Google Git
Sign in
android/platform/frameworks/opt/gamesdk/refs/heads/android10-dev^2..refs/heads/android10-dev/.
commit
222ea766a65999e619da08f0fda0f7af7a34ed08
[log] [tgz]
author
Bill Rassieur <[email protected]>
Wed Apr 03 16:44:44 2019 -0700
committer
android-build-merger <[email protected]>
Wed Apr 03 16:44:44 2019 -0700
tree
24f341afa3b56079c9cf6e8d1f3828113434ea10
parent
db3c0ac544ca25421a389b4d82d7750df4fb4927 [diff]
parent
fcebb73df91e648c1ae469713fe1886c727db01b [diff]
Merge master@5406228 into git_qt-dev-plus-aosp.
am: fcebb73df9

Change-Id: I407757aa7705628164700aca9266057430b422e6

diff --git a/include/tuningfork/tuningfork.h b/include/tuningfork/tuningfork.h
index 4b26fa1..24ff52f 100644
--- a/include/tuningfork/tuningfork.h
+++ b/include/tuningfork/tuningfork.h

@@ -19,6 +19,10 @@
 #include <stdint.h>
 #include <jni.h>
 
+#define TUNINGFORK_MAJOR_VERSION 0
+#define TUNINGFORK_MINOR_VERSION 1
+#define TUNINGFORK_PACKED_VERSION ((TUNINGFORK_MAJOR_VERSION<<16)|(TUNINGFORK_MINOR_VERSION))
+
 // These are reserved instrumentation keys
 enum {
     TFTICK_SYSCPU = 0,

diff --git a/samples/bouncyball/build.gradle b/samples/bouncyball/build.gradle
index cf1d23d..4699ea7 100644
--- a/samples/bouncyball/build.gradle
+++ b/samples/bouncyball/build.gradle

@@ -6,7 +6,7 @@
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.4.0-beta05'
+        classpath 'com.android.tools.build:gradle:3.3.2'
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
     }

diff --git a/samples/cube/build.gradle b/samples/cube/build.gradle
index cf1d23d..4699ea7 100644
--- a/samples/cube/build.gradle
+++ b/samples/cube/build.gradle

@@ -6,7 +6,7 @@
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.4.0-beta05'
+        classpath 'com.android.tools.build:gradle:3.3.2'
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
     }

diff --git a/samples/tuningfork/tftestapp/app/src/main/cpp/Renderer.cpp b/samples/tuningfork/tftestapp/app/src/main/cpp/Renderer.cpp
index e1c0197..ddf8dac 100644
--- a/samples/tuningfork/tftestapp/app/src/main/cpp/Renderer.cpp
+++ b/samples/tuningfork/tftestapp/app/src/main/cpp/Renderer.cpp

@@ -32,9 +32,12 @@
 
 #include "swappy/swappy.h"
 #include "swappy/swappy_extra.h"
+#include "tuningfork/tuningfork.h"
 
 #include "Scene.h"
 
+extern bool swappy_enabled;
+
 using namespace std::chrono_literals;
 
 namespace samples {
@@ -48,7 +51,7 @@
     enqueue([=](State* state) {
         state->clearSurface();
 
-        ALOGE("Creating window surface %dx%d", width, height);
+        ALOGI("Creating window surface %dx%d", width, height);
 
         if (!window) return;
 
@@ -227,7 +230,8 @@
         return;
     }
 
-    Swappy_recordFrameStart(state->display, state->surface);
+    if (swappy_enabled)
+        Swappy_recordFrameStart(state->display, state->surface);
 
     calculateFps();
 
@@ -252,7 +256,12 @@
 
     state->scene.draw(aspectRatio, mTesselation);
 
-    Swappy_swap(state->display, state->surface);
+    if (swappy_enabled)
+        Swappy_swap(state->display, state->surface);
+    else {
+        TuningFork_frameTick(TFTICK_SYSCPU);
+        eglSwapBuffers(state->display, state->surface);
+    }
 
     // If we're still started, request another frame
     requestDraw();

diff --git a/samples/tuningfork/tftestapp/app/src/main/cpp/tftestapp.cpp b/samples/tuningfork/tftestapp/app/src/main/cpp/tftestapp.cpp
index e160f12..7ec2737 100644
--- a/samples/tuningfork/tftestapp/app/src/main/cpp/tftestapp.cpp
+++ b/samples/tuningfork/tftestapp/app/src/main/cpp/tftestapp.cpp

@@ -36,6 +36,8 @@
 namespace tf = tuningfork;
 using namespace samples;
 
+bool swappy_enabled = false;
+
 namespace {
 
 constexpr TFInstrumentKey TFTICK_CHOREOGRAPHER = 4;
@@ -116,6 +118,9 @@
     if (evt.has_apk_version_code()) {
         eventStr << "  apk_version_code : " << evt.apk_version_code() << "\n";
     }
+    if (evt.has_tuningfork_version()) {
+        eventStr << "  tuningfork_version : " << evt.tuningfork_version() << "\n";
+    }
     eventStr << "}";
     return eventStr.str();
 }
@@ -181,7 +186,8 @@
 JNIEXPORT void JNICALL
 Java_com_google_tuningfork_TFTestActivity_initTuningFork(JNIEnv *env, jobject activity) {
     Swappy_init(env, activity);
-    if (Swappy_isEnabled()) {
+    swappy_enabled = Swappy_isEnabled();
+    if (swappy_enabled) {
         int defaultFPIndex = 3; // i.e. dev_tuningfork_fidelityparams_3.bin
         int initialTimeoutMs = 1000;
         int ultimateTimeoutMs = 100000;
@@ -196,7 +202,29 @@
             ALOGW("Error initializing TuningFork: %d", c);
         }
     } else {
-        ALOGW("Couldn't enable Swappy. Tuning Fork is not enabled either");
+        ALOGW("Couldn't enable Swappy.");
+        CProtobufSerialization settings = {};
+        TuningFork_findSettingsInAPK(env, activity, &settings);
+        TuningFork_init(&settings, env, activity);
+        tuningfork::CProtobufSerialization_Free(&settings);
+        int fp_count;
+        TuningFork_findFidelityParamsInAPK(env, activity, NULL, &fp_count);
+        CProtobufSerialization fps = {};
+        std::vector<CProtobufSerialization> defaultFPs(fp_count);
+        TuningFork_findFidelityParamsInAPK(env, activity, defaultFPs.data(), &fp_count);
+        CProtobufSerialization* defaultFP = &defaultFPs[fp_count/2-1]; // Middle settings level
+        if (TuningFork_getFidelityParameters(defaultFP, &fps, 1000)) {
+            SetFidelityParams(&fps);
+            tuningfork::CProtobufSerialization_Free(&fps);
+        }
+        else {
+            SetFidelityParams(defaultFP);
+        }
+        for(auto& a: defaultFPs) {
+            tuningfork::CProtobufSerialization_Free(&a);
+        }
+        TuningFork_setUploadCallback(UploadCallback);
+        SetAnnotations();
     }
 }
 

diff --git a/samples/tuningfork/tftestapp/build.gradle b/samples/tuningfork/tftestapp/build.gradle
index b9017fb..798ee14 100644
--- a/samples/tuningfork/tftestapp/build.gradle
+++ b/samples/tuningfork/tftestapp/build.gradle

@@ -7,7 +7,7 @@
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.4.0-beta05'
+        classpath 'com.android.tools.build:gradle:3.3.2'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

diff --git a/src/swappy/Swappy.cpp b/src/swappy/Swappy.cpp
index fa4ea2b..d4a32d3 100644
--- a/src/swappy/Swappy.cpp
+++ b/src/swappy/Swappy.cpp

@@ -78,6 +78,12 @@
             displayClass,
             "getAppVsyncOffsetNanos", "()J");
 
+    // getAppVsyncOffsetNanos was only added in API 21.
+    // Return gracefully if this device doesn't support it.
+    if (getAppVsyncOffsetNanos == 0 || env->ExceptionOccurred()) {
+        env->ExceptionClear();
+        return;
+    }
     const long appVsyncOffsetNanos = env->CallLongMethod(display, getAppVsyncOffsetNanos);
 
     jmethodID getPresentationDeadlineNanos = env->GetMethodID(

diff --git a/src/swappyVk/SwappyVk.cpp b/src/swappyVk/SwappyVk.cpp
index cc6877d..9c0a5a3 100644
--- a/src/swappyVk/SwappyVk.cpp
+++ b/src/swappyVk/SwappyVk.cpp

@@ -199,12 +199,14 @@
     PFN_AChoreographer_postFrameCallbackDelayed mAChoreographer_postFrameCallbackDelayed = nullptr;
 
     long mFrameID = 0;
-    long mLastframeTimeNanos = 0;
+    long mTargetFrameID = 0;
+    uint64_t mLastframeTimeNanos = 0;
     long mSumRefreshTime = 0;
     long mSamples = 0;
+    long mCallbacksBeforeIdle = 0;
 
-    static constexpr int CHOREOGRAPHER_THRESH = 1000;
     static constexpr int MAX_SAMPLES = 5;
+    static constexpr int MAX_CALLBACKS_BEFORE_IDLE = 10;
 
     void initGoogExtention()
     {
@@ -222,7 +224,8 @@
     void *looperThread();
     static void frameCallback(long frameTimeNanos, void *data);
     void onDisplayRefresh(long frameTimeNanos);
-    void calcRefreshRate(long frameTimeNanos);
+    void calcRefreshRate(uint64_t currentTime);
+    void postChoreographerCallback();
 };
 
 void SwappyVkBase::startChoreographerThread() {
@@ -279,24 +282,37 @@
 
 void SwappyVkBase::onDisplayRefresh(long frameTimeNanos) {
     std::lock_guard<std::mutex> lock(mWaitingMutex);
-    calcRefreshRate(frameTimeNanos);
-    mLastframeTimeNanos = frameTimeNanos;
+    struct timespec currTime;
+    clock_gettime(CLOCK_MONOTONIC, &currTime);
+    uint64_t currentTime =
+            ((uint64_t) currTime.tv_sec * kBillion) + (uint64_t) currTime.tv_nsec;
+
+    calcRefreshRate(currentTime);
+    mLastframeTimeNanos = currentTime;
     mFrameID++;
     mWaitingCondition.notify_all();
+
+    // queue the next frame callback
+    if (mCallbacksBeforeIdle > 0) {
+        mCallbacksBeforeIdle--;
+        mAChoreographer_postFrameCallbackDelayed(mChoreographer, frameCallback, this, 1);
+    }
 }
 
-void SwappyVkBase::calcRefreshRate(long frameTimeNanos) {
-  long refresh_nano = std::abs(frameTimeNanos - mLastframeTimeNanos);
+void SwappyVkBase::postChoreographerCallback() {
+    if (mCallbacksBeforeIdle == 0) {
+        mAChoreographer_postFrameCallbackDelayed(mChoreographer, frameCallback, this, 1);
+    }
+    mCallbacksBeforeIdle = MAX_CALLBACKS_BEFORE_IDLE;
+}
+
+void SwappyVkBase::calcRefreshRate(uint64_t currentTime) {
+    long refresh_nano = currentTime - mLastframeTimeNanos;
 
     if (mRefreshDur != 0 || mLastframeTimeNanos == 0) {
         return;
     }
 
-    // ignore wrap around
-    if (mLastframeTimeNanos > frameTimeNanos) {
-        return;
-    }
-
     mSumRefreshTime += refresh_nano;
     mSamples++;
 
@@ -662,7 +678,10 @@
     mPendingSync[queue].pop_front();
     mWaitingCondition.wait(lock, [&]() {
         if (vkWaitForFences(mDevice, 1, &sync.fence, VK_TRUE, 0) == VK_TIMEOUT) {
-            mAChoreographer_postFrameCallbackDelayed(mChoreographer, frameCallback, this, 1);
+            postChoreographerCallback();
+
+            // adjust the target frame here as we are waiting additional frame for the fence
+            mTargetFrameID++;
             return false;
         }
         return true;
@@ -681,19 +700,11 @@
         return ret;
     }
 
-    struct timespec currTime;
-    clock_gettime(CLOCK_MONOTONIC, &currTime);
-    uint64_t currentTime =
-            ((uint64_t) currTime.tv_sec * kBillion) + (uint64_t) currTime.tv_nsec;
-
-    // do we have something in the queue ?
-    if (mNextDesiredPresentTime > currentTime) {
+    {
         std::unique_lock<std::mutex> lock(mWaitingMutex);
-        long target = mFrameID + mInterval;
         mWaitingCondition.wait(lock, [&]() {
-            if (mFrameID < target) {
-                // wait for the next frame as this frame is too soon
-                mAChoreographer_postFrameCallbackDelayed(mChoreographer, frameCallback, this, 1);
+            if (mFrameID < mTargetFrameID) {
+                postChoreographerCallback();
                 return false;
             }
             return true;
@@ -704,10 +715,12 @@
         waitForFenceChoreographer(queue);
     }
 
-    clock_gettime(CLOCK_MONOTONIC, &currTime);
-    currentTime =
-            ((uint64_t) currTime.tv_sec * kBillion) + (uint64_t) currTime.tv_nsec;
-    mNextDesiredPresentTime = currentTime + mRefreshDur * mInterval;
+    // Adjust the presentation time based on the current frameID we are at.
+    if(mFrameID < mTargetFrameID) {
+        ALOGE("Bad frame ID %ld < target %ld", mFrameID, mTargetFrameID);
+        mTargetFrameID = mFrameID;
+    }
+    mNextDesiredPresentTime += (mFrameID - mTargetFrameID) * mRefreshDur;
 
     // Setup the new structures to pass:
     VkPresentTimeGOOGLE pPresentTimes[pPresentInfo->swapchainCount];
@@ -750,6 +763,11 @@
                                                pPresentInfo->pImageIndices, pPresentInfo->pResults};
     ret = mpfnQueuePresentKHR(queue, &replacementPresentInfo);
 
+    // next present time is going to be 2 intervals from now, leaving 1 interval for cpu work
+    // and 1 interval for gpu work
+    mNextDesiredPresentTime = mLastframeTimeNanos + 2 * mRefreshDur * mInterval;
+    mTargetFrameID = mFrameID + mInterval;
+
     return ret;
 }
 
@@ -785,7 +803,7 @@
         std::unique_lock<std::mutex> lock(mWaitingMutex);
         mWaitingCondition.wait(lock, [&]() {
             if (mRefreshDur == 0) {
-                mAChoreographer_postFrameCallbackDelayed(mChoreographer, frameCallback, this, 1);
+                postChoreographerCallback();
                 return false;
             }
             return true;
@@ -804,19 +822,17 @@
                                     const VkPresentInfoKHR* pPresentInfo) override
     {
         {
-            const long target = mFrameID + mInterval;
             std::unique_lock<std::mutex> lock(mWaitingMutex);
 
-
             mWaitingCondition.wait(lock, [&]() {
-                if (mFrameID < target) {
-                    // wait for the next frame as this frame is too soon
-                    mAChoreographer_postFrameCallbackDelayed(mChoreographer, frameCallback, this, 1);
+                if (mFrameID < mTargetFrameID) {
+                    postChoreographerCallback();
                     return false;
                 }
                 return true;
             });
         }
+        mTargetFrameID = mFrameID + mInterval;
         return mpfnQueuePresentKHR(queue, pPresentInfo);
     }
 };

diff --git a/src/tuningfork/clearcutserializer.cpp b/src/tuningfork/clearcutserializer.cpp
index 481e042..fc11b30 100644
--- a/src/tuningfork/clearcutserializer.cpp
+++ b/src/tuningfork/clearcutserializer.cpp

@@ -45,11 +45,8 @@
     std::vector<uint64_t>* v = static_cast<std::vector<uint64_t>*>(*arg);
     // Encode each item
     for (int i = 0; i < v->size(); ++i) {
-        if(!pb_encode_tag(stream, PB_WT_STRING,
-                          logs_proto_tuningfork_DeviceInfo_cpu_max_freq_hz_tag))
-            return false;
-        if(!pb_encode_varint(stream, (*v)[i]))
-            return false;
+        pb_encode_tag_for_field(stream, field);
+        pb_encode_varint(stream, (*v)[i]);
     }
     return true;
 }
@@ -136,6 +133,8 @@
     evt.apk_package_name.arg = (void*)&info.apk_package_name;
     evt.has_apk_version_code = true;
     evt.apk_version_code = info.apk_version_code;
+    evt.has_tuningfork_version = true;
+    evt.tuningfork_version = info.tuningfork_version;
 }
 
 void ClearcutSerializer::FillHistograms(const ProngCache& pc, TuningForkLogEvent &evt) {

diff --git a/src/tuningfork/proto/tuningfork_clearcut_log.proto b/src/tuningfork/proto/tuningfork_clearcut_log.proto
index 648bdd5..813914c 100644
--- a/src/tuningfork/proto/tuningfork_clearcut_log.proto
+++ b/src/tuningfork/proto/tuningfork_clearcut_log.proto

@@ -48,6 +48,9 @@
 
   // Version code from APK manifest.
   optional int32 apk_version_code = 7;
+
+  // Tuning fork version (upper 16 bits: major, lower 16 bits minor)
+  optional int32 tuningfork_version = 8;
 }
 
 message TuningForkHistogram {

diff --git a/src/tuningfork/tools/validation/build.gradle b/src/tuningfork/tools/validation/build.gradle
new file mode 100644
index 0000000..21b69de
--- /dev/null
+++ b/src/tuningfork/tools/validation/build.gradle

@@ -0,0 +1,66 @@
+apply plugin: 'java'
+apply plugin: 'com.google.protobuf'
+
+repositories {
+    mavenCentral()
+    google()
+    jcenter()
+}
+
+sourceSets {
+    main {
+        proto {
+            include '../../proto/tuningfork.proto'
+        }
+    }
+    test {
+        java {
+            exclude '**'
+        }
+    }
+}
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.8'
+    }
+}
+
+dependencies {
+    compile 'com.google.guava:guava:26.0-jre'
+    compile 'com.google.protobuf:protobuf-java:3.5.1'
+    compile 'com.google.flogger:flogger:0.3.1'
+    compile 'com.google.flogger:flogger-system-backend:0.3.1'
+    compile 'com.beust:jcommander:1.7'
+
+    testCompile 'junit:junit:4.12'
+    testCompile 'com.google.truth:truth:0.43'
+    testCompile 'org.junit.jupiter:junit-jupiter:5.4.1'
+
+    protobuf files('../../proto/tuningfork.proto')
+}
+
+protobuf {
+    protoc {
+        //Download from repo
+        artifact = 'com.google.protobuf:protoc:3.0.0'
+    }
+}
+
+task createJar(type: Jar) {
+    manifest {
+        attributes 'Implementation-Title': 'Gradle Jar',
+            'Implementation-Version': 1.0,
+            'Main-Class': 'com.google.tuningfork.validation.TuningforkApkValidationTool'
+    }
+    baseName = 'TuningforkApkValidationTool'
+    from {
+        configurations.compile.collect {
+            it.isDirectory()? it:zipTree(it)
+        }
+    }
+    with jar
+}
\ No newline at end of file

diff --git a/src/tuningfork/tools/validation/gradlew b/src/tuningfork/tools/validation/gradlew
new file mode 100755
index 0000000..cccdd3d
--- /dev/null
+++ b/src/tuningfork/tools/validation/gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

diff --git a/src/tuningfork/tools/validation/gradlew.bat b/src/tuningfork/tools/validation/gradlew.bat
new file mode 100644
index 0000000..e95643d
--- /dev/null
+++ b/src/tuningfork/tools/validation/gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off

+@rem ##########################################################################

+@rem

+@rem  Gradle startup script for Windows

+@rem

+@rem ##########################################################################

+

+@rem Set local scope for the variables with windows NT shell

+if "%OS%"=="Windows_NT" setlocal

+

+set DIRNAME=%~dp0

+if "%DIRNAME%" == "" set DIRNAME=.

+set APP_BASE_NAME=%~n0

+set APP_HOME=%DIRNAME%

+

+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.

+set DEFAULT_JVM_OPTS=

+

+@rem Find java.exe

+if defined JAVA_HOME goto findJavaFromJavaHome

+

+set JAVA_EXE=java.exe

+%JAVA_EXE% -version >NUL 2>&1

+if "%ERRORLEVEL%" == "0" goto init

+

+echo.

+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

+echo.

+echo Please set the JAVA_HOME variable in your environment to match the

+echo location of your Java installation.

+

+goto fail

+

+:findJavaFromJavaHome

+set JAVA_HOME=%JAVA_HOME:"=%

+set JAVA_EXE=%JAVA_HOME%/bin/java.exe

+

+if exist "%JAVA_EXE%" goto init

+

+echo.

+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%

+echo.

+echo Please set the JAVA_HOME variable in your environment to match the

+echo location of your Java installation.

+

+goto fail

+

+:init

+@rem Get command-line arguments, handling Windows variants

+

+if not "%OS%" == "Windows_NT" goto win9xME_args

+

+:win9xME_args

+@rem Slurp the command line arguments.

+set CMD_LINE_ARGS=

+set _SKIP=2

+

+:win9xME_args_slurp

+if "x%~1" == "x" goto execute

+

+set CMD_LINE_ARGS=%*

+

+:execute

+@rem Setup the command line

+

+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar

+

+@rem Execute Gradle

+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%

+

+:end

+@rem End local scope for the variables with windows NT shell

+if "%ERRORLEVEL%"=="0" goto mainEnd

+

+:fail

+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of

+rem the _cmd.exe /c_ return code!

+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1

+exit /b 1

+

+:mainEnd

+if "%OS%"=="Windows_NT" endlocal

+

+:omega


diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ApkConfig.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ApkConfig.java
index fd35f3b..347fa76 100644
--- a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ApkConfig.java
+++ b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ApkConfig.java

@@ -25,6 +25,8 @@
   public static final String ASSETS_DIRECTORY = "assets/tuningfork/";
 
   public static final String DEV_TUNINGFORK_PROTO = ASSETS_DIRECTORY + "dev_tuningfork.proto";
+  public static final String DEV_TUNINGFORK_PROTO_DESCRIPTOR =
+      ASSETS_DIRECTORY + "dev_tuningfork.descriptor";
   public static final String TUNINGFORK_SETTINGS = ASSETS_DIRECTORY + "tuningfork_settings.bin";
   public static final Pattern DEV_FIDELITY_PATTERN =
       Pattern.compile(ASSETS_DIRECTORY + "dev_tuningfork_fidelityparams_.{1,15}.bin");

diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/DeveloperTuningforkParser.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/DeveloperTuningforkParser.java
index dab5889..d1c447e 100644
--- a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/DeveloperTuningforkParser.java
+++ b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/DeveloperTuningforkParser.java

@@ -19,10 +19,8 @@
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.LinkedListMultimap;
-import com.google.common.collect.ListMultimap;
 import com.google.common.flogger.FluentLogger;
-import com.google.common.io.ByteStreams;
+import com.google.common.io.Files;
 import com.google.protobuf.ByteString;
 import com.google.protobuf.Descriptors.Descriptor;
 import com.google.protobuf.Descriptors.FileDescriptor;
@@ -30,45 +28,44 @@
 import java.io.File;
 import java.io.IOException;
 import java.util.Optional;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
+import java.util.regex.Pattern;
 
-/** Tuningfork validation tool.
- * Parses proto and settings files and validates them. */
+/** Tuningfork validation tool. Parses proto and settings files and validates them. */
 public class DeveloperTuningforkParser {
 
-  private Optional<String> devTuningfork = Optional.empty();
-  private Optional<ByteString> tuningforkSettings = Optional.empty();
-  private final ListMultimap<String, ByteString> devFidelityParams = LinkedListMultimap.create();
+  private Optional<File> devTuningforkProto = Optional.empty();
+  private Optional<String> tuningforkSettings = Optional.empty();
+  private ImmutableList<File> devFidelityFiles;
 
   private final ErrorCollector errors;
-  private final File protocBinary;
+  private final ExternalProtoCompiler compiler;
+  private final File folder;
 
   private static final FluentLogger logger = FluentLogger.forEnclosingClass();
 
-  public DeveloperTuningforkParser(ErrorCollector errors, File protocBinary) {
+  public DeveloperTuningforkParser(ErrorCollector errors, File folder, File protocBinary) {
     this.errors = errors;
-    this.protocBinary = protocBinary;
+    this.folder = folder;
+    this.compiler = new ExternalProtoCompiler(protocBinary);
   }
 
-  public void parseJarEntry(JarFile apk, JarEntry file) throws IOException {
-    if (file.getName().equals(ApkConfig.DEV_TUNINGFORK_PROTO)) {
-      String content = new String(ByteStreams.toByteArray(apk.getInputStream(file)), UTF_8);
-      devTuningfork = Optional.of(content);
-    } else if (file.getName().equals(ApkConfig.TUNINGFORK_SETTINGS)) {
-      ByteString content = ByteString.readFrom(apk.getInputStream(file));
-      tuningforkSettings = Optional.of(content);
-    } else if (ApkConfig.DEV_FIDELITY_PATTERN.matcher(file.getName()).find()) {
-      ByteString content = ByteString.readFrom(apk.getInputStream(file));
-      devFidelityParams.put(file.getName(), content);
-    }
+  public void parseFilesInFolder() throws IOException {
+    devTuningforkProto = findDevTuningforkProto(folder);
+    tuningforkSettings = findTuningforkSettings(folder);
+    devFidelityFiles = findDevFidelityParams(folder);
   }
 
-  /** Validate protos and settings.*/
   public void validate() throws IOException, CompilationException {
+    if (devTuningforkProto.isPresent()) {
+      logger.atInfo().log("File %s exists: OK", FolderConfig.DEV_TUNINGFORK_PROTO);
+    } else {
+      logger.atSevere().log("File %s exists: FAIL", FolderConfig.DEV_TUNINGFORK_PROTO);
+    }
+
+    File descriptorFile = new File(folder, FolderConfig.DEV_TUNINGFORK_DESCRIPTOR);
 
     FileDescriptor devTuningforkFileDesc =
-        ProtoHelper.compileContent(devTuningfork.get(), protocBinary);
+        compiler.compile(devTuningforkProto.get(), Optional.of(descriptorFile));
     Descriptor annotationField = devTuningforkFileDesc.findMessageTypeByName("Annotation");
     Descriptor fidelityField = devTuningforkFileDesc.findMessageTypeByName("FidelityParams");
 
@@ -79,16 +76,118 @@
     logger.atInfo().log("Loaded Annotation message:\n" + annotationField.toProto());
     logger.atInfo().log("Loaded FidelityParams message:\n" + fidelityField.toProto());
 
-    // Validate settings only if annotations are valid
-    if (!errors.hasAnnotationErrors()) {
-      ValidationUtil.validateSettings(enumSizes, tuningforkSettings.get(), errors);
-      Settings settings = Settings.parseFrom(tuningforkSettings.get());
-      logger.atInfo().log("Loaded settings:\n" + settings);
+    validateAndSaveBinarySettings(enumSizes);
+    encodeBinaryAndValidateDevFidelity(fidelityField);
+  }
+
+  private void validateAndSaveBinarySettings(ImmutableList<Integer> enumSizes) {
+    if (tuningforkSettings.isPresent()) {
+      logger.atInfo().log("File %s exists: OK", FolderConfig.TUNINGFORK_SETTINGS_TEXTPROTO);
+    } else {
+      logger.atSevere().log("File %s exists: FAIL", FolderConfig.TUNINGFORK_SETTINGS_TEXTPROTO);
     }
 
-    // Validate devFidelityOnly only if fidelity parameters are valid
-    if (!errors.hasFidelityParamsErrors()) {
-      ValidationUtil.validateDevFidelityParams(devFidelityParams.values(), fidelityField, errors);
+    if (errors.hasAnnotationErrors()) {
+      logger.atSevere().log(
+          "Skip %s file check as Annotation is not valid",
+          FolderConfig.TUNINGFORK_SETTINGS_TEXTPROTO);
     }
+
+    Optional<Settings> settings =
+        ValidationUtil.validateSettings(enumSizes, tuningforkSettings.get(), errors);
+
+    if (errors.hasSettingsErrors() || !settings.isPresent()) {
+      logger.atSevere().log(
+          "Skip saving %s file as %s contains errors",
+          FolderConfig.TUNINGFORK_SETTINGS_BINARY, FolderConfig.TUNINGFORK_SETTINGS_TEXTPROTO);
+    }
+
+    logger.atInfo().log("Loaded settings:\n" + settings.get());
+
+    saveBinarySettings(settings.get());
+  }
+
+  private void saveBinarySettings(Settings settings) {
+    File outFile = new File(folder, FolderConfig.TUNINGFORK_SETTINGS_BINARY);
+    try {
+      Files.write(settings.toByteArray(), outFile);
+    } catch (IOException e) {
+      logger.atSevere().withCause(e).log(
+          "Error writing settings to %s file", FolderConfig.TUNINGFORK_SETTINGS_BINARY);
+    }
+  }
+
+  private void encodeBinaryAndValidateDevFidelity(Descriptor fidelityField) {
+    if (!devFidelityFiles.isEmpty()) {
+      logger.atInfo().log(
+          "%d %s files found: OK\n %s",
+          devFidelityFiles.size(),
+          FolderConfig.DEV_FIDELITY_TEXTPROTO,
+          devFidelityFiles.toString());
+    } else {
+      logger.atSevere().log("%s files found: FAIL", FolderConfig.DEV_FIDELITY_TEXTPROTO);
+    }
+
+    if (errors.hasFidelityParamsErrors()) {
+      logger.atSevere().log(
+          "Skip %s files check as FidelityParams message is not valid",
+          FolderConfig.DEV_FIDELITY_TEXTPROTO);
+    }
+
+    devFidelityFiles.forEach(
+        textprotoFile -> encodeBinaryAndValidateDevFidelity(fidelityField, textprotoFile));
+  }
+
+  private void encodeBinaryAndValidateDevFidelity(Descriptor fidelityField, File textprotoFile) {
+    File binaryFile;
+    try {
+      binaryFile =
+          compiler.encodeFromTextprotoFile(
+              fidelityField.getFullName(),
+              devTuningforkProto.get(),
+              textprotoFile,
+              getBinaryPathForTextprotoPath(textprotoFile),
+              Optional.empty());
+    } catch (IOException | CompilationException e) {
+      errors.addError(
+          ErrorType.DEV_FIDELITY_PARAMETERS_ENCODING,
+          String.format("Encoding %s file", textprotoFile.getName()),
+          e);
+      return;
+    }
+    ByteString content;
+    try {
+      content = ByteString.copyFrom(Files.toByteArray(binaryFile));
+    } catch (IOException e) {
+      errors.addError(
+          ErrorType.DEV_FIDELITY_PARAMETERS_READING,
+          String.format("Reading %s file", binaryFile.getName()),
+          e);
+      return;
+    }
+    ValidationUtil.validateDevFidelityParams(content, fidelityField, errors);
+  }
+
+  private static String getBinaryPathForTextprotoPath(File textprotoFile) {
+    return textprotoFile.getParentFile().getAbsolutePath()
+        + "/"
+        + textprotoFile.getName().replace(".txt", ".bin");
+  }
+
+  private static Optional<File> findDevTuningforkProto(File folder) throws IOException {
+    File file = new File(folder, FolderConfig.DEV_TUNINGFORK_PROTO);
+    return Optional.of(file);
+  }
+
+  private static Optional<String> findTuningforkSettings(File folder) throws IOException {
+    File file = new File(folder, FolderConfig.TUNINGFORK_SETTINGS_TEXTPROTO);
+    String content = Files.asCharSource(file, UTF_8).read();
+    return Optional.of(content);
+  }
+
+  private static ImmutableList<File> findDevFidelityParams(File folder) throws IOException {
+    Pattern devFidelityPattern = Pattern.compile(FolderConfig.DEV_FIDELITY_TEXTPROTO);
+    return ImmutableList.copyOf(
+        folder.listFiles((dir, filename) -> devFidelityPattern.matcher(filename).find()));
   }
 }

diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ErrorCollector.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ErrorCollector.java
index 95cafb8..05f1a44 100644
--- a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ErrorCollector.java
+++ b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ErrorCollector.java

@@ -30,9 +30,13 @@
 
   void printStatus();
 
+  Boolean hasErrors(ErrorType.ErrorGroup group);
+
   Boolean hasAnnotationErrors();
 
   Boolean hasFidelityParamsErrors();
 
+  Boolean hasSettingsErrors();
+
   Multimap<ErrorType, String> getErrors();
 };

diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ErrorType.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ErrorType.java
index ca7f8ec..c72dd27 100644
--- a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ErrorType.java
+++ b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ErrorType.java

@@ -18,23 +18,52 @@
 
 /** Validation errors */
 public enum ErrorType {
-  ANNOTATION_EMPTY, // Annotation field is empty
-  ANNOTATION_COMPLEX, // Annotation field is too complex - contains oneofs/nestedtypes/extensions
-  ANNOTATION_TYPE, // Annotation must contains enums only
+  // Annotation field is empty
+  ANNOTATION_EMPTY(ErrorGroup.ANNOTATION),
+  // Annotation field is too complex - contains oneofs/nestedtypes/extensions
+  ANNOTATION_COMPLEX(ErrorGroup.ANNOTATION),
+  // Annotation must contains enums only
+  ANNOTATION_TYPE(ErrorGroup.ANNOTATION),
+  // FidelityParams fied is empty
+  FIDELITY_PARAMS_EMPTY(ErrorGroup.FIDELITY),
+  // FidelityParams field is complex - contains  oneof/nestedtypes/extensions
+  FIDELITY_PARAMS_COMPLEX(ErrorGroup.FIDELITY),
+  // FidelityParams can only contains float, int32 or enum
+  FIDELITY_PARAMS_TYPE(ErrorGroup.FIDELITY),
+  // Fidelity parameters are empty
+  DEV_FIDELITY_PARAMETERS_EMPTY(ErrorGroup.DEV_FIDELITY),
+  // Fidelity parameters parsing error
+  DEV_FIDELITY_PARAMETERS_PARSING(ErrorGroup.DEV_FIDELITY),
+  // Fidelity parameters encoding textproto file
+  DEV_FIDELITY_PARAMETERS_ENCODING(ErrorGroup.DEV_FIDELITY),
+  // Fidelity parameters reading file
+  DEV_FIDELITY_PARAMETERS_READING(ErrorGroup.DEV_FIDELITY),
+  // Parsing error
+  SETTINGS_PARSING(ErrorGroup.SETTINGS),
+  // Histogram field is empty
+  HISTOGRAM_EMPTY(ErrorGroup.SETTINGS),
+  // Aggreagtion field is empty
+  AGGREGATION_EMPTY(ErrorGroup.SETTINGS),
+  // Aggregation contains incorrect  max_instrumentation_keys field
+  AGGREGATION_INSTRUMENTATION_KEY(ErrorGroup.SETTINGS),
+  // Aggregation contains incorrect annotation_enum_sizes
+  AGGREGATION_ANNOTATIONS(ErrorGroup.SETTINGS);
 
-  FIDELITY_PARAMS_EMPTY, // FidelityParams fied is empty
-  FIDELITY_PARAMS_COMPLEX, // FidelityParams field is complex - contains
-                           // oneof/nestedtypes/extensions
-  FIDELITY_PARAMS_TYPE, // FidelityParams can only contains float, int32 or enum
+  private final ErrorGroup group;
 
-  DEV_FIDELITY_PARAMETERS_EMPTY, // Fidelity parameters are empty
-  DEV_FIDELITY_PARAMETERS_PARSING, // Fidelity parameters parsing error
+  public ErrorGroup getGroup() {
+    return group;
+  }
 
-  SETTINGS_PARSING, // Parsing error
+  ErrorType(ErrorGroup group) {
+    this.group = group;
+  }
 
-  HISTOGRAM_EMPTY, // Histogram field is empty
-
-  AGGREGATION_EMPTY, // Aggreagtion field is empty
-  AGGREGATION_INSTRUMENTATION_KEY, // Aggregation contains incorrect max_instrumentation_keys field
-  AGGREGATION_ANNOTATIONS, // Aggregation contains incorrect annotation_enum_sizes
+  /** Validation group of errors */
+  public enum ErrorGroup {
+    ANNOTATION,
+    FIDELITY,
+    DEV_FIDELITY,
+    SETTINGS,
+  }
 };

diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ExternalProtoCompiler.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ExternalProtoCompiler.java
index b35e667..d8f8c84 100644
--- a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ExternalProtoCompiler.java
+++ b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ExternalProtoCompiler.java

@@ -1,9 +1,24 @@
-// Copyright 2009 Google Inc. All Rights Reserved.
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
 
 package com.google.tuningfork.validation;
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
+import com.google.common.io.Files;
 import com.google.protobuf.DescriptorProtos.FileDescriptorProto;
 import com.google.protobuf.DescriptorProtos.FileDescriptorSet;
 import com.google.protobuf.Descriptors.DescriptorValidationException;
@@ -12,7 +27,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.List;
+import java.util.Optional;
 
 /** Compiles .proto file into a {@link FileDescriptor} */
 public class ExternalProtoCompiler {
@@ -25,14 +40,15 @@
     protoPath = protoBinary.getAbsolutePath();
   }
 
-  public FileDescriptor compile(File file) throws IOException, CompilationException {
+  public FileDescriptor compile(File file, Optional<File> outFile)
+      throws IOException, CompilationException {
     Preconditions.checkNotNull(file, "file");
-    FileDescriptor descriptor = buildAndRunCompilerProcess(file);
+    FileDescriptor descriptor = buildAndRunCompilerProcess(file, outFile);
     return descriptor;
   }
 
-  public byte[] runCommand(List<String> commandLine) throws IOException, CompilationException {
-    Process process = new ProcessBuilder(commandLine).start();
+  public byte[] runCommand(ProcessBuilder processBuilder) throws IOException, CompilationException {
+    Process process = processBuilder.start();
     try {
       process.waitFor();
     } catch (InterruptedException e) {
@@ -44,13 +60,16 @@
     return result;
   }
 
-  private FileDescriptor buildAndRunCompilerProcess(File file)
+  private FileDescriptor buildAndRunCompilerProcess(File file, Optional<File> outFile)
       throws IOException, CompilationException {
-    List<String> commandLine = createCommandLine(file);
-    byte[] result = runCommand(commandLine);
+    ImmutableList<String> commandLine = createCommandLine(file);
+    byte[] result = runCommand(new ProcessBuilder(commandLine));
 
     try {
       FileDescriptorSet fileSet = FileDescriptorSet.parseFrom(result);
+      if (outFile.isPresent()) {
+        Files.write(fileSet.toByteArray(), outFile.get());
+      }
       for (FileDescriptorProto descProto : fileSet.getFileList()) {
         if (descProto.getName().equals(file.getName())) {
           return FileDescriptor.buildFrom(descProto, emptyDeps);
@@ -63,7 +82,49 @@
         String.format("Descriptor for [%s] does not exist.", file.getName()));
   }
 
-  private List<String> createCommandLine(File file) {
+  /* Decode textproto message from text(textprotoFile) into binary(binFile) */
+  public File encodeFromTextprotoFile(
+      String message,
+      File protoFile,
+      File textprotoFile,
+      String binaryPath,
+      Optional<File> errorFile)
+      throws IOException, CompilationException {
+    ImmutableList<String> command = encodeCommandLine(message, protoFile);
+
+    File binFile = new File(binaryPath);
+
+    ProcessBuilder builder =
+        new ProcessBuilder(command).redirectInput(textprotoFile).redirectOutput(binFile);
+
+    if (errorFile.isPresent()) {
+      builder.redirectError(errorFile.get());
+    }
+
+    runCommand(builder);
+    return binFile;
+  }
+
+  /* Decode textproto message from binary(binFile) into text(textFile) */
+  public File decodeToTextprotoFile(
+      String message, File protoFile, String textprotoPath, File binFile, Optional<File> errorFile)
+      throws IOException, CompilationException {
+    ImmutableList<String> command = decodeCommandLine(message, protoFile);
+
+    File textprotoFile = new File(textprotoPath);
+
+    ProcessBuilder builder =
+        new ProcessBuilder(command).redirectInput(binFile).redirectOutput(textprotoFile);
+
+    if (errorFile.isPresent()) {
+      builder.redirectError(errorFile.get());
+    }
+
+    runCommand(builder);
+    return textprotoFile;
+  }
+
+  private ImmutableList<String> createCommandLine(File file) {
     return ImmutableList.of(
         protoPath,
         "-o",
@@ -72,4 +133,22 @@
         file.getName() + "=" + file.getAbsolutePath(), // That should be one line
         file.getName());
   }
+
+  private ImmutableList<String> encodeCommandLine(String message, File protoFile) {
+    return ImmutableList.of(
+        protoPath,
+        "--encode=" + message,
+        "-I",
+        protoFile.getName() + "=" + protoFile.getAbsolutePath(), // That should be one line
+        protoFile.getName());
+  }
+
+  private ImmutableList<String> decodeCommandLine(String message, File protoFile) {
+    return ImmutableList.of(
+        protoPath,
+        "--decode=" + message,
+        "-I",
+        protoFile.getName() + "=" + protoFile.getAbsolutePath(), // That should be one line
+        protoFile.getName());
+  }
 }

diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/FolderConfig.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/FolderConfig.java
new file mode 100644
index 0000000..f3c2615
--- /dev/null
+++ b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/FolderConfig.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.google.tuningfork.validation;
+
+/** Settings and proto file names for assets/tuningfork folder */
+final class FolderConfig {
+
+  public static final String DEV_TUNINGFORK_PROTO = "dev_tuningfork.proto";
+  public static final String DEV_TUNINGFORK_DESCRIPTOR = "dev_tuningfork.descriptor";
+  public static final String TUNINGFORK_SETTINGS_TEXTPROTO = "tuningfork_settings.txt";
+  public static final String TUNINGFORK_SETTINGS_BINARY = "tuningfork_settings.bin";
+  public static final String DEV_FIDELITY_TEXTPROTO = "dev_tuningfork_fidelityparams_.{1,15}.txt";
+}

diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ParserErrorCollector.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ParserErrorCollector.java
index 547e27f..4da322c 100644
--- a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ParserErrorCollector.java
+++ b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ParserErrorCollector.java

@@ -56,31 +56,42 @@
   public void printStatus() {
     StringBuilder builder = new StringBuilder();
     for (ErrorType errorType : ErrorType.values()) {
-      builder.append(errorType).append(" : ");
       int errorCount = errors.get(errorType).size();
-      if (errorCount == 0) {
-        builder.append("OK");
-      } else {
-        builder.append(errorCount);
-        builder.append(" ERRORS\n\t");
-        builder.append(errors.get(errorType));
+      if (errorCount != 0) {
+        builder
+            .append(errorType)
+            .append(" : ")
+            .append(errorCount)
+            .append(" ERRORS\n\t")
+            .append(errors.get(errorType))
+            .append("\n");
       }
-      builder.append("\n");
     }
-    logger.atInfo().log(builder.toString());
+    logger.atWarning().log(builder.toString());
+  }
+
+  @Override
+  public Boolean hasErrors(ErrorType.ErrorGroup group) {
+    for (ErrorType errorType : ErrorType.values()) {
+      if (errorType.getGroup() == group && errors.containsKey(errorType)) {
+        return true;
+      }
+    }
+    return false;
   }
 
   @Override
   public Boolean hasAnnotationErrors() {
-    return errors.containsKey(ErrorType.ANNOTATION_EMPTY)
-        || errors.containsKey(ErrorType.ANNOTATION_COMPLEX)
-        || errors.containsKey(ErrorType.ANNOTATION_TYPE);
+    return hasErrors(ErrorType.ErrorGroup.ANNOTATION);
   }
 
   @Override
   public Boolean hasFidelityParamsErrors() {
-    return errors.containsKey(ErrorType.FIDELITY_PARAMS_EMPTY)
-        || errors.containsKey(ErrorType.FIDELITY_PARAMS_COMPLEX)
-        || errors.containsKey(ErrorType.FIDELITY_PARAMS_TYPE);
+    return hasErrors(ErrorType.ErrorGroup.FIDELITY);
+  }
+
+  @Override
+  public Boolean hasSettingsErrors() {
+    return hasErrors(ErrorType.ErrorGroup.SETTINGS);
   }
 }

diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ProtoHelper.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ProtoHelper.java
deleted file mode 100644
index 855944d..0000000
--- a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ProtoHelper.java
+++ /dev/null

@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License
- */
-
-package com.google.tuningfork.validation;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-import com.google.common.io.Files;
-import com.google.protobuf.Descriptors.FileDescriptor;
-import java.io.File;
-import java.io.IOException;
-
-/** Compile {@link FileDescriptor} from proto file content */
-final class ProtoHelper {
-
-  private static final String TEMP_FILE_NAME = "tempfile.proto";
-
-  private ProtoHelper() {}
-
-  public static FileDescriptor compileContent(String content, File protocBinary)
-      throws IOException, CompilationException {
-    File file = File.createTempFile(TEMP_FILE_NAME, null);
-    Files.asCharSink(file, UTF_8).write(content);
-    ExternalProtoCompiler compiler = new ExternalProtoCompiler(protocBinary);
-    FileDescriptor desc = compiler.compile(file);
-    file.delete();
-    return desc;
-  }
-}

diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/TuningforkApkValidationTool.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/TuningforkApkValidationTool.java
index 3081147..b3bf50b 100644
--- a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/TuningforkApkValidationTool.java
+++ b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/TuningforkApkValidationTool.java

@@ -18,79 +18,76 @@
 
 import static com.google.common.base.Preconditions.checkArgument;
 
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.Parameter;
 import com.google.common.base.Strings;
-import com.google.common.flags.Flag;
-import com.google.common.flags.FlagSpec;
-import com.google.common.flags.Flags;
 import com.google.common.flogger.FluentLogger;
 import java.io.File;
 import java.io.IOException;
-import java.util.Enumeration;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
 
 /** APK Validation tool for Tuningfork */
 final class TuningforkApkValidationTool {
+
+  private static class Parameters {
+    @Parameter(
+        names = {"--tuningforkPath"},
+        description = "Path to an assets/tuningfork folder")
+    public String tuningforkPath;
+
+    @Parameter(
+        names = {"--protoCompiler"},
+        description = "Path to protoc binary")
+    public String protoCompiler;
+  }
+
   private static final FluentLogger logger = FluentLogger.forEnclosingClass();
 
-  @FlagSpec(help = "Path to apk file")
-  public static final Flag<String> apkPath = Flag.nullString();
-
-  @FlagSpec(help = "Path to proto compiler")
-  public static final Flag<String> protoCompiler = Flag.nullString();
-
   public static void main(String[] args) {
-    Flags.parse(args);
+    Parameters parameters = new Parameters();
+    new JCommander(parameters, args);
 
     checkArgument(
-        !Strings.isNullOrEmpty(apkPath.get()),
-        "You need to specify path to your apk file --apkPath");
+        !Strings.isNullOrEmpty(parameters.tuningforkPath),
+        "You need to specify path to your tuningfork settings folder --tuningforkPath");
 
     checkArgument(
-        !Strings.isNullOrEmpty(protoCompiler.get()),
+        !Strings.isNullOrEmpty(parameters.protoCompiler),
         "You need to specify path to proto compiler --protoCompiler");
 
-    File apkFile = new File(apkPath.get());
-    if (!apkFile.exists()) {
-      logger.atSevere().log("APK File does not exist %s", apkPath.get());
-      return;
+    File tuningforkFolder = new File(parameters.tuningforkPath);
+    if (!tuningforkFolder.exists()) {
+      logger.atSevere().log(
+          "Tuningfork settings folder does not exist %s", parameters.tuningforkPath);
     }
 
-    File protoCompilerFile = new File(protoCompiler.get());
+    if (!tuningforkFolder.isDirectory()) {
+      logger.atSevere().log(
+          "--tuningforkPath=[%s] is not a path to a folder", parameters.tuningforkPath);
+    }
+
+    File protoCompilerFile = new File(parameters.protoCompiler);
     if (!protoCompilerFile.exists()) {
-      logger.atSevere().log("Proto compiler file does not exist %s", protoCompiler.get());
-      return;
+      logger.atSevere().log("Proto compiler file does not exist %s", parameters.protoCompiler);
     }
 
-    logger.atInfo().log("Start validation of %s...", apkFile.getName());
-
-    JarFile jarApk;
-
-    try {
-      jarApk = new JarFile(apkFile);
-    } catch (IOException e) {
-      logger.atSevere().withCause(e).log("Can not open apk file %s", apkFile.getName());
-      return;
+    if (!protoCompilerFile.isFile() || !protoCompilerFile.canExecute()) {
+      logger.atSevere().log(
+          "--protoCompiler=[%s] is not a path to an executable file", parameters.protoCompiler);
     }
 
+    logger.atInfo().log("Start validation of %s...", tuningforkFolder.getPath());
+
     ErrorCollector errors = new ParserErrorCollector();
-    DeveloperTuningforkParser parser = new DeveloperTuningforkParser(errors, protoCompilerFile);
-
-    Enumeration<JarEntry> apkFiles = jarApk.entries();
-    while (apkFiles.hasMoreElements()) {
-      JarEntry file = apkFiles.nextElement();
-      try {
-        parser.parseJarEntry(jarApk, file);
-      } catch (Exception e) {
-        logger.atWarning().withCause(e).log("Can not parse apk entry %s", file.getName());
-      }
-    }
+    DeveloperTuningforkParser parser =
+        new DeveloperTuningforkParser(errors, tuningforkFolder, protoCompilerFile);
 
     try {
+      parser.parseFilesInFolder();
       parser.validate();
       if (errors.getErrorCount() == 0) {
-        logger.atInfo().log("Apk %s is valid", apkFile.getName());
+        logger.atInfo().log("Tuning Fork settings are valid");
       } else {
+        logger.atWarning().log("Tuning Fork settings are invalid");
         errors.printStatus();
       }
     } catch (IOException | CompilationException e) {

diff --git a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ValidationUtil.java b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ValidationUtil.java
index b41982f..e2f5ce9 100644
--- a/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ValidationUtil.java
+++ b/src/tuningfork/tools/validation/src/main/java/com/google/tuningfork/validation/ValidationUtil.java

@@ -22,13 +22,16 @@
 import com.google.protobuf.Descriptors.FieldDescriptor;
 import com.google.protobuf.DynamicMessage;
 import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.TextFormat;
+import com.google.protobuf.TextFormat.ParseException;
 import com.google.tuningfork.Tuningfork.Settings;
 import com.google.tuningfork.Tuningfork.Settings.AggregationStrategy;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Optional;
 
-/** Utility methods for validating Tuning Fork protos and settings.*/
+/** Utility methods for validating Tuning Fork protos and settings. */
 final class ValidationUtil {
 
   private ValidationUtil() {}
@@ -40,6 +43,22 @@
           FieldDescriptor.Type.ENUM, FieldDescriptor.Type.FLOAT, FieldDescriptor.Type.INT32);
 
   /* Validate settings */
+  public static Optional<Settings> validateSettings(
+      List<Integer> enumSizes, String settingsTextProto, ErrorCollector errors) {
+    try {
+      Settings.Builder builder = Settings.newBuilder();
+      TextFormat.merge(settingsTextProto, builder);
+      Settings settings = builder.build();
+      validateSettingsAggregation(settings, enumSizes, errors);
+      validateSettingsHistograms(settings, errors);
+      return Optional.of(settings);
+    } catch (ParseException e) {
+      errors.addError(ErrorType.SETTINGS_PARSING, "Parsing tuningfork_settings.txt", e);
+      return Optional.empty();
+    }
+  }
+
+  /* Validate settings */
   public static final void validateSettings(
       List<Integer> enumSizes, ByteString settingsContent, ErrorCollector errors) {
     try {

diff --git a/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/DeveloperTuningforkParserTest.java b/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/DeveloperTuningforkParserTest.java
new file mode 100644
index 0000000..f57a849
--- /dev/null
+++ b/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/DeveloperTuningforkParserTest.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.google.tuningfork.validation;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.io.Files;
+import com.google.devtools.build.runtime.Runfiles;
+import com.google.protobuf.ByteString;
+import com.google.testing.testsize.MediumTest;
+import com.google.tuningfork.DevTuningfork.FidelityParams;
+import com.google.tuningfork.DevTuningfork.QualitySettings;
+import com.google.tuningfork.Tuningfork.Settings;
+import com.google.tuningfork.Tuningfork.Settings.AggregationStrategy;
+import com.google.tuningfork.Tuningfork.Settings.Histogram;
+import java.io.File;
+import java.util.Arrays;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+@MediumTest
+public final class DeveloperTuningforkParserTest {
+
+  @Rule
+  // Override default behavior to allow overwriting files.
+  public TemporaryFolder tempFolder =
+      new TemporaryFolder() {
+        @Override
+        public File newFile(String filename) {
+          return new File(getRoot(), filename);
+        }
+      };
+
+  private final TestdataHelper helper = new TestdataHelper(tempFolder);
+  private final ErrorCollector errors = new ParserErrorCollector();
+
+  private DeveloperTuningforkParser parser;
+  private final Settings settings =
+      Settings.newBuilder()
+          .setAggregationStrategy(
+              AggregationStrategy.newBuilder()
+                  .addAllAnnotationEnumSize(Arrays.asList(2))
+                  .setMaxInstrumentationKeys(100))
+          .addHistograms(Histogram.getDefaultInstance())
+          .build();
+
+  private final FidelityParams devParameters1 =
+      FidelityParams.newBuilder()
+          .setIntField(10)
+          .setFloatField(1.5f)
+          .setQualitySettings(QualitySettings.FAST)
+          .build();
+
+  private final FidelityParams devParameters2 = FidelityParams.newBuilder().setIntField(10).build();
+  private final FidelityParams devParameters3 = FidelityParams.getDefaultInstance();
+
+  private static final File PROTOC_BINARY =
+      Runfiles.location("net/proto2/compiler/public/protocol_compiler");
+
+  @Before
+  public void setUp() throws Exception {
+    parser = new DeveloperTuningforkParser(errors, tempFolder.getRoot(), PROTOC_BINARY);
+    helper.getFile("dev_tuningfork.proto");
+    helper.createFile("tuningfork_settings.txt", settings.toString());
+    helper.createFile("dev_tuningfork_fidelityparams_1.txt", devParameters1.toString());
+    helper.createFile("dev_tuningfork_fidelityparams_2.txt", devParameters2.toString());
+    helper.createFile("dev_tuningfork_fidelityparams_3.txt", devParameters3.toString());
+    parser.parseFilesInFolder();
+  }
+
+  @Test
+  public void checkNoErrors() throws Exception {
+    parser.validate();
+    assertThat(errors.getErrorCount()).isEqualTo(0);
+  }
+
+  @Test
+  public void checkSettings() throws Exception {
+    parser.validate();
+    File settingsFile = new File(tempFolder.getRoot(), "tuningfork_settings.bin");
+    ByteString settingsBinary = ByteString.copyFrom(Files.toByteArray(settingsFile));
+    Settings parsed = Settings.parseFrom(settingsBinary);
+
+    assertThat(parsed).isEqualTo(settings);
+    assertThat(errors.hasSettingsErrors()).isFalse();
+  }
+
+  @Test
+  public void checkFidelityParametersFiles() throws Exception {
+    parser.validate();
+    File file1 = new File(tempFolder.getRoot(), "dev_tuningfork_fidelityparams_1.bin");
+    File file2 = new File(tempFolder.getRoot(), "dev_tuningfork_fidelityparams_2.bin");
+    File file3 = new File(tempFolder.getRoot(), "dev_tuningfork_fidelityparams_3.bin");
+    File file4 = new File(tempFolder.getRoot(), "dev_tuningfork_fidelityparams_4.bin");
+
+    assertThat(file1.exists()).isTrue();
+    assertThat(file2.exists()).isTrue();
+    assertThat(file3.exists()).isTrue();
+    assertThat(file4.exists()).isFalse();
+  }
+
+  @Test
+  public void checkFidelityParameters() throws Exception {
+    parser.validate();
+    File devFidelityFile = new File(tempFolder.getRoot(), "dev_tuningfork_fidelityparams_1.bin");
+    ByteString devFidelityBinary = ByteString.copyFrom(Files.toByteArray(devFidelityFile));
+    FidelityParams parsed = FidelityParams.parseFrom(devFidelityBinary);
+
+    assertThat(parsed).isEqualTo(devParameters1);
+    assertThat(errors.hasFidelityParamsErrors()).isFalse();
+  }
+}

diff --git a/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ExternalProtoCompilerTest.java b/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ExternalProtoCompilerTest.java
index 72d9fc3..314cb40 100644
--- a/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ExternalProtoCompilerTest.java
+++ b/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ExternalProtoCompilerTest.java

@@ -1,16 +1,36 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
 package com.google.tuningfork.validation;
 
 import static com.google.common.truth.Truth.assertThat;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertThrows;
 
+import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
+import com.google.common.io.Files;
 import com.google.devtools.build.runtime.Runfiles;
+import com.google.protobuf.DescriptorProtos.FileDescriptorSet;
 import com.google.protobuf.Descriptors.Descriptor;
 import com.google.protobuf.Descriptors.FileDescriptor;
 import java.io.File;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -49,7 +69,7 @@
   public void compileValid() throws Exception {
     File file = helper.getFile("compile_valid.proto");
 
-    FileDescriptor fDesc = compiler.compile(file);
+    FileDescriptor fDesc = compiler.compile(file, Optional.empty());
 
     Descriptor messageDesc = fDesc.findMessageTypeByName("Message");
     Descriptor anotherDesc = fDesc.findMessageTypeByName("AnotherMessage");
@@ -58,10 +78,30 @@
   }
 
   @Test
+  public void compareDescriptors() throws Exception {
+    File file = helper.getFile("compile_valid.proto");
+    File outFile = new File(tempFolder.getRoot(), "compile_valid.descriptor");
+
+    FileDescriptor stdoutDescriptor = compiler.compile(file, Optional.of(outFile));
+
+    Descriptor messageDesc = stdoutDescriptor.findMessageTypeByName("Message");
+    Descriptor anotherDesc = stdoutDescriptor.findMessageTypeByName("AnotherMessage");
+    FileDescriptorSet fileSet = FileDescriptorSet.parseFrom(Files.toByteArray(outFile));
+    FileDescriptor outFileDescriptor =
+        FileDescriptor.buildFrom(
+            Iterables.getOnlyElement(fileSet.getFileList()), new FileDescriptor[] {});
+
+    assertThat(messageDesc).isNotNull();
+    assertThat(anotherDesc).isNotNull();
+    assertThat(outFile).isNotNull();
+    assertThat(stdoutDescriptor.toProto()).isEqualTo(outFileDescriptor.toProto());
+  }
+
+  @Test
   public void compileInvalid() throws Exception {
     File file = helper.getFile("compile_invalid.proto");
     CompilationException expected =
-        assertThrows(CompilationException.class, () -> compiler.compile(file));
+        assertThrows(CompilationException.class, () -> compiler.compile(file, Optional.empty()));
 
     assertThat(expected)
         .hasMessageThat()
@@ -72,7 +112,7 @@
   public void compileWithDeps() throws Exception {
     File file = helper.getFile("compile_with_deps.proto");
     CompilationException expected =
-        assertThrows(CompilationException.class, () -> compiler.compile(file));
+        assertThrows(CompilationException.class, () -> compiler.compile(file, Optional.empty()));
 
     assertThat(expected)
         .hasMessageThat()
@@ -80,9 +120,55 @@
   }
 
   @Test
+  public void compileDevTuningfork() throws Exception {
+    File file = helper.getFile("dev_tuningfork.proto");
+
+    FileDescriptor fDesc = compiler.compile(file, Optional.empty());
+
+    Descriptor annotation = fDesc.findMessageTypeByName("Annotation");
+    Descriptor fidelityParams = fDesc.findMessageTypeByName("FidelityParams");
+    assertThat(annotation).isNotNull();
+    assertThat(fidelityParams).isNotNull();
+  }
+
+  @Test
+  public void encodeAndDecode() throws Exception {
+    String message = "com.google.tuningfork.FidelityParams";
+    File protoFile = helper.getFile("dev_tuningfork.proto");
+    File originalTextFile = helper.getFile("dev_tuningfork_fidelityparams_1.txt");
+    Optional<File> errorFile = Optional.of(tempFolder.newFile("errors.txt"));
+    String root = tempFolder.getRoot().getAbsolutePath();
+    File binaryFile =
+        compiler.encodeFromTextprotoFile(
+            message,
+            protoFile,
+            originalTextFile,
+            root + "/dev_tuningfork_fidelityparams_1.bin",
+            errorFile);
+
+    byte[] error = Files.toByteArray(errorFile.get());
+    assertThat(error).isEqualTo(new byte[0]);
+
+    File decodedTextFile =
+        compiler.decodeToTextprotoFile(
+            message,
+            protoFile,
+            root + "/dev_tuningfork_fidelityparams_decoded.txt",
+            binaryFile,
+            errorFile);
+
+    String originalMessage = Files.asCharSource(originalTextFile, UTF_8).read();
+    String decodedMessage = Files.asCharSource(decodedTextFile, UTF_8).read();
+    error = Files.toByteArray(errorFile.get());
+    assertThat(error).isEqualTo(new byte[0]);
+    assertThat(decodedMessage).isEqualTo(originalMessage);
+  }
+
+  @Test
   public void runEchoCommand() throws Exception {
     String expected = "Hello world";
-    String result = new String(compiler.runCommand(Arrays.asList("echo", expected)), UTF_8);
+    ProcessBuilder builder = new ProcessBuilder(Arrays.asList("echo", expected));
+    String result = new String(compiler.runCommand(builder), UTF_8);
     assertThat(result).startsWith(expected);
   }
 }

diff --git a/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ProtoCompilerHelper.java b/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ProtoCompilerHelper.java
index 2604120..d9ef5a9 100644
--- a/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ProtoCompilerHelper.java
+++ b/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ProtoCompilerHelper.java

@@ -22,6 +22,7 @@
 import com.google.protobuf.Descriptors.Descriptor;
 import com.google.protobuf.Descriptors.FileDescriptor;
 import java.io.File;
+import java.util.Optional;
 import org.junit.rules.TemporaryFolder;
 
 /** Base class for tests that need to create proto Descriptors */
@@ -39,7 +40,7 @@
   public Descriptor getDescriptor(String fileName, String message, String descName)
       throws Exception {
     File file = testdata.getFile(fileName);
-    FileDescriptor fDesc = compiler.compile(file);
+    FileDescriptor fDesc = compiler.compile(file, Optional.empty());
     assertThat(fDesc).isNotNull();
     Descriptor desc = fDesc.findMessageTypeByName(descName);
     return desc;

diff --git a/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ValidationUtilTest.java b/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ValidationUtilTest.java
index 767ab48..a2d915a 100644
--- a/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ValidationUtilTest.java
+++ b/src/tuningfork/tools/validation/src/test/java/com/google/tuningfork/validation/ValidationUtilTest.java

@@ -20,12 +20,13 @@
 
 import com.google.protobuf.ByteString;
 import com.google.protobuf.Descriptors.Descriptor;
+import com.google.testing.testsize.MediumTest;
 import com.google.tuningfork.Tuningfork.Settings;
 import com.google.tuningfork.Tuningfork.Settings.AggregationStrategy;
 import com.google.tuningfork.Tuningfork.Settings.Histogram;
-import com.google.testing.testsize.MediumTest;
 import java.io.File;
 import java.util.Arrays;
+import java.util.Optional;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
@@ -53,6 +54,26 @@
   private final ErrorCollector errors = new ParserErrorCollector();
 
   @Test
+  public void settingsValid() throws Exception {
+    AggregationStrategy aggregation =
+        AggregationStrategy.newBuilder()
+            .addAllAnnotationEnumSize(Arrays.asList(5, 10))
+            .setMaxInstrumentationKeys(100)
+            .build();
+    Settings settings =
+        Settings.newBuilder()
+            .setAggregationStrategy(aggregation)
+            .addHistograms(Histogram.getDefaultInstance())
+            .build();
+
+    Optional<Settings> parsedSettings =
+        ValidationUtil.validateSettings(Arrays.asList(5, 10), settings.toString(), errors);
+
+    assertThat(errors.getErrorCount()).isEqualTo(0);
+    assertThat(parsedSettings.get()).isEqualTo(settings);
+  }
+
+  @Test
   public void settingsHistogramsValid() throws Exception {
     Settings settings = Settings.newBuilder().addHistograms(Histogram.getDefaultInstance()).build();
 

diff --git a/src/tuningfork/tools/validation/src/test/resources/testdata/dev_tuningfork.proto b/src/tuningfork/tools/validation/src/test/resources/testdata/dev_tuningfork.proto
new file mode 100644
index 0000000..da618e2
--- /dev/null
+++ b/src/tuningfork/tools/validation/src/test/resources/testdata/dev_tuningfork.proto

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+syntax = "proto3";
+
+package com.google.tuningfork;
+
+option java_package = "com.google.tuningfork";
+
+enum LoadingState {
+  UNKNOWN = 0;
+  NOT_LOADING = 1;
+}
+
+message Annotation {
+  LoadingState loading_state = 1;
+}
+
+enum QualitySettings {
+  UNKNOWN_QUALITY = 0;
+  FAST = 1;
+  SIMPLE = 2;
+  GOOD = 3;
+  BEAUTIFUL = 4;
+  FANTASTIC = 5;
+}
+
+message FidelityParams {
+  QualitySettings quality_settings = 1;
+  int32 int_field = 2;
+  float float_field = 3;
+}

diff --git a/src/tuningfork/tools/validation/src/test/resources/testdata/dev_tuningfork_fidelityparams_1.txt b/src/tuningfork/tools/validation/src/test/resources/testdata/dev_tuningfork_fidelityparams_1.txt
new file mode 100644
index 0000000..21152fc
--- /dev/null
+++ b/src/tuningfork/tools/validation/src/test/resources/testdata/dev_tuningfork_fidelityparams_1.txt

@@ -0,0 +1,2 @@
+quality_settings: FANTASTIC
+int_field: 10

diff --git a/src/tuningfork/tuningfork_internal.h b/src/tuningfork/tuningfork_internal.h
index 9ccc0ad..3282249 100644
--- a/src/tuningfork/tuningfork_internal.h
+++ b/src/tuningfork/tuningfork_internal.h

@@ -74,6 +74,7 @@
     std::vector<uint64_t> cpu_max_freq_hz;
     std::string apk_package_name;
     int apk_version_code;
+    int tuningfork_version;
 };
 
 class Backend {

diff --git a/src/tuningfork/tuningfork_utils.cpp b/src/tuningfork/tuningfork_utils.cpp
index 7894e48..7158d65 100644
--- a/src/tuningfork/tuningfork_utils.cpp
+++ b/src/tuningfork/tuningfork_utils.cpp

@@ -139,4 +139,17 @@
 
 } // namespace file_utils
 
+std::string UniqueId(JNIEnv* env) {
+    jclass uuid_class = env->FindClass("java/util/UUID");
+    jmethodID randomUUID = env->GetStaticMethodID( uuid_class, "randomUUID",
+            "()Ljava/util/UUID;");
+    jobject uuid = env->CallStaticObjectMethod(uuid_class, randomUUID);
+    jmethodID toString = env->GetMethodID( uuid_class, "toString", "()Ljava/lang/String;");
+    jstring uuid_string = (jstring)env->CallObjectMethod(uuid, toString);
+    const char *uuid_chars = env->GetStringUTFChars( uuid_string, NULL );
+    std::string temp_uuid( uuid_chars );
+    env->ReleaseStringUTFChars( uuid_string, uuid_chars );
+    return temp_uuid;
+}
+
 } // namespace tuningfork

diff --git a/src/tuningfork/tuningfork_utils.h b/src/tuningfork/tuningfork_utils.h
index ef16f84..63df285 100644
--- a/src/tuningfork/tuningfork_utils.h
+++ b/src/tuningfork/tuningfork_utils.h

@@ -49,4 +49,7 @@
 
 } // namespace file_utils
 
+// Get a unique identifier using java.util.UUID
+std::string UniqueId(JNIEnv* env);
+
 } // namespace tuningfork

diff --git a/src/tuningfork/uploadthread.cpp b/src/tuningfork/uploadthread.cpp
index 12d0c3d..244dc7a 100644
--- a/src/tuningfork/uploadthread.cpp
+++ b/src/tuningfork/uploadthread.cpp

@@ -186,22 +186,26 @@
     extra_info.build_version_sdk = getSystemPropViaGet("ro.build.version.sdk");
     extra_info.build_fingerprint = getSystemPropViaGet("ro.build.fingerprint");
 
+    extra_info.session_id = UniqueId(env);
+
     extra_info.cpu_max_freq_hz.clear();
     for(int index = 1;;++index) {
         std::stringstream str;
-        str << "/sys/devices/system/cpu/cpu/" << index << "/cpufreq/cpuinfo_max_freq";
+        str << "/sys/devices/system/cpu/cpu" << index << "/cpufreq/cpuinfo_max_freq";
         auto cpu_freq_file = slurpFile(str.str().c_str());
         if (cpu_freq_file.empty())
             break;
         uint64_t freq;
         std::istringstream cstr(cpu_freq_file);
         cstr >> freq;
-        // TODO check units
-        extra_info.cpu_max_freq_hz.push_back(freq);
+        extra_info.cpu_max_freq_hz.push_back(freq*1000); // File is in kHz
     }
 
     extra_info.apk_version_code = apk_utils::GetVersionCode(env, activity,
         &extra_info.apk_package_name);
+
+    extra_info.tuningfork_version = TUNINGFORK_PACKED_VERSION;
+
     return extra_info;
 }
 

diff --git a/third_party/cube/build.gradle b/third_party/cube/build.gradle
index 51b175b..4699ea7 100644
--- a/third_party/cube/build.gradle
+++ b/third_party/cube/build.gradle

@@ -6,7 +6,7 @@
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.2.1'
+        classpath 'com.android.tools.build:gradle:3.3.2'
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
     }