diff --git a/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp b/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp
index 9b7d0cf..145d4c3 100644
--- a/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp
+++ b/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp
@@ -38,8 +38,7 @@
 class AudioEffectHidlTest : public ::testing::Test {
  public:
   virtual void SetUp() override {
-    // currently test passthrough mode only
-    effectsFactory = IEffectsFactory::getService("audio_effects_factory", true);
+    effectsFactory = IEffectsFactory::getService("audio_effects_factory");
     ASSERT_NE(effectsFactory, nullptr);
   }
 
diff --git a/biometrics/fingerprint/2.1/Android.bp b/biometrics/fingerprint/2.1/Android.bp
index 02b7328..2a252dc 100644
--- a/biometrics/fingerprint/2.1/Android.bp
+++ b/biometrics/fingerprint/2.1/Android.bp
@@ -62,3 +62,155 @@
         "android.hidl.base@1.0",
     ],
 }
+
+genrule {
+    name: "android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mDRIVER -tSOURCE -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+    srcs: [
+        "types.hal",
+        "IBiometricsFingerprint.hal",
+        "IBiometricsFingerprintClientCallback.hal",
+    ],
+    out: [
+        "android/hardware/biometrics/fingerprint/2.1/types.vts.cpp",
+        "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprint.vts.cpp",
+        "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprintClientCallback.vts.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++_headers",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mDRIVER -tHEADER -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+    srcs: [
+        "types.hal",
+        "IBiometricsFingerprint.hal",
+        "IBiometricsFingerprintClientCallback.hal",
+    ],
+    out: [
+        "android/hardware/biometrics/fingerprint/2.1/types.vts.h",
+        "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprint.vts.h",
+        "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprintClientCallback.vts.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.biometrics.fingerprint.vts.driver@2.1",
+    generated_sources: ["android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++"],
+    generated_headers: ["android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++_headers"],
+    export_generated_headers: ["android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++_headers"],
+    shared_libs: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+        "libcutils",
+        "libvts_common",
+        "libvts_datatype",
+        "libvts_measurement",
+        "libvts_multidevice_proto",
+        "libcamera_metadata",
+        "libprotobuf-cpp-full",
+        "android.hidl.base@1.0",
+        "android.hardware.biometrics.fingerprint@2.1",
+    ],
+    export_shared_lib_headers: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "android.hidl.base@1.0",
+    ],
+}
+
+genrule {
+    name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mPROFILER -tSOURCE -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+    srcs: [
+        "IBiometricsFingerprint.hal",
+        "types.hal",
+    ],
+    out: [
+        "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprint.vts.cpp",
+        "android/hardware/biometrics/fingerprint/2.1/types.vts.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++_headers",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mPROFILER -tHEADER -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+    srcs: [
+        "IBiometricsFingerprint.hal",
+        "types.hal",
+    ],
+    out: [
+        "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprint.vts.h",
+        "android/hardware/biometrics/fingerprint/2.1/types.vts.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler",
+    generated_sources: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++"],
+    generated_headers: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++_headers"],
+    export_generated_headers: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++_headers"],
+    shared_libs: [
+        "libbase",
+        "libhidlbase",
+        "libhidltransport",
+        "libvts_profiling",
+        "libvts_multidevice_proto",
+        "libprotobuf-cpp-full",
+        "android.hidl.base@1.0",
+        "android.hardware.biometrics.fingerprint@2.1",
+    ],
+}
+
+genrule {
+    name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mPROFILER -tSOURCE -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+    srcs: [
+        "IBiometricsFingerprintClientCallback.hal",
+        "types.hal",
+    ],
+    out: [
+        "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprintClientCallback.vts.cpp",
+        "android/hardware/biometrics/fingerprint/2.1/types.vts.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++_headers",
+    tools: ["hidl-gen", "vtsc"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mPROFILER -tHEADER -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+    srcs: [
+        "IBiometricsFingerprintClientCallback.hal",
+        "types.hal",
+    ],
+    out: [
+        "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprintClientCallback.vts.h",
+        "android/hardware/biometrics/fingerprint/2.1/types.vts.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler",
+    generated_sources: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++"],
+    generated_headers: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++_headers"],
+    export_generated_headers: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++_headers"],
+    shared_libs: [
+        "libbase",
+        "libhidlbase",
+        "libhidltransport",
+        "libvts_profiling",
+        "libvts_multidevice_proto",
+        "libprotobuf-cpp-full",
+        "android.hidl.base@1.0",
+        "android.hardware.biometrics.fingerprint@2.1",
+    ],
+}
diff --git a/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.hal b/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.hal
index 63435d1..d913cf1 100644
--- a/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.hal
+++ b/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.hal
@@ -43,8 +43,9 @@
      * @param deviceId the instance of this fingerprint device
      * @param fingerId the fingerprint templetate that was authenticated
      * @param groupId the groupid for the template that was authenticated
+     * @param token the hardware authentication token to pass to Keystore.addAuthToken()
      */
-    oneway onAuthenticated(uint64_t deviceId, uint32_t fingerId, uint32_t groupId);
+    oneway onAuthenticated(uint64_t deviceId, uint32_t fingerId, uint32_t groupId, vec<uint8_t> token);
 
     /**
      * Sent when a fingerprint error occurs
diff --git a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
index 516cd00..154b7a6 100644
--- a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
+++ b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 #define LOG_TAG "android.hardware.biometrics.fingerprint@2.1-service"
+#define LOG_VERBOSE "android.hardware.biometrics.fingerprint@2.1-service"
 
 // For communication with Keystore binder interface
-#include <binder/IServiceManager.h>
-#include <keystore/IKeystoreService.h>
 #include <keystore/keystore.h> // for error codes
 #include <hardware/hw_auth_token.h>
 
@@ -40,23 +39,19 @@
 using RequestStatus =
         android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
 
-sp<IBiometricsFingerprintClientCallback>
-    BiometricsFingerprint::mClientCallback = nullptr;
+BiometricsFingerprint *BiometricsFingerprint::sInstance = nullptr;
 
-// TODO: This is here because HAL 2.1 doesn't have a way to propagate a
-// unique token for its driver. Subsequent versions should send a unique
-// token for each call to notify(). This is fine as long as there's only
-// one fingerprint device on the platform.
-fingerprint_device_t *BiometricsFingerprint::sDevice = nullptr;
-
-BiometricsFingerprint::BiometricsFingerprint(fingerprint_device_t *device)
-    : mDevice(device) {
-    sDevice = mDevice; // keep track of the most recent instance
+BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr), mDevice(nullptr) {
+    sInstance = this; // keep track of the most recent instance
+    mDevice = openHal();
+    if (!mDevice) {
+        ALOGE("Can't open HAL module");
+    }
 }
 
 BiometricsFingerprint::~BiometricsFingerprint() {
-    ALOG(LOG_VERBOSE, LOG_TAG, "nativeCloseHal()\n");
-    if (mDevice == NULL) {
+    ALOGV(LOG_VERBOSE, LOG_TAG, "~BiometricsFingerprint()\n");
+    if (mDevice == nullptr) {
         ALOGE("No valid device");
         return;
     }
@@ -66,7 +61,7 @@
         ALOGE("Can't close fingerprint module, error: %d", err);
         return;
     }
-    mDevice = NULL;
+    mDevice = nullptr;
 }
 
 Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) {
@@ -107,6 +102,8 @@
             return FingerprintError::ERROR_CANCELED;
         case FINGERPRINT_ERROR_UNABLE_TO_REMOVE:
             return FingerprintError::ERROR_UNABLE_TO_REMOVE;
+        case FINGERPRINT_ERROR_LOCKOUT:
+            return FingerprintError::ERROR_LOCKOUT;
         default:
             if (error >= FINGERPRINT_ERROR_VENDOR_BASE) {
                 // vendor specific code.
@@ -114,7 +111,7 @@
                 return FingerprintError::ERROR_VENDOR;
             }
     }
-    ALOGE("Unknown error from fingerprint vendor library");
+    ALOGE("Unknown error from fingerprint vendor library: %d", error);
     return FingerprintError::ERROR_UNABLE_TO_PROCESS;
 }
 
@@ -143,13 +140,17 @@
                 return FingerprintAcquiredInfo::ACQUIRED_VENDOR;
             }
     }
-    ALOGE("Unknown acquiredmsg from fingerprint vendor library");
+    ALOGE("Unknown acquiredmsg from fingerprint vendor library: %d", info);
     return FingerprintAcquiredInfo::ACQUIRED_INSUFFICIENT;
 }
 
 Return<uint64_t> BiometricsFingerprint::setNotify(
         const sp<IBiometricsFingerprintClientCallback>& clientCallback) {
     mClientCallback = clientCallback;
+    // This is here because HAL 2.1 doesn't have a way to propagate a
+    // unique token for its driver. Subsequent versions should send a unique
+    // token for each call to setNotify(). This is fine as long as there's only
+    // one fingerprint device on the platform.
     return reinterpret_cast<uint64_t>(mDevice);
 }
 
@@ -199,36 +200,44 @@
 }
 
 IBiometricsFingerprint* BiometricsFingerprint::getInstance() {
+    if (!sInstance) {
+      sInstance = new BiometricsFingerprint();
+    }
+    return sInstance;
+}
+
+fingerprint_device_t* BiometricsFingerprint::openHal() {
     int err;
-    const hw_module_t *hw_mdl = NULL;
-    ALOGE("Opening fingerprint hal library...");
+    const hw_module_t *hw_mdl = nullptr;
+    ALOGD("Opening fingerprint hal library...");
     if (0 != (err = hw_get_module(FINGERPRINT_HARDWARE_MODULE_ID, &hw_mdl))) {
         ALOGE("Can't open fingerprint HW Module, error: %d", err);
         return nullptr;
     }
 
-    if (hw_mdl == NULL) {
+    if (hw_mdl == nullptr) {
         ALOGE("No valid fingerprint module");
         return nullptr;
     }
 
     fingerprint_module_t const *module =
         reinterpret_cast<const fingerprint_module_t*>(hw_mdl);
-    if (module->common.methods->open == NULL) {
+    if (module->common.methods->open == nullptr) {
         ALOGE("No valid open method");
         return nullptr;
     }
 
-    hw_device_t *device = NULL;
+    hw_device_t *device = nullptr;
 
-    if (0 != (err = module->common.methods->open(hw_mdl, NULL, &device))) {
+    if (0 != (err = module->common.methods->open(hw_mdl, nullptr, &device))) {
         ALOGE("Can't open fingerprint methods, error: %d", err);
         return nullptr;
     }
 
     if (kVersion != device->version) {
+        // enforce version on new devices because of HIDL@2.1 translation layer
         ALOGE("Wrong fp version. Expected %d, got %d", kVersion, device->version);
-        return 0; // enforce this on new devices because of HIDL translation layer
+        return nullptr;
     }
 
     fingerprint_device_t* fp_device =
@@ -240,23 +249,67 @@
         return nullptr;
     }
 
-    return new BiometricsFingerprint(fp_device);
+    return fp_device;
 }
 
-void BiometricsFingerprint::notifyKeystore(const uint8_t *auth_token, const size_t auth_token_length) {
-    if (auth_token != nullptr && auth_token_length > 0) {
-        // TODO: cache service?
-        sp<IServiceManager> sm = android::defaultServiceManager();
-        sp<::android::IBinder> binder = sm->getService(String16("android.security.keystore"));
-        sp<IKeystoreService> service = interface_cast<IKeystoreService>(binder);
-        if (service != nullptr) {
-            auto ret = service->addAuthToken(auth_token, auth_token_length);
-            if (!ret.isOk()) {
-                ALOGE("Failure sending auth token to KeyStore: %" PRId32, int32_t(ret));
+void BiometricsFingerprint::notify(const fingerprint_msg_t *msg) {
+    BiometricsFingerprint* thisPtr = static_cast<BiometricsFingerprint*>(
+            BiometricsFingerprint::getInstance());
+    if (thisPtr == nullptr || thisPtr->mClientCallback == nullptr) {
+        ALOGE("Receiving callbacks before the client callback is registered.");
+        return;
+    }
+    const uint64_t devId = reinterpret_cast<uint64_t>(thisPtr->mDevice);
+    switch (msg->type) {
+        case FINGERPRINT_ERROR: {
+                int32_t vendorCode = 0;
+                FingerprintError result = VendorErrorFilter(msg->data.error, &vendorCode);
+                thisPtr->mClientCallback->onError(devId, result, vendorCode);
             }
-        } else {
-            ALOGE("Unable to communicate with KeyStore");
-        }
+            break;
+        case FINGERPRINT_ACQUIRED: {
+                int32_t vendorCode = 0;
+                FingerprintAcquiredInfo result =
+                    VendorAcquiredFilter(msg->data.acquired.acquired_info, &vendorCode);
+                thisPtr->mClientCallback->onAcquired(devId, result, vendorCode);
+            }
+            break;
+        case FINGERPRINT_TEMPLATE_ENROLLING:
+            thisPtr->mClientCallback->onEnrollResult(devId,
+                msg->data.enroll.finger.fid,
+                msg->data.enroll.finger.gid,
+                msg->data.enroll.samples_remaining);
+            break;
+        case FINGERPRINT_TEMPLATE_REMOVED:
+            thisPtr->mClientCallback->onRemoved(devId,
+                msg->data.removed.finger.fid,
+                msg->data.removed.finger.gid,
+                msg->data.removed.remaining_templates);
+            break;
+        case FINGERPRINT_AUTHENTICATED:
+            if (msg->data.authenticated.finger.fid != 0) {
+                const uint8_t* hat =
+                    reinterpret_cast<const uint8_t *>(&msg->data.authenticated.hat);
+                const hidl_vec<uint8_t> token(
+                    std::vector<uint8_t>(hat, hat + sizeof(msg->data.authenticated.hat)));
+                thisPtr->mClientCallback->onAuthenticated(devId,
+                    msg->data.authenticated.finger.fid,
+                    msg->data.authenticated.finger.gid,
+                    token);
+            } else {
+                // Not a recognized fingerprint
+                thisPtr->mClientCallback->onAuthenticated(devId,
+                    msg->data.authenticated.finger.fid,
+                    msg->data.authenticated.finger.gid,
+                    hidl_vec<uint8_t>());
+            }
+            break;
+        case FINGERPRINT_TEMPLATE_ENUMERATING:
+            thisPtr->mClientCallback->onEnumerate(devId,
+                msg->data.enumerated.finger.fid,
+                msg->data.enumerated.finger.gid,
+                msg->data.enumerated.remaining_templates);
+            break;
     }
 }
 
diff --git a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h
index 1f44a1c..652a3e0 100644
--- a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h
+++ b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h
@@ -43,7 +43,7 @@
 
 struct BiometricsFingerprint : public IBiometricsFingerprint {
 public:
-    BiometricsFingerprint(fingerprint_device_t *device);
+    BiometricsFingerprint();
     ~BiometricsFingerprint();
 
     // Method to wrap legacy HAL with BiometricsFingerprint class
@@ -60,68 +60,17 @@
     Return<RequestStatus> remove(uint32_t gid, uint32_t fid) override;
     Return<RequestStatus> setActiveGroup(uint32_t gid, const hidl_string& storePath) override;
     Return<RequestStatus> authenticate(uint64_t operationId, uint32_t gid) override;
-    static void notify(const fingerprint_msg_t *msg) {
-        if (mClientCallback == nullptr) {
-            ALOGE("Receiving callbacks before the client callback is registered.");
-            return;
-        }
-        const uint64_t devId = reinterpret_cast<uint64_t>(sDevice);
-        switch (msg->type) {
-            case FINGERPRINT_ERROR: {
-                int32_t vendorCode = 0;
-                FingerprintError result =
-                    VendorErrorFilter(msg->data.error, &vendorCode);
-                mClientCallback->onError(devId, result, vendorCode);
-                }
-                break;
-            case FINGERPRINT_ACQUIRED: {
-                int32_t vendorCode = 0;
-                FingerprintAcquiredInfo result =
-                    VendorAcquiredFilter(msg->data.acquired.acquired_info,
-                                         &vendorCode);
-                mClientCallback->onAcquired(devId, result, vendorCode);
-                }
-                break;
-            case FINGERPRINT_TEMPLATE_ENROLLING:
-                mClientCallback->onEnrollResult(devId,
-                    msg->data.enroll.finger.fid,
-                    msg->data.enroll.finger.gid,
-                    msg->data.enroll.samples_remaining);
-                break;
-            case FINGERPRINT_TEMPLATE_REMOVED:
-                mClientCallback->onRemoved(devId,
-                    msg->data.removed.finger.fid,
-                    msg->data.removed.finger.gid,
-                    msg->data.removed.remaining_templates);
-                break;
-            case FINGERPRINT_AUTHENTICATED:
-                if (msg->data.authenticated.finger.fid != 0) {
-                    const uint8_t* hat =
-                            reinterpret_cast<const uint8_t *>(&msg->data.authenticated.hat);
-                    notifyKeystore(hat, sizeof(msg->data.authenticated.hat));
-                }
-                mClientCallback->onAuthenticated(devId,
-                    msg->data.authenticated.finger.fid,
-                    msg->data.authenticated.finger.gid);
-                break;
-            case FINGERPRINT_TEMPLATE_ENUMERATING:
-                mClientCallback->onEnumerate(devId,
-                    msg->data.enumerated.finger.fid,
-                    msg->data.enumerated.finger.gid,
-                    msg->data.enumerated.remaining_templates);
-                break;
-        }
-    }
+
 private:
-    Return<RequestStatus> ErrorFilter(int32_t error);
-    static void notifyKeystore(const uint8_t *auth_token, const size_t auth_token_length);
-    static FingerprintError VendorErrorFilter(int32_t error,
-            int32_t* vendorCode);
-    static FingerprintAcquiredInfo VendorAcquiredFilter(int32_t error,
-            int32_t* vendorCode);
-    static sp<IBiometricsFingerprintClientCallback> mClientCallback;
+    static fingerprint_device_t* openHal();
+    static void notify(const fingerprint_msg_t *msg); /* Static callback for legacy HAL implementation */
+    static Return<RequestStatus> ErrorFilter(int32_t error);
+    static FingerprintError VendorErrorFilter(int32_t error, int32_t* vendorCode);
+    static FingerprintAcquiredInfo VendorAcquiredFilter(int32_t error, int32_t* vendorCode);
+    static BiometricsFingerprint* sInstance;
+
+    sp<IBiometricsFingerprintClientCallback> mClientCallback;
     fingerprint_device_t *mDevice;
-    static fingerprint_device_t *sDevice; // TODO: allow multiple drivers
 };
 
 }  // namespace implementation
diff --git a/bluetooth/1.0/default/Android.bp b/bluetooth/1.0/default/Android.bp
index 32e5328..a99cd9e 100644
--- a/bluetooth/1.0/default/Android.bp
+++ b/bluetooth/1.0/default/Android.bp
@@ -38,7 +38,9 @@
 cc_test_host {
     name: "bluetooth-vendor-interface-unit-tests",
     srcs: [
+        "async_fd_watcher.cc",
         "bluetooth_address.cc",
+        "test/async_fd_watcher_unittest.cc",
         "test/bluetooth_address_test.cc",
         "test/properties.cc",
     ],
diff --git a/bluetooth/1.0/default/async_fd_watcher.cc b/bluetooth/1.0/default/async_fd_watcher.cc
index 636b4b6..9cd86f1 100644
--- a/bluetooth/1.0/default/async_fd_watcher.cc
+++ b/bluetooth/1.0/default/async_fd_watcher.cc
@@ -50,6 +50,20 @@
   return 0;
 }
 
+int AsyncFdWatcher::ConfigureTimeout(
+    const std::chrono::milliseconds timeout,
+    const TimeoutCallback& on_timeout_callback) {
+  // Add timeout and callback
+  {
+    std::unique_lock<std::mutex> guard(timeout_mutex_);
+    timeout_cb_ = on_timeout_callback;
+    timeout_ms_ = timeout;
+  }
+
+  notifyThread();
+  return 0;
+}
+
 void AsyncFdWatcher::StopWatchingFileDescriptor() { stopThread(); }
 
 AsyncFdWatcher::~AsyncFdWatcher() {}
@@ -86,6 +100,11 @@
     read_fd_ = -1;
   }
 
+  {
+    std::unique_lock<std::mutex> guard(timeout_mutex_);
+    timeout_cb_ = nullptr;
+  }
+
   return 0;
 }
 
@@ -104,21 +123,37 @@
     FD_SET(notification_listen_fd_, &read_fds);
     FD_SET(read_fd_, &read_fds);
 
-    // Wait until there is data available to read on some FD
-    int nfds = std::max(notification_listen_fd_, read_fd_);
-    int retval = select(nfds + 1, &read_fds, NULL, NULL, NULL);
-    if (retval <= 0) continue;  // there was some error or a timeout
+    struct timeval timeout;
+    struct timeval* timeout_ptr = NULL;
+    if (timeout_ms_ > std::chrono::milliseconds(0)) {
+      timeout.tv_sec = timeout_ms_.count() / 1000;
+      timeout.tv_usec = (timeout_ms_.count() % 1000) * 1000;
+      timeout_ptr = &timeout;
+    }
 
-    // Read data from the notification FD
+    // Wait until there is data available to read on some FD.
+    int nfds = std::max(notification_listen_fd_, read_fd_);
+    int retval = select(nfds + 1, &read_fds, NULL, NULL, timeout_ptr);
+
+    // There was some error.
+    if (retval < 0) continue;
+
+    // Timeout.
+    if (retval == 0) {
+      std::unique_lock<std::mutex> guard(timeout_mutex_);
+      if (timeout_ms_ > std::chrono::milliseconds(0) && timeout_cb_)
+        timeout_cb_();
+      continue;
+    }
+
+    // Read data from the notification FD.
     if (FD_ISSET(notification_listen_fd_, &read_fds)) {
       char buffer[] = {0};
       TEMP_FAILURE_RETRY(read(notification_listen_fd_, buffer, 1));
+      continue;
     }
 
-    // Make sure we're still running
-    if (!running_) break;
-
-    // Invoke the data ready callback if appropriate
+    // Invoke the data ready callback if appropriate.
     if (FD_ISSET(read_fd_, &read_fds)) {
       std::unique_lock<std::mutex> guard(internal_mutex_);
       if (cb_) cb_(read_fd_);
diff --git a/bluetooth/1.0/default/async_fd_watcher.h b/bluetooth/1.0/default/async_fd_watcher.h
index 1e4da8c..d6e112f 100644
--- a/bluetooth/1.0/default/async_fd_watcher.h
+++ b/bluetooth/1.0/default/async_fd_watcher.h
@@ -26,6 +26,7 @@
 namespace implementation {
 
 using ReadCallback = std::function<void(int)>;
+using TimeoutCallback = std::function<void(void)>;
 
 class AsyncFdWatcher {
  public:
@@ -34,6 +35,8 @@
 
   int WatchFdForNonBlockingReads(int file_descriptor,
                                  const ReadCallback& on_read_fd_ready_callback);
+  int ConfigureTimeout(const std::chrono::milliseconds timeout,
+                       const TimeoutCallback& on_timeout_callback);
   void StopWatchingFileDescriptor();
 
  private:
@@ -48,11 +51,14 @@
   std::atomic_bool running_{false};
   std::thread thread_;
   std::mutex internal_mutex_;
+  std::mutex timeout_mutex_;
 
   int read_fd_;
   int notification_listen_fd_;
   int notification_write_fd_;
   ReadCallback cb_;
+  TimeoutCallback timeout_cb_;
+  std::chrono::milliseconds timeout_ms_;
 };
 
 
diff --git a/bluetooth/1.0/default/bluetooth_hci.cc b/bluetooth/1.0/default/bluetooth_hci.cc
index 1559119..6cea623 100644
--- a/bluetooth/1.0/default/bluetooth_hci.cc
+++ b/bluetooth/1.0/default/bluetooth_hci.cc
@@ -83,8 +83,7 @@
 
 void BluetoothHci::sendDataToController(const uint8_t type,
                                         const hidl_vec<uint8_t>& data) {
-  VendorInterface::get()->Send(&type, 1);
-  VendorInterface::get()->Send(data.data(), data.size());
+  VendorInterface::get()->Send(type, data.data(), data.size());
 }
 
 IBluetoothHci* HIDL_FETCH_IBluetoothHci(const char* /* name */) {
diff --git a/bluetooth/1.0/default/hci_internals.h b/bluetooth/1.0/default/hci_internals.h
index d839590..d5714be 100644
--- a/bluetooth/1.0/default/hci_internals.h
+++ b/bluetooth/1.0/default/hci_internals.h
@@ -42,3 +42,6 @@
 const size_t HCI_LENGTH_OFFSET_EVT = 1;
 
 const size_t HCI_PREAMBLE_SIZE_MAX = HCI_ACL_PREAMBLE_SIZE;
+
+// Event codes (Volume 2, Part E, 7.7.14)
+const uint8_t HCI_COMMAND_COMPLETE_EVENT = 0x0E;
diff --git a/bluetooth/1.0/default/test/async_fd_watcher_unittest.cc b/bluetooth/1.0/default/test/async_fd_watcher_unittest.cc
new file mode 100644
index 0000000..c21acb8
--- /dev/null
+++ b/bluetooth/1.0/default/test/async_fd_watcher_unittest.cc
@@ -0,0 +1,295 @@
+//
+// Copyright 2017 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.
+//
+
+#include "async_fd_watcher.h"
+#include <gtest/gtest.h>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <utils/Log.h>
+
+namespace android {
+namespace hardware {
+namespace bluetooth {
+namespace V1_0 {
+namespace implementation {
+
+class AsyncFdWatcherSocketTest : public ::testing::Test {
+ public:
+  static const uint16_t kPort = 6111;
+  static const size_t kBufferSize = 16;
+
+  bool CheckBufferEquals() {
+    return strcmp(server_buffer_, client_buffer_) == 0;
+  }
+
+ protected:
+  int StartServer() {
+    ALOGD("%s", __func__);
+    struct sockaddr_in serv_addr;
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    EXPECT_FALSE(fd < 0);
+
+    memset(&serv_addr, 0, sizeof(serv_addr));
+    serv_addr.sin_family = AF_INET;
+    serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    serv_addr.sin_port = htons(kPort);
+    int reuse_flag = 1;
+    EXPECT_FALSE(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse_flag,
+                            sizeof(reuse_flag)) < 0);
+    EXPECT_FALSE(bind(fd, (sockaddr*)&serv_addr, sizeof(serv_addr)) <
+                 0);
+
+    ALOGD("%s before listen", __func__);
+    listen(fd, 1);
+    return fd;
+  }
+
+  int AcceptConnection(int fd) {
+    ALOGD("%s", __func__);
+    struct sockaddr_in cli_addr;
+    memset(&cli_addr, 0, sizeof(cli_addr));
+    socklen_t clilen = sizeof(cli_addr);
+
+    int connection_fd = accept(fd, (struct sockaddr*)&cli_addr, &clilen);
+    EXPECT_FALSE(connection_fd < 0);
+
+    return connection_fd;
+  }
+
+  void ReadIncomingMessage(int fd) {
+    ALOGD("%s", __func__);
+    int n = TEMP_FAILURE_RETRY(read(fd, server_buffer_, kBufferSize - 1));
+    EXPECT_FALSE(n < 0);
+
+    if (n == 0)  // got EOF
+      ALOGD("%s: EOF", __func__);
+    else
+      ALOGD("%s: Got something", __func__);
+      n = write(fd, "1", 1);
+  }
+
+  void SetUp() override {
+    ALOGD("%s", __func__);
+    memset(server_buffer_, 0, kBufferSize);
+    memset(client_buffer_, 0, kBufferSize);
+  }
+
+  void ConfigureServer() {
+    socket_fd_ = StartServer();
+
+    conn_watcher_.WatchFdForNonBlockingReads(socket_fd_, [this](int fd) {
+      int connection_fd = AcceptConnection(fd);
+      ALOGD("%s: Conn_watcher fd = %d", __func__, fd);
+
+      conn_watcher_.ConfigureTimeout(std::chrono::seconds(0), [this]() { bool connection_timeout_cleared = false; ASSERT_TRUE(connection_timeout_cleared); });
+
+      ALOGD("%s: 3", __func__);
+      async_fd_watcher_.WatchFdForNonBlockingReads(
+          connection_fd, [this](int fd) { ReadIncomingMessage(fd); });
+
+      // Time out if it takes longer than a second.
+      SetTimeout(std::chrono::seconds(1));
+    });
+    conn_watcher_.ConfigureTimeout(std::chrono::seconds(1), [this]() { bool connection_timeout = true; ASSERT_FALSE(connection_timeout); });
+  }
+
+  void CleanUpServer() {
+    async_fd_watcher_.StopWatchingFileDescriptor();
+    conn_watcher_.StopWatchingFileDescriptor();
+    close(socket_fd_);
+  }
+
+  void TearDown() override {
+    ALOGD("%s 3", __func__);
+    EXPECT_TRUE(CheckBufferEquals());
+  }
+
+  void OnTimeout() {
+    ALOGD("%s", __func__);
+    timed_out_ = true;
+  }
+
+  void ClearTimeout() {
+    ALOGD("%s", __func__);
+    timed_out_ = false;
+  }
+
+  bool TimedOut() {
+    ALOGD("%s %d", __func__, timed_out_? 1 : 0);
+    return timed_out_;
+  }
+
+  void SetTimeout(std::chrono::milliseconds timeout_ms) {
+    ALOGD("%s", __func__);
+    async_fd_watcher_.ConfigureTimeout(timeout_ms, [this]() { OnTimeout(); });
+    ClearTimeout();
+  }
+
+  int ConnectClient() {
+    ALOGD("%s", __func__);
+    int socket_cli_fd = socket(AF_INET, SOCK_STREAM, 0);
+    EXPECT_FALSE(socket_cli_fd < 0);
+
+    struct sockaddr_in serv_addr;
+    memset((void*)&serv_addr, 0, sizeof(serv_addr));
+    serv_addr.sin_family = AF_INET;
+    serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    serv_addr.sin_port = htons(kPort);
+
+    int result =
+        connect(socket_cli_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
+    EXPECT_FALSE(result < 0);
+
+    return socket_cli_fd;
+  }
+
+  void WriteFromClient(int socket_cli_fd) {
+    ALOGD("%s", __func__);
+    strcpy(client_buffer_, "1");
+    int n = write(socket_cli_fd, client_buffer_, strlen(client_buffer_));
+    EXPECT_TRUE(n > 0);
+  }
+
+  void AwaitServerResponse(int socket_cli_fd) {
+    ALOGD("%s", __func__);
+    int n = read(socket_cli_fd, client_buffer_, 1);
+    ALOGD("%s done", __func__);
+    EXPECT_TRUE(n > 0);
+  }
+
+ private:
+  AsyncFdWatcher async_fd_watcher_;
+  AsyncFdWatcher conn_watcher_;
+  int socket_fd_;
+  char server_buffer_[kBufferSize];
+  char client_buffer_[kBufferSize];
+  bool timed_out_;
+};
+
+// Use a single AsyncFdWatcher to signal a connection to the server socket.
+TEST_F(AsyncFdWatcherSocketTest, Connect) {
+  int socket_fd = StartServer();
+
+  AsyncFdWatcher conn_watcher;
+  conn_watcher.WatchFdForNonBlockingReads(socket_fd, [this](int fd) {
+    int connection_fd = AcceptConnection(fd);
+    close(connection_fd);
+  });
+
+  // Fail if the client doesn't connect within 1 second.
+  conn_watcher.ConfigureTimeout(std::chrono::seconds(1), [this]() {
+     bool connection_timeout = true;
+     ASSERT_FALSE(connection_timeout);
+  });
+
+  ConnectClient();
+  conn_watcher.StopWatchingFileDescriptor();
+  close(socket_fd);
+}
+
+// Use a single AsyncFdWatcher to signal a connection to the server socket.
+TEST_F(AsyncFdWatcherSocketTest, TimedOutConnect) {
+  int socket_fd = StartServer();
+  bool timed_out = false;
+  bool* timeout_ptr = &timed_out;
+
+  AsyncFdWatcher conn_watcher;
+  conn_watcher.WatchFdForNonBlockingReads(socket_fd, [this](int fd) {
+    int connection_fd = AcceptConnection(fd);
+    close(connection_fd);
+  });
+
+  // Set the timeout flag after 100ms.
+  conn_watcher.ConfigureTimeout(std::chrono::milliseconds(100), [this, timeout_ptr]() { *timeout_ptr = true; });
+  EXPECT_FALSE(timed_out);
+  sleep(1);
+  EXPECT_TRUE(timed_out);
+  conn_watcher.StopWatchingFileDescriptor();
+  close(socket_fd);
+}
+
+// Use two AsyncFdWatchers to set up a server socket.
+TEST_F(AsyncFdWatcherSocketTest, ClientServer) {
+  ConfigureServer();
+  int socket_cli_fd = ConnectClient();
+
+  WriteFromClient(socket_cli_fd);
+
+  AwaitServerResponse(socket_cli_fd);
+
+  close(socket_cli_fd);
+  CleanUpServer();
+}
+
+// Use two AsyncFdWatchers to set up a server socket, which times out.
+TEST_F(AsyncFdWatcherSocketTest, TimeOutTest) {
+  ConfigureServer();
+  int socket_cli_fd = ConnectClient();
+
+  while (!TimedOut()) sleep(1);
+
+  close(socket_cli_fd);
+  CleanUpServer();
+}
+
+// Use two AsyncFdWatchers to set up a server socket, which times out.
+TEST_F(AsyncFdWatcherSocketTest, RepeatedTimeOutTest) {
+  ConfigureServer();
+  int socket_cli_fd = ConnectClient();
+  ClearTimeout();
+
+  // Time out when there are no writes.
+  EXPECT_FALSE(TimedOut());
+  sleep(2);
+  EXPECT_TRUE(TimedOut());
+  ClearTimeout();
+
+  // Don't time out when there is a write.
+  WriteFromClient(socket_cli_fd);
+  AwaitServerResponse(socket_cli_fd);
+  EXPECT_FALSE(TimedOut());
+  ClearTimeout();
+
+  // Time out when the write is late.
+  sleep(2);
+  WriteFromClient(socket_cli_fd);
+  AwaitServerResponse(socket_cli_fd);
+  EXPECT_TRUE(TimedOut());
+  ClearTimeout();
+
+  // Time out when there is a pause after a write.
+  WriteFromClient(socket_cli_fd);
+  sleep(2);
+  AwaitServerResponse(socket_cli_fd);
+  EXPECT_TRUE(TimedOut());
+  ClearTimeout();
+
+  close(socket_cli_fd);
+  CleanUpServer();
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace bluetooth
+} // namespace hardware
+} // namespace android
diff --git a/bluetooth/1.0/default/vendor_interface.cc b/bluetooth/1.0/default/vendor_interface.cc
index 20b30ae..51a0add 100644
--- a/bluetooth/1.0/default/vendor_interface.cc
+++ b/bluetooth/1.0/default/vendor_interface.cc
@@ -16,6 +16,8 @@
 
 #include "vendor_interface.h"
 
+#include <assert.h>
+
 #define LOG_TAG "android.hardware.bluetooth@1.0-impl"
 #include <android-base/logging.h>
 #include <cutils/properties.h>
@@ -38,6 +40,8 @@
 using android::hardware::hidl_vec;
 
 tINT_CMD_CBACK internal_command_cb;
+uint16_t internal_command_opcode;
+
 VendorInterface* g_vendor_interface = nullptr;
 
 const size_t preamble_size_for_type[] = {
@@ -47,11 +51,10 @@
     0, HCI_LENGTH_OFFSET_CMD, HCI_LENGTH_OFFSET_ACL, HCI_LENGTH_OFFSET_SCO,
     HCI_LENGTH_OFFSET_EVT};
 
-size_t HciGetPacketLengthForType(HciPacketType type,
-                                 const hidl_vec<uint8_t>& packet) {
+size_t HciGetPacketLengthForType(HciPacketType type, const uint8_t* preamble) {
   size_t offset = packet_length_offset_for_type[type];
-  if (type != HCI_PACKET_TYPE_ACL_DATA) return packet[offset];
-  return (((packet[offset + 1]) << 8) | packet[offset]);
+  if (type != HCI_PACKET_TYPE_ACL_DATA) return preamble[offset];
+  return (((preamble[offset + 1]) << 8) | preamble[offset]);
 }
 
 HC_BT_HDR* WrapPacketAndCopy(uint16_t event, const hidl_vec<uint8_t>& data) {
@@ -67,13 +70,54 @@
   return packet;
 }
 
+size_t write_safely(int fd, const uint8_t* data, size_t length) {
+  size_t transmitted_length = 0;
+  while (length > 0) {
+    ssize_t ret =
+        TEMP_FAILURE_RETRY(write(fd, data + transmitted_length, length));
+
+    if (ret == -1) {
+      if (errno == EAGAIN) continue;
+      ALOGE("%s error writing to UART (%s)", __func__, strerror(errno));
+      break;
+
+    } else if (ret == 0) {
+      // Nothing written :(
+      ALOGE("%s zero bytes written - something went wrong...", __func__);
+      break;
+    }
+
+    transmitted_length += ret;
+    length -= ret;
+  }
+
+  return transmitted_length;
+}
+
+bool internal_command_event_match(const hidl_vec<uint8_t>& packet) {
+  uint8_t event_code = packet[0];
+  if (event_code != HCI_COMMAND_COMPLETE_EVENT) {
+    ALOGE("%s: Unhandled event type %02X", __func__, event_code);
+    return false;
+  }
+
+  size_t opcode_offset = HCI_EVENT_PREAMBLE_SIZE + 1;  // Skip num packets.
+
+  uint16_t opcode = packet[opcode_offset] | (packet[opcode_offset + 1] << 8);
+
+  ALOGV("%s internal_command_opcode = %04X opcode = %04x", __func__,
+        internal_command_opcode, opcode);
+  return opcode == internal_command_opcode;
+}
+
 uint8_t transmit_cb(uint16_t opcode, void* buffer, tINT_CMD_CBACK callback) {
-  ALOGV("%s opcode: 0x%04x, ptr: %p", __func__, opcode, buffer);
+  ALOGV("%s opcode: 0x%04x, ptr: %p, cb: %p", __func__, opcode, buffer,
+        callback);
   internal_command_cb = callback;
+  internal_command_opcode = opcode;
   uint8_t type = HCI_PACKET_TYPE_COMMAND;
-  VendorInterface::get()->Send(&type, 1);
   HC_BT_HDR* bt_hdr = reinterpret_cast<HC_BT_HDR*>(buffer);
-  VendorInterface::get()->Send(bt_hdr->data, bt_hdr->len);
+  VendorInterface::get()->Send(type, bt_hdr->data, bt_hdr->len);
   return true;
 }
 
@@ -137,7 +181,7 @@
         std::chrono::steady_clock::now() - start_time_;
     double s = duration.count();
     if (s == 0) return;
-    ALOGD("Firmware configured in %.3fs", s);
+    ALOGI("Firmware configured in %.3fs", s);
   }
 
  private:
@@ -219,7 +263,7 @@
     return false;
   }
 
-  ALOGD("%s UART fd: %d", __func__, uart_fd_);
+  ALOGI("%s UART fd: %d", __func__, uart_fd_);
 
   fd_watcher_.WatchFdForNonBlockingReads(uart_fd_,
                                          [this](int fd) { OnDataReady(fd); });
@@ -252,35 +296,18 @@
   }
 }
 
-size_t VendorInterface::Send(const uint8_t* data, size_t length) {
+size_t VendorInterface::Send(uint8_t type, const uint8_t* data, size_t length) {
   if (uart_fd_ == INVALID_FD) return 0;
 
-  size_t transmitted_length = 0;
-  while (length > 0) {
-    ssize_t ret =
-        TEMP_FAILURE_RETRY(write(uart_fd_, data + transmitted_length, length));
+  int rv = write_safely(uart_fd_, &type, sizeof(type));
+  if (rv == sizeof(type))
+    rv = write_safely(uart_fd_, data, length);
 
-    if (ret == -1) {
-      if (errno == EAGAIN) continue;
-      ALOGE("%s error writing to UART (%s)", __func__, strerror(errno));
-      break;
-
-    } else if (ret == 0) {
-      // Nothing written :(
-      ALOGE("%s zero bytes written - something went wrong...", __func__);
-      break;
-    }
-
-    transmitted_length += ret;
-    length -= ret;
-  }
-
-  return transmitted_length;
+  return rv;
 }
 
 void VendorInterface::OnFirmwareConfigured(uint8_t result) {
   ALOGD("%s result: %d", __func__, result);
-  internal_command_cb = nullptr;
 
   if (firmware_startup_timer_ != nullptr) {
     delete firmware_startup_timer_;
@@ -303,9 +330,8 @@
       // TODO(eisenbach): Check for workaround(s)
       CHECK(hci_packet_type_ >= HCI_PACKET_TYPE_ACL_DATA &&
             hci_packet_type_ <= HCI_PACKET_TYPE_EVENT)
-          << "buffer[0] = " << buffer[0];
+          << "buffer[0] = " << static_cast<unsigned int>(buffer[0]);
       hci_parser_state_ = HCI_TYPE_READY;
-      hci_packet_.resize(HCI_PREAMBLE_SIZE_MAX);
       hci_packet_bytes_remaining_ = preamble_size_for_type[hci_packet_type_];
       hci_packet_bytes_read_ = 0;
       break;
@@ -313,16 +339,18 @@
 
     case HCI_TYPE_READY: {
       size_t bytes_read = TEMP_FAILURE_RETRY(
-          read(fd, hci_packet_.data() + hci_packet_bytes_read_,
+          read(fd, hci_packet_preamble_ + hci_packet_bytes_read_,
                hci_packet_bytes_remaining_));
       CHECK(bytes_read > 0);
       hci_packet_bytes_remaining_ -= bytes_read;
       hci_packet_bytes_read_ += bytes_read;
       if (hci_packet_bytes_remaining_ == 0) {
         size_t packet_length =
-            HciGetPacketLengthForType(hci_packet_type_, hci_packet_);
+            HciGetPacketLengthForType(hci_packet_type_, hci_packet_preamble_);
         hci_packet_.resize(preamble_size_for_type[hci_packet_type_] +
                            packet_length);
+        memcpy(hci_packet_.data(), hci_packet_preamble_,
+               preamble_size_for_type[hci_packet_type_]);
         hci_packet_bytes_remaining_ = packet_length;
         hci_parser_state_ = HCI_PAYLOAD;
         hci_packet_bytes_read_ = 0;
@@ -339,17 +367,18 @@
       hci_packet_bytes_remaining_ -= bytes_read;
       hci_packet_bytes_read_ += bytes_read;
       if (hci_packet_bytes_remaining_ == 0) {
-        if (internal_command_cb != nullptr) {
+        if (internal_command_cb != nullptr &&
+            hci_packet_type_ == HCI_PACKET_TYPE_EVENT &&
+            internal_command_event_match(hci_packet_)) {
           HC_BT_HDR* bt_hdr =
               WrapPacketAndCopy(HCI_PACKET_TYPE_EVENT, hci_packet_);
-          internal_command_cb(bt_hdr);
-        } else if (packet_read_cb_ != nullptr &&
-                   initialize_complete_cb_ == nullptr) {
-          packet_read_cb_(hci_packet_type_, hci_packet_);
+
+          // The callbacks can send new commands, so don't zero after calling.
+          tINT_CMD_CBACK saved_cb = internal_command_cb;
+          internal_command_cb = nullptr;
+          saved_cb(bt_hdr);
         } else {
-          ALOGE(
-              "%s HCI_PAYLOAD received without packet_read_cb or pending init.",
-              __func__);
+          packet_read_cb_(hci_packet_type_, hci_packet_);
         }
         hci_parser_state_ = HCI_IDLE;
       }
diff --git a/bluetooth/1.0/default/vendor_interface.h b/bluetooth/1.0/default/vendor_interface.h
index 450b99c..79611cd 100644
--- a/bluetooth/1.0/default/vendor_interface.h
+++ b/bluetooth/1.0/default/vendor_interface.h
@@ -42,14 +42,15 @@
   static void Shutdown();
   static VendorInterface *get();
 
-  size_t Send(const uint8_t *data, size_t length);
+  size_t Send(uint8_t type, const uint8_t *data, size_t length);
 
   void OnFirmwareConfigured(uint8_t result);
 
  private:
   virtual ~VendorInterface() = default;
 
-  bool Open(InitializeCompleteCallback initialize_complete_cb, PacketReadCallback packet_read_cb);
+  bool Open(InitializeCompleteCallback initialize_complete_cb,
+            PacketReadCallback packet_read_cb);
   void Close();
 
   void OnDataReady(int fd);
@@ -64,6 +65,7 @@
   enum HciParserState { HCI_IDLE, HCI_TYPE_READY, HCI_PAYLOAD };
   HciParserState hci_parser_state_{HCI_IDLE};
   HciPacketType hci_packet_type_{HCI_PACKET_TYPE_UNKNOWN};
+  uint8_t hci_packet_preamble_[HCI_PREAMBLE_SIZE_MAX];
   hidl_vec<uint8_t> hci_packet_;
   size_t hci_packet_bytes_remaining_;
   size_t hci_packet_bytes_read_;
diff --git a/camera/provider/2.4/vts/functional/camera_hidl_hal_test.cpp b/camera/provider/2.4/vts/functional/camera_hidl_hal_test.cpp
index 0eb291c..0186371 100644
--- a/camera/provider/2.4/vts/functional/camera_hidl_hal_test.cpp
+++ b/camera/provider/2.4/vts/functional/camera_hidl_hal_test.cpp
@@ -95,7 +95,7 @@
 
 void CameraHidlEnvironment::SetUp() {
     // TODO: test the binderized mode
-    mProvider = ICameraProvider::getService(CAMERA_PASSTHROUGH_SERVICE_NAME, true);
+    mProvider = ICameraProvider::getService(CAMERA_PASSTHROUGH_SERVICE_NAME);
     // TODO: handle the device doesn't have any camera case
     ALOGI_IF(mProvider, "provider is not nullptr, %p", mProvider.get());
     ASSERT_NE(mProvider, nullptr);
diff --git a/drm/1.0/IDrmFactory.hal b/drm/1.0/IDrmFactory.hal
index de53929..f8e4779 100644
--- a/drm/1.0/IDrmFactory.hal
+++ b/drm/1.0/IDrmFactory.hal
@@ -50,10 +50,12 @@
      *
      * @param uuid uniquely identifies the drm scheme. See
      * http://dashif.org/identifiers/protection for uuid assignments
+     * @param appPackageName identifies the package name of the calling
+     * application.
      * @return status the status of the call. The HAL implementation must return
      * OK if the plugin is created and ERROR_DRM_CANNOT_HANDLE if the plugin
      * cannot be created.
      */
-    createPlugin(uint8_t[16] uuid) generates (Status status,
-            IDrmPlugin drmPlugin);
+    createPlugin(uint8_t[16] uuid, string appPackageName)
+            generates (Status status, IDrmPlugin drmPlugin);
 };
diff --git a/drm/1.0/default/CryptoFactory.cpp b/drm/1.0/default/CryptoFactory.cpp
index 02084e7..13cad67 100644
--- a/drm/1.0/default/CryptoFactory.cpp
+++ b/drm/1.0/default/CryptoFactory.cpp
@@ -13,11 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#define LOG_TAG "android.hardware.drm@1.0-impl"
+
+#include <utils/Log.h>
 
 #include "CryptoFactory.h"
 #include "CryptoPlugin.h"
 #include "TypeConvert.h"
-#include <utils/Log.h>
 
 namespace android {
 namespace hardware {
@@ -25,45 +27,63 @@
 namespace V1_0 {
 namespace implementation {
 
-    CryptoFactory::CryptoFactory() :
-        loader("/vendor/lib/mediadrm", "createCryptoFactory") {
-    }
+CryptoFactory::CryptoFactory() :
+    trebleLoader("/vendor/lib/hw", "createCryptoFactory"),
+    legacyLoader("/vendor/lib/mediadrm", "createCryptoFactory") {
+}
 
-    // Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.
-    Return<bool> CryptoFactory::isCryptoSchemeSupported(
-            const hidl_array<uint8_t, 16>& uuid) {
-        for (size_t i = 0; i < loader.factoryCount(); i++) {
-            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
-                return true;
-            }
-        }
-        return false;
-    }
+// Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.
+Return<bool> CryptoFactory::isCryptoSchemeSupported(
+        const hidl_array<uint8_t, 16>& uuid) {
+    return isCryptoSchemeSupported(trebleLoader, uuid) ||
+            isCryptoSchemeSupported(legacyLoader, uuid);
+}
 
-    Return<void> CryptoFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,
-            const hidl_vec<uint8_t>& initData, createPlugin_cb _hidl_cb) {
-        for (size_t i = 0; i < loader.factoryCount(); i++) {
-            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
-                android::CryptoPlugin *legacyPlugin = NULL;
-                status_t status = loader.getFactory(i)->createPlugin(uuid.data(),
-                        initData.data(), initData.size(), &legacyPlugin);
-                CryptoPlugin *newPlugin = NULL;
-                if (legacyPlugin == NULL) {
-                    ALOGE("Crypto legacy HAL: failed to create crypto plugin");
-                } else {
-                    newPlugin = new CryptoPlugin(legacyPlugin);
+Return<void> CryptoFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,
+        const hidl_vec<uint8_t>& initData, createPlugin_cb _hidl_cb) {
+    sp<ICryptoPlugin> plugin = createTreblePlugin(uuid, initData);
+    if (plugin == nullptr) {
+        plugin = createLegacyPlugin(uuid, initData);
+    }
+    _hidl_cb(plugin != nullptr ? Status::OK : Status::ERROR_DRM_CANNOT_HANDLE, plugin);
+    return Void();
+}
+
+sp<ICryptoPlugin> CryptoFactory::createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,
+        const hidl_vec<uint8_t>& initData) {
+    sp<ICryptoPlugin> plugin;
+    for (size_t i = 0; i < trebleLoader.factoryCount(); i++) {
+        Return<void> hResult = trebleLoader.getFactory(i)->createPlugin(uuid, initData,
+                [&](Status status, const sp<ICryptoPlugin>& hPlugin) {
+                    if (status == Status::OK) {
+                        plugin = hPlugin;
+                    }
                 }
-                _hidl_cb(toStatus(status), newPlugin);
-                return Void();
-            }
+            );
+        if (plugin != nullptr) {
+            return plugin;
         }
-        _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);
-        return Void();
     }
+    return nullptr;
+}
 
-    ICryptoFactory* HIDL_FETCH_ICryptoFactory(const char* /* name */) {
-        return new CryptoFactory();
+sp<ICryptoPlugin> CryptoFactory::createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid,
+        const hidl_vec<uint8_t>& initData) {
+    android::CryptoPlugin *legacyPlugin = nullptr;
+    for (size_t i = 0; i < legacyLoader.factoryCount(); i++) {
+        legacyLoader.getFactory(i)->createPlugin(uuid.data(),
+                initData.data(), initData.size(), &legacyPlugin);
+        if (legacyPlugin) {
+            return new CryptoPlugin(legacyPlugin);
+        }
     }
+    return nullptr;
+}
+
+
+ICryptoFactory* HIDL_FETCH_ICryptoFactory(const char* /* name */) {
+    return new CryptoFactory();
+}
 
 }  // namespace implementation
 }  // namespace V1_0
diff --git a/drm/1.0/default/CryptoFactory.h b/drm/1.0/default/CryptoFactory.h
index 412b557..d774406 100644
--- a/drm/1.0/default/CryptoFactory.h
+++ b/drm/1.0/default/CryptoFactory.h
@@ -41,8 +41,7 @@
     CryptoFactory();
     virtual ~CryptoFactory() {}
 
-    // Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.
-
+    // Methods from ::android::hardware::drmn::V1_0::ICryptoFactory follow.
     Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>& uuid)
             override;
 
@@ -51,7 +50,27 @@
             override;
 
 private:
-    android::PluginLoader<android::CryptoFactory> loader;
+    template <typename L> Return<bool> isCryptoSchemeSupported(
+            const L& loader, const hidl_array<uint8_t, 16>& uuid) {
+        for (size_t i = 0; i < loader.factoryCount(); i++) {
+           if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    sp<ICryptoPlugin> createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,
+                    const hidl_vec<uint8_t>& initData);
+
+    sp<ICryptoPlugin> createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid,
+                    const hidl_vec<uint8_t>& initData);
+
+    typedef android::PluginLoader<ICryptoFactory> PluginLoader;
+    PluginLoader trebleLoader;
+
+    typedef android::PluginLoader<android::CryptoFactory> LegacyLoader;
+    LegacyLoader legacyLoader;
 
     CryptoFactory(const CryptoFactory &) = delete;
     void operator=(const CryptoFactory &) = delete;
diff --git a/drm/1.0/default/CryptoPlugin.cpp b/drm/1.0/default/CryptoPlugin.cpp
index 073f030..fb61ede 100644
--- a/drm/1.0/default/CryptoPlugin.cpp
+++ b/drm/1.0/default/CryptoPlugin.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#define LOG_TAG "android.hardware.drm@1.0-impl"
 
 #include "CryptoPlugin.h"
 #include "TypeConvert.h"
@@ -61,6 +62,11 @@
             const DestinationBuffer& destination,
             decrypt_cb _hidl_cb) {
 
+        if (mSharedBufferBase == NULL) {
+            _hidl_cb(Status::BAD_VALUE, 0, "decrypt buffer base not set");
+            return Void();
+        }
+
         android::CryptoPlugin::Mode legacyMode;
         switch(mode) {
         case Mode::UNENCRYPTED:
diff --git a/drm/1.0/default/DrmFactory.cpp b/drm/1.0/default/DrmFactory.cpp
index cba2c99..c98c1da 100644
--- a/drm/1.0/default/DrmFactory.cpp
+++ b/drm/1.0/default/DrmFactory.cpp
@@ -13,11 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#define LOG_TAG "android.hardware.drm@1.0-impl"
+
+#include <utils/Log.h>
 
 #include "DrmFactory.h"
 #include "DrmPlugin.h"
 #include "TypeConvert.h"
-#include <utils/Log.h>
 
 namespace android {
 namespace hardware {
@@ -25,56 +27,66 @@
 namespace V1_0 {
 namespace implementation {
 
-    DrmFactory::DrmFactory() :
-        loader("/vendor/lib/mediadrm", "createDrmFactory") {
-    }
+DrmFactory::DrmFactory() :
+    trebleLoader("/vendor/lib/hw", "createDrmFactory"),
+    legacyLoader("/vendor/lib/mediadrm", "createDrmFactory") {
+}
 
-    // Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.
-    Return<bool> DrmFactory::isCryptoSchemeSupported (
-            const hidl_array<uint8_t, 16>& uuid) {
-        for (size_t i = 0; i < loader.factoryCount(); i++) {
-            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
-                return true;
-            }
-        }
-        return false;
-    }
+// Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.
+Return<bool> DrmFactory::isCryptoSchemeSupported(
+        const hidl_array<uint8_t, 16>& uuid) {
+    return isCryptoSchemeSupported(trebleLoader, uuid) ||
+            isCryptoSchemeSupported(legacyLoader, uuid);
+}
 
-    Return<bool> DrmFactory::isContentTypeSupported (
-            const hidl_string& mimeType) {
-        for (size_t i = 0; i < loader.factoryCount(); i++) {
-            if (loader.getFactory(i)->isContentTypeSupported(String8(mimeType.c_str()))) {
-                return true;
-            }
-        }
-        return false;
-    }
+Return<bool> DrmFactory::isContentTypeSupported (
+        const hidl_string& mimeType) {
+    return isContentTypeSupported<PluginLoader, hidl_string>(trebleLoader, mimeType) ||
+            isContentTypeSupported<LegacyLoader, String8>(legacyLoader, mimeType);
+}
 
     Return<void> DrmFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,
-            createPlugin_cb _hidl_cb) {
+            const hidl_string& appPackageName, createPlugin_cb _hidl_cb) {
+        sp<IDrmPlugin> plugin = createTreblePlugin(uuid, appPackageName);
+    if (plugin == nullptr) {
+        plugin = createLegacyPlugin(uuid);
+    }
+    _hidl_cb(plugin != nullptr ? Status::OK : Status::ERROR_DRM_CANNOT_HANDLE, plugin);
+    return Void();
+}
 
-        for (size_t i = 0; i < loader.factoryCount(); i++) {
-            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
-                android::DrmPlugin *legacyPlugin = NULL;
-                status_t status = loader.getFactory(i)->createDrmPlugin(
-                        uuid.data(), &legacyPlugin);
-                DrmPlugin *newPlugin = NULL;
-                if (legacyPlugin == NULL) {
-                    ALOGE("Drm legacy HAL: failed to create drm plugin");
-                } else {
-                    newPlugin = new DrmPlugin(legacyPlugin);
+sp<IDrmPlugin> DrmFactory::createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,
+        const hidl_string& appPackageName) {
+    sp<IDrmPlugin> plugin;
+    for (size_t i = 0; i < trebleLoader.factoryCount(); i++) {
+        Return<void> hResult = trebleLoader.getFactory(i)->createPlugin(uuid,
+                appPackageName, [&](Status status, const sp<IDrmPlugin>& hPlugin) {
+                    if (status == Status::OK) {
+                        plugin = hPlugin;
+                    }
                 }
-                _hidl_cb(toStatus(status), newPlugin);
-                return Void();
-            }
+            );
+        if (plugin != nullptr) {
+            return plugin;
         }
-        _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);
-        return Void();
     }
+    return nullptr;
+}
 
-    IDrmFactory* HIDL_FETCH_IDrmFactory(const char* /* name */) {
-        return new DrmFactory();
+sp<IDrmPlugin> DrmFactory::createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid) {
+    android::DrmPlugin *legacyPlugin = nullptr;
+    for (size_t i = 0; i < legacyLoader.factoryCount(); i++) {
+        legacyLoader.getFactory(i)->createDrmPlugin(uuid.data(), &legacyPlugin);
+        if (legacyPlugin) {
+            return new DrmPlugin(legacyPlugin);
+        }
     }
+    return nullptr;
+}
+
+IDrmFactory* HIDL_FETCH_IDrmFactory(const char* /* name */) {
+    return new DrmFactory();
+}
 
 }  // namespace implementation
 }  // namespace V1_0
diff --git a/drm/1.0/default/DrmFactory.h b/drm/1.0/default/DrmFactory.h
index 78b7f6e..2e71624 100644
--- a/drm/1.0/default/DrmFactory.h
+++ b/drm/1.0/default/DrmFactory.h
@@ -42,18 +42,45 @@
     virtual ~DrmFactory() {}
 
     // Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.
-
     Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>& uuid)
             override;
 
-    Return<bool> isContentTypeSupported(const hidl_string &mimeType)
+    Return<bool> isContentTypeSupported(const hidl_string& mimeType)
             override;
 
     Return<void> createPlugin(const hidl_array<uint8_t, 16>& uuid,
-            createPlugin_cb _hidl_cb) override;
+            const hidl_string& appPackageName, createPlugin_cb _hidl_cb) override;
 
 private:
-    android::PluginLoader<android::DrmFactory> loader;
+    template <typename L> Return<bool> isCryptoSchemeSupported(
+            const L& loader, const hidl_array<uint8_t, 16>& uuid) {
+        for (size_t i = 0; i < loader.factoryCount(); i++) {
+            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    template <typename L, typename S> Return<bool> isContentTypeSupported(
+            const L& loader, const hidl_string& mimeType) {
+        for (size_t i = 0; i < loader.factoryCount(); i++) {
+            if (loader.getFactory(i)->isContentTypeSupported(S(mimeType))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    sp<IDrmPlugin> createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,
+        const hidl_string& appPackageName);
+    sp<IDrmPlugin> createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid);
+
+    typedef android::PluginLoader<IDrmFactory> PluginLoader;
+    PluginLoader trebleLoader;
+
+    typedef android::PluginLoader<android::DrmFactory> LegacyLoader;
+    LegacyLoader legacyLoader;
 
     DrmFactory(const DrmFactory &) = delete;
     void operator=(const DrmFactory &) = delete;
diff --git a/drm/1.0/default/DrmPlugin.cpp b/drm/1.0/default/DrmPlugin.cpp
index 9204fc5..1b2f90e 100644
--- a/drm/1.0/default/DrmPlugin.cpp
+++ b/drm/1.0/default/DrmPlugin.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#define LOG_TAG "android.hardware.drm@1.0-impl"
 
 #include <utils/KeyedVector.h>
 #include <utils/String8.h>
diff --git a/drm/1.0/default/TypeConvert.cpp b/drm/1.0/default/TypeConvert.cpp
index 52cc503..ede2a38 100644
--- a/drm/1.0/default/TypeConvert.cpp
+++ b/drm/1.0/default/TypeConvert.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#define LOG_TAG "android.hardware.drm@1.0-impl"
 
 #include "TypeConvert.h"
 
diff --git a/drm/1.0/default/service.cpp b/drm/1.0/default/service.cpp
index fba56ec..d2507c4 100644
--- a/drm/1.0/default/service.cpp
+++ b/drm/1.0/default/service.cpp
@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 #define LOG_TAG "android.hardware.drm@1.0-service"
 
 #include <1.0/default/CryptoFactory.h>
diff --git a/evs/1.0/IEvsCamera.hal b/evs/1.0/IEvsCamera.hal
index a2fc565..d0559d7 100644
--- a/evs/1.0/IEvsCamera.hal
+++ b/evs/1.0/IEvsCamera.hal
@@ -65,7 +65,7 @@
      * as one), and if the supply is exhausted, no further frames may be
      * delivered until a buffer is returned.
      */
-    doneWithFrame(uint32_t frameId, handle bufferHandle) generates (EvsResult result);
+    oneway doneWithFrame(BufferDesc buffer);
 
     /**
      * Stop the delivery of EVS camera frames.
diff --git a/evs/1.0/IEvsCameraStream.hal b/evs/1.0/IEvsCameraStream.hal
index ef5460f..fcd5717 100644
--- a/evs/1.0/IEvsCameraStream.hal
+++ b/evs/1.0/IEvsCameraStream.hal
@@ -32,5 +32,5 @@
      * must be delivered, signifying the end of the stream. No further frame
      * deliveries may happen thereafter.
      */
-    oneway deliverFrame(uint32_t frameId, handle bufferHandle);
+    oneway deliverFrame(BufferDesc buffer);
 };
diff --git a/evs/1.0/IEvsDisplay.hal b/evs/1.0/IEvsDisplay.hal
index a473872..8352221 100644
--- a/evs/1.0/IEvsDisplay.hal
+++ b/evs/1.0/IEvsDisplay.hal
@@ -65,7 +65,7 @@
      * must be returned via a call to returnTargetBufferForDisplay() even if the
      * display is no longer visible.
      */
-     getTargetBuffer() generates (handle bufferHandle);
+     getTargetBuffer() generates (BufferDesc buffer);
 
 
     /**
@@ -76,5 +76,5 @@
      * call. The buffer may be returned at any time and in any DisplayState, but all
      * buffers are expected to be returned before the IEvsDisplay interface is destroyed.
      */
-    returnTargetBufferForDisplay(handle bufferHandle) generates (EvsResult result);
+    returnTargetBufferForDisplay(BufferDesc buffer) generates (EvsResult result);
 };
diff --git a/evs/1.0/IEvsEnumerator.hal b/evs/1.0/IEvsEnumerator.hal
index e3a1382..3779866 100644
--- a/evs/1.0/IEvsEnumerator.hal
+++ b/evs/1.0/IEvsEnumerator.hal
@@ -67,5 +67,15 @@
      * NOTE: All buffer must have been returned to the display before making this call.
      */
     closeDisplay(IEvsDisplay display);
+
+    /**
+     * This call requests the current state of the display
+     *
+     * If there is no open display, this returns DisplayState::NOT_OPEN. otherwise, it returns
+     * the actual state of the active display.  This call is replicated on the IEvsEnumerator
+     * interface in order to allow secondary clients to monitor the state of the EVS display
+     * without acquiring exclusive ownership of the display.
+     */
+    getDisplayState() generates (DisplayState state);
 };
 
diff --git a/evs/1.0/default/Android.bp b/evs/1.0/default/Android.bp
index 3bda250..e3bff25 100644
--- a/evs/1.0/default/Android.bp
+++ b/evs/1.0/default/Android.bp
@@ -11,7 +11,6 @@
 
     shared_libs: [
         "android.hardware.evs@1.0",
-        "android.hardware.graphics.allocator@2.0",
         "libui",
         "libbase",
         "libbinder",
diff --git a/evs/1.0/default/EvsCamera.cpp b/evs/1.0/default/EvsCamera.cpp
index 6715a2e..c62f7b6 100644
--- a/evs/1.0/default/EvsCamera.cpp
+++ b/evs/1.0/default/EvsCamera.cpp
@@ -33,18 +33,22 @@
 const char EvsCamera::kCameraName_Backup[]    = "backup";
 const char EvsCamera::kCameraName_RightTurn[] = "Right Turn";
 
+// Arbitrary limit on number of graphics buffers allowed to be allocated
+// Safeguards against unreasonable resource consumption and provides a testable limit
+const unsigned MAX_BUFFERS_IN_FLIGHT = 100;
+
 
 // TODO(b/31632518):  Need to get notification when our client dies so we can close the camera.
-// As it stands, if the client dies suddently, the buffer may be stranded.
-// As possible work around would be to give the client a HIDL object to exclusively hold
-// and use it's destructor to perform some work in the server side.
+// As it stands, if the client dies suddenly, the buffer may be stranded.
 
-EvsCamera::EvsCamera(const char *id) {
+EvsCamera::EvsCamera(const char *id) :
+    mFramesAllowed(0),
+    mFramesInUse(0),
+    mStreamState(STOPPED) {
+
     ALOGD("EvsCamera instantiated");
 
     mDescription.cameraId = id;
-    mFrameBusy = false;
-    mStreamState = STOPPED;
 
     // Set up dummy data for testing
     if (mDescription.cameraId == kCameraName_Backup) {
@@ -52,16 +56,23 @@
         mDescription.vendorFlags            = 0xFFFFFFFF;   // Arbitrary value
         mDescription.defaultHorResolution   = 320;          // 1/2 NTSC/VGA
         mDescription.defaultVerResolution   = 240;          // 1/2 NTSC/VGA
-    }
-    else if (mDescription.cameraId == kCameraName_RightTurn) {
+    } else if (mDescription.cameraId == kCameraName_RightTurn) {
         // Nothing but the name and the usage hint
         mDescription.hints                  = static_cast<uint32_t>(UsageHint::USAGE_HINT_RIGHT_TURN);
-    }
-    else {
+    } else {
         // Leave empty for a minimalist camera description without even a hint
     }
+
+
+    // Set our buffer properties
+    mWidth  = (mDescription.defaultHorResolution) ? mDescription.defaultHorResolution : 640;
+    mHeight = (mDescription.defaultVerResolution) ? mDescription.defaultVerResolution : 480;
+
+    mFormat = HAL_PIXEL_FORMAT_RGBA_8888;
+    mUsage  = GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_CAMERA_WRITE;
 }
 
+
 EvsCamera::~EvsCamera() {
     ALOGD("EvsCamera being destroyed");
     std::lock_guard<std::mutex> lock(mAccessLock);
@@ -70,11 +81,14 @@
     // (It really should be already)
     stopVideoStream();
 
-    // Drop the graphics buffer we've been using
-    if (mBuffer) {
-        // Drop the graphics buffer we've been using
-        GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
-        alloc.free(mBuffer);
+    // Drop all the graphics buffers we've been using
+    GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
+    for (auto&& rec : mBuffers) {
+        if (rec.inUse) {
+            ALOGE("Error - releasing buffer despite remote ownership");
+        }
+        alloc.free(rec.handle);
+        rec.handle = nullptr;
     }
 
     ALOGD("EvsCamera destroyed");
@@ -95,113 +109,109 @@
     ALOGD("setMaxFramesInFlight");
     std::lock_guard<std::mutex> lock(mAccessLock);
 
-    // TODO:  Update our stored value
-
-    // TODO:  Adjust our buffer count right now if we can.  Otherwise, it'll adjust in doneWithFrame
-
-    // For now we support only one!
-    if (bufferCount != 1) {
-        return EvsResult::BUFFER_NOT_AVAILABLE;
+    // We cannot function without at least one video buffer to send data
+    if (bufferCount < 1) {
+        ALOGE("Ignoring setMaxFramesInFlight with less than one buffer requested");
+        return EvsResult::INVALID_ARG;
     }
 
-    return EvsResult::OK;
+    // Update our internal state
+    if (setAvailableFrames_Locked(bufferCount)) {
+        return EvsResult::OK;
+    } else {
+        return EvsResult::BUFFER_NOT_AVAILABLE;
+    }
 }
 
+
 Return<EvsResult> EvsCamera::startVideoStream(const ::android::sp<IEvsCameraStream>& stream)  {
     ALOGD("startVideoStream");
     std::lock_guard<std::mutex> lock(mAccessLock);
 
-    // We only support a single stream at a time
     if (mStreamState != STOPPED) {
         ALOGE("ignoring startVideoStream call when a stream is already running.");
         return EvsResult::STREAM_ALREADY_RUNNING;
     }
 
+    // If the client never indicated otherwise, configure ourselves for a single streaming buffer
+    if (mFramesAllowed < 1) {
+        if (!setAvailableFrames_Locked(1)) {
+            ALOGE("Failed to start stream because we couldn't get a graphics buffer");
+            return EvsResult::BUFFER_NOT_AVAILABLE;
+        }
+    }
+
     // Record the user's callback for use when we have a frame ready
     mStream = stream;
 
-    // Allocate a graphics buffer into which we'll put our test images
-    if (!mBuffer) {
-        mWidth  = (mDescription.defaultHorResolution) ? mDescription.defaultHorResolution : 640;
-        mHeight = (mDescription.defaultVerResolution) ? mDescription.defaultVerResolution : 480;
-        // TODO:  What about stride?  Assume no padding for now...
-        mStride = 4* mWidth;    // Special cased to assume 4 byte pixels with no padding for now
-
-        ALOGD("Allocating buffer for camera frame");
-        GraphicBufferAllocator &alloc(GraphicBufferAllocator::get());
-        status_t result = alloc.allocate(mWidth, mHeight,
-                                         HAL_PIXEL_FORMAT_RGBA_8888, 1, GRALLOC_USAGE_HW_TEXTURE,
-                                         &mBuffer, &mStride, 0, "EvsCamera");
-        if (result != NO_ERROR) {
-            ALOGE("Error %d allocating %d x %d graphics buffer", result, mWidth, mHeight);
-            return EvsResult::BUFFER_NOT_AVAILABLE;
-        }
-        if (!mBuffer) {
-            ALOGE("We didn't get a buffer handle back from the allocator");
-            return EvsResult::BUFFER_NOT_AVAILABLE;
-        }
-    }
-
     // Start the frame generation thread
     mStreamState = RUNNING;
-    mCaptureThread = std::thread([this](){GenerateFrames();});
+    mCaptureThread = std::thread([this](){ generateFrames(); });
 
     return EvsResult::OK;
 }
 
-Return<EvsResult> EvsCamera::doneWithFrame(uint32_t /* frameId */, const hidl_handle& bufferHandle)  {
+
+Return<void> EvsCamera::doneWithFrame(const BufferDesc& buffer)  {
     ALOGD("doneWithFrame");
-    std::lock_guard<std::mutex> lock(mAccessLock);
-
-    if (!bufferHandle)
-    {
-        ALOGE("ignoring doneWithFrame called with invalid handle");
-        return EvsResult::INVALID_ARG;
-    }
-
-    // TODO:  Track which frames we've delivered and validate this is one of them
-
-    // Mark the frame buffer as available for a new frame
-    mFrameBusy = false;
-
-    // TODO:  If we currently have too many buffers, drop this one
-
-    return EvsResult::OK;
-}
-
-Return<void> EvsCamera::stopVideoStream()  {
-    ALOGD("stopVideoStream");
-
-    bool waitForJoin = false;
-    // Lock scope
-    {
+    {  // lock context
         std::lock_guard <std::mutex> lock(mAccessLock);
 
-        if (mStreamState == RUNNING) {
-            // Tell the GenerateFrames loop we want it to stop
-            mStreamState = STOPPING;
+        if (buffer.memHandle == nullptr) {
+            ALOGE("ignoring doneWithFrame called with null handle");
+        } else if (buffer.bufferId >= mBuffers.size()) {
+            ALOGE("ignoring doneWithFrame called with invalid bufferId %d (max is %lu)",
+                  buffer.bufferId, mBuffers.size()-1);
+        } else if (!mBuffers[buffer.bufferId].inUse) {
+            ALOGE("ignoring doneWithFrame called on frame %d which is already free",
+                  buffer.bufferId);
+        } else {
+            // Mark the frame as available
+            mBuffers[buffer.bufferId].inUse = false;
+            mFramesInUse--;
 
-            // Note that we asked the thread to stop and should wait for it do so
-            waitForJoin = true;
-        }
-    }
-
-    if (waitForJoin) {
-        // Block outside the mutex until the "stop" flag has been acknowledged
-        // NOTE:  We won't send any more frames, but the client might still get one already in flight
-        ALOGD("Waiting for stream thread to end...");
-        mCaptureThread.join();
-
-        // Lock scope
-        {
-            std::lock_guard <std::mutex> lock(mAccessLock);
-            mStreamState = STOPPED;
+            // If this frame's index is high in the array, try to move it down
+            // to improve locality after mFramesAllowed has been reduced.
+            if (buffer.bufferId >= mFramesAllowed) {
+                // Find an empty slot lower in the array (which should always exist in this case)
+                for (auto&& rec : mBuffers) {
+                    if (rec.handle == nullptr) {
+                        rec.handle = mBuffers[buffer.bufferId].handle;
+                        mBuffers[buffer.bufferId].handle = nullptr;
+                        break;
+                    }
+                }
+            }
         }
     }
 
     return Void();
 }
 
+
+Return<void> EvsCamera::stopVideoStream()  {
+    ALOGD("stopVideoStream");
+    std::unique_lock <std::mutex> lock(mAccessLock);
+
+    if (mStreamState == RUNNING) {
+        // Tell the GenerateFrames loop we want it to stop
+        mStreamState = STOPPING;
+
+        // Block outside the mutex until the "stop" flag has been acknowledged
+        // We won't send any more frames, but the client might still get some already in flight
+        ALOGD("Waiting for stream thread to end...");
+        lock.unlock();
+        mCaptureThread.join();
+        lock.lock();
+
+        mStreamState = STOPPED;
+        ALOGD("Stream marked STOPPED.");
+    }
+
+    return Void();
+}
+
+
 Return<int32_t> EvsCamera::getExtendedInfo(uint32_t opaqueIdentifier)  {
     ALOGD("getExtendedInfo");
     std::lock_guard<std::mutex> lock(mAccessLock);
@@ -215,6 +225,7 @@
     return 0;
 }
 
+
 Return<EvsResult> EvsCamera::setExtendedInfo(uint32_t /*opaqueIdentifier*/, int32_t /*opaqueValue*/)  {
     ALOGD("setExtendedInfo");
     std::lock_guard<std::mutex> lock(mAccessLock);
@@ -224,10 +235,124 @@
 }
 
 
-void EvsCamera::GenerateFrames() {
-    ALOGD("Frame generate loop started");
+bool EvsCamera::setAvailableFrames_Locked(unsigned bufferCount) {
+    if (bufferCount < 1) {
+        ALOGE("Ignoring request to set buffer count to zero");
+        return false;
+    }
+    if (bufferCount > MAX_BUFFERS_IN_FLIGHT) {
+        ALOGE("Rejecting buffer request in excess of internal limit");
+        return false;
+    }
 
-    uint32_t frameNumber;
+    // Is an increase required?
+    if (mFramesAllowed < bufferCount) {
+        // An increase is required
+        unsigned needed = bufferCount - mFramesAllowed;
+        ALOGI("Allocating %d buffers for camera frames", needed);
+
+        unsigned added = increaseAvailableFrames_Locked(needed);
+        if (added != needed) {
+            // If we didn't add all the frames we needed, then roll back to the previous state
+            ALOGE("Rolling back to previous frame queue size");
+            decreaseAvailableFrames_Locked(added);
+            return false;
+        }
+    } else if (mFramesAllowed > bufferCount) {
+        // A decrease is required
+        unsigned framesToRelease = mFramesAllowed - bufferCount;
+        ALOGI("Returning %d camera frame buffers", framesToRelease);
+
+        unsigned released = decreaseAvailableFrames_Locked(framesToRelease);
+        if (released != framesToRelease) {
+            // This shouldn't happen with a properly behaving client because the client
+            // should only make this call after returning sufficient outstanding buffers
+            // to allow a clean resize.
+            ALOGE("Buffer queue shrink failed -- too many buffers currently in use?");
+        }
+    }
+
+    return true;
+}
+
+
+unsigned EvsCamera::increaseAvailableFrames_Locked(unsigned numToAdd) {
+    // Acquire the graphics buffer allocator
+    GraphicBufferAllocator &alloc(GraphicBufferAllocator::get());
+
+    unsigned added = 0;
+
+    while (added < numToAdd) {
+        buffer_handle_t memHandle = nullptr;
+        status_t result = alloc.allocate(mWidth, mHeight,
+                                         mFormat, 1,
+                                         mUsage,
+                                         &memHandle, &mStride, 0, "EvsCamera");
+        if (result != NO_ERROR) {
+            ALOGE("Error %d allocating %d x %d graphics buffer", result, mWidth, mHeight);
+            break;
+        }
+        if (!memHandle) {
+            ALOGE("We didn't get a buffer handle back from the allocator");
+            break;
+        }
+
+        // Find a place to store the new buffer
+        bool stored = false;
+        for (auto&& rec : mBuffers) {
+            if (rec.handle == nullptr) {
+                // Use this existing entry
+                rec.handle = memHandle;
+                rec.inUse = false;
+                stored = true;
+                break;
+            }
+        }
+        if (!stored) {
+            // Add a BufferRecord wrapping this handle to our set of available buffers
+            mBuffers.emplace_back(memHandle);
+        }
+
+        mFramesAllowed++;
+        added++;
+    }
+
+    return added;
+}
+
+
+unsigned EvsCamera::decreaseAvailableFrames_Locked(unsigned numToRemove) {
+    // Acquire the graphics buffer allocator
+    GraphicBufferAllocator &alloc(GraphicBufferAllocator::get());
+
+    unsigned removed = 0;
+
+    for (auto&& rec : mBuffers) {
+        // Is this record not in use, but holding a buffer that we can free?
+        if ((rec.inUse == false) && (rec.handle != nullptr)) {
+            // Release buffer and update the record so we can recognize it as "empty"
+            alloc.free(rec.handle);
+            rec.handle = nullptr;
+
+            mFramesAllowed--;
+            removed++;
+
+            if (removed == numToRemove) {
+                break;
+            }
+        }
+    }
+
+    return removed;
+}
+
+
+// This is the asynchronous frame generation thread that runs in parallel with the
+// main serving thread.  There is one for each active camera instance.
+void EvsCamera::generateFrames() {
+    ALOGD("Frame generation loop started");
+
+    unsigned idx;
 
     while (true) {
         bool timeForFrame = false;
@@ -235,57 +360,69 @@
         {
             std::lock_guard<std::mutex> lock(mAccessLock);
 
-            // Tick the frame counter -- rollover is tolerated
-            frameNumber = mFrameId++;
-
             if (mStreamState != RUNNING) {
                 // Break out of our main thread loop
                 break;
             }
 
-            if (mFrameBusy) {
+            // Are we allowed to issue another buffer?
+            if (mFramesInUse >= mFramesAllowed) {
                 // Can't do anything right now -- skip this frame
-                ALOGW("Skipped a frame because client hasn't returned a buffer\n");
-            }
-            else {
-                // We're going to make the frame busy
-                mFrameBusy = true;
-                timeForFrame = true;
+                ALOGW("Skipped a frame because too many are in flight\n");
+            } else {
+                // Identify an available buffer to fill
+                for (idx = 0; idx < mBuffers.size(); idx++) {
+                    if (!mBuffers[idx].inUse) {
+                        if (mBuffers[idx].handle != nullptr) {
+                            // Found an available record, so stop looking
+                            break;
+                        }
+                    }
+                }
+                if (idx >= mBuffers.size()) {
+                    // This shouldn't happen since we already checked mFramesInUse vs mFramesAllowed
+                    ALOGE("Failed to find an available buffer slot\n");
+                } else {
+                    // We're going to make the frame busy
+                    mBuffers[idx].inUse = true;
+                    mFramesInUse++;
+                    timeForFrame = true;
+                }
             }
         }
 
         if (timeForFrame) {
-            // Lock our output buffer for writing
-            uint32_t *pixels = nullptr;
-            GraphicBufferMapper &mapper = GraphicBufferMapper::get();
-            mapper.lock(mBuffer,
-                        GRALLOC_USAGE_SW_WRITE_OFTEN,
-                        android::Rect(mWidth, mHeight),
-                        (void **) &pixels);
+            // Assemble the buffer description we'll transmit below
+            BufferDesc buff = {};
+            buff.width      = mWidth;
+            buff.height     = mHeight;
+            buff.stride     = mStride;
+            buff.format     = mFormat;
+            buff.usage      = mUsage;
+            buff.bufferId   = idx;
+            buff.memHandle  = mBuffers[idx].handle;
 
-            // If we failed to lock the pixel buffer, we're about to crash, but log it first
-            if (!pixels) {
-                ALOGE("Camera failed to gain access to image buffer for writing");
+            // Write test data into the image buffer
+            fillTestFrame(buff);
+
+            // Issue the (asynchronous) callback to the client -- can't be holding the lock
+            auto result = mStream->deliverFrame(buff);
+            if (result.isOk()) {
+                ALOGD("Delivered %p as id %d", buff.memHandle.getNativeHandle(), buff.bufferId);
+            } else {
+                // This can happen if the client dies and is likely unrecoverable.
+                // To avoid consuming resources generating failing calls, we stop sending
+                // frames.  Note, however, that the stream remains in the "STREAMING" state
+                // until cleaned up on the main thread.
+                ALOGE("Frame delivery call failed in the transport layer.");
+
+                // Since we didn't actually deliver it, mark the frame as available
+                std::lock_guard<std::mutex> lock(mAccessLock);
+                mBuffers[idx].inUse = false;
+                mFramesInUse--;
+
+                break;
             }
-
-            // Fill in the test pixels
-            for (unsigned row = 0; row < mHeight; row++) {
-                for (unsigned col = 0; col < mWidth; col++) {
-                    // Index into the row to set the pixel at this column
-                    // (We're making vertical gradient in the green channel, and
-                    // horitzontal gradient in the blue channel)
-                    pixels[col] = 0xFF0000FF | ((row & 0xFF) << 16) | ((col & 0xFF) << 8);
-                }
-                // Point to the next row
-                pixels = pixels + (mStride / sizeof(*pixels));
-            }
-
-            // Release our output buffer
-            mapper.unlock(mBuffer);
-
-            // Issue the (asynchronous) callback to the client
-            mStream->deliverFrame(frameNumber, mBuffer);
-            ALOGD("Delivered %p as frame %d", mBuffer, frameNumber);
         }
 
         // We arbitrarily choose to generate frames at 10 fps (1/10 * uSecPerSec)
@@ -293,11 +430,58 @@
     }
 
     // If we've been asked to stop, send one last NULL frame to signal the actual end of stream
-    mStream->deliverFrame(frameNumber, nullptr);
+    BufferDesc nullBuff = {};
+    auto result = mStream->deliverFrame(nullBuff);
+    if (!result.isOk()) {
+        ALOGE("Error delivering end of stream marker");
+    }
 
     return;
 }
 
+
+void EvsCamera::fillTestFrame(BufferDesc buff) {
+    // Lock our output buffer for writing
+    uint32_t *pixels = nullptr;
+    GraphicBufferMapper &mapper = GraphicBufferMapper::get();
+    mapper.lock(buff.memHandle,
+                GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_NEVER,
+                android::Rect(buff.width, buff.height),
+                (void **) &pixels);
+
+    // If we failed to lock the pixel buffer, we're about to crash, but log it first
+    if (!pixels) {
+        ALOGE("Camera failed to gain access to image buffer for writing");
+    }
+
+    // Fill in the test pixels
+    for (unsigned row = 0; row < buff.height; row++) {
+        for (unsigned col = 0; col < buff.width; col++) {
+            // Index into the row to check the pixel at this column.
+            // We expect 0xFF in the LSB channel, a vertical gradient in the
+            // second channel, a horitzontal gradient in the third channel, and
+            // 0xFF in the MSB.
+            // The exception is the very first 32 bits which is used for the
+            // time varying frame signature to avoid getting fooled by a static image.
+            uint32_t expectedPixel = 0xFF0000FF           | // MSB and LSB
+                                     ((row & 0xFF) <<  8) | // vertical gradient
+                                     ((col & 0xFF) << 16);  // horizontal gradient
+            if ((row | col) == 0) {
+                static uint32_t sFrameTicker = 0;
+                expectedPixel = (sFrameTicker) & 0xFF;
+                sFrameTicker++;
+            }
+            pixels[col] = expectedPixel;
+        }
+        // Point to the next row
+        pixels = pixels + (buff.stride / sizeof(*pixels));
+    }
+
+    // Release our output buffer
+    mapper.unlock(buff.memHandle);
+}
+
+
 } // namespace implementation
 } // namespace V1_0
 } // namespace evs
diff --git a/evs/1.0/default/EvsCamera.h b/evs/1.0/default/EvsCamera.h
index 5d29125..8d644a0 100644
--- a/evs/1.0/default/EvsCamera.h
+++ b/evs/1.0/default/EvsCamera.h
@@ -23,19 +23,21 @@
 
 #include <thread>
 
+
 namespace android {
 namespace hardware {
 namespace evs {
 namespace V1_0 {
 namespace implementation {
 
+
 class EvsCamera : public IEvsCamera {
 public:
     // Methods from ::android::hardware::evs::V1_0::IEvsCamera follow.
     Return<void> getId(getId_cb id_cb)  override;
     Return<EvsResult> setMaxFramesInFlight(uint32_t bufferCount)  override;
     Return<EvsResult> startVideoStream(const ::android::sp<IEvsCameraStream>& stream) override;
-    Return<EvsResult> doneWithFrame(uint32_t frameId, const hidl_handle& bufferHandle)  override;
+    Return<void> doneWithFrame(const BufferDesc& buffer)  override;
     Return<void> stopVideoStream()  override;
     Return<int32_t> getExtendedInfo(uint32_t opaqueIdentifier)  override;
     Return<EvsResult> setExtendedInfo(uint32_t opaqueIdentifier, int32_t opaqueValue)  override;
@@ -45,34 +47,49 @@
     virtual ~EvsCamera() override;
 
     const CameraDesc& getDesc() { return mDescription; };
-    void GenerateFrames();
 
     static const char kCameraName_Backup[];
     static const char kCameraName_RightTurn[];
 
 private:
-    CameraDesc              mDescription = {};  // The properties of this camera
+    // These three functions are expected to be called while mAccessLock is held
+    bool     setAvailableFrames_Locked(unsigned bufferCount);
+    unsigned increaseAvailableFrames_Locked(unsigned numToAdd);
+    unsigned decreaseAvailableFrames_Locked(unsigned numToRemove);
 
-    buffer_handle_t         mBuffer = nullptr;  // A graphics buffer into which we'll store images
-    uint32_t                mWidth  = 0;        // number of pixels across the buffer
-    uint32_t                mHeight = 0;        // number of pixels vertically in the buffer
-    uint32_t                mStride = 0;        // Bytes per line in the buffer
+    void generateFrames();
+    void fillTestFrame(BufferDesc buff);
 
-    sp<IEvsCameraStream>    mStream = nullptr;  // The callback the user expects when a frame is ready
+    CameraDesc                  mDescription = {};  // The properties of this camera
 
-    std::thread             mCaptureThread;     // The thread we'll use to synthesize frames
+    std::thread                 mCaptureThread;     // The thread we'll use to synthesize frames
 
-    uint32_t                mFrameId;           // A frame counter used to identify specific frames
+    uint32_t                    mWidth  = 0;        // Horizontal pixel count in the buffers
+    uint32_t                    mHeight = 0;        // Vertical pixel count in the buffers
+    uint32_t                    mFormat = 0;        // Values from android_pixel_format_t [TODO: YUV?  Leave opaque?]
+    uint32_t                    mUsage  = 0;        // Values from from Gralloc.h
+    uint32_t                    mStride = 0;        // Bytes per line in the buffers
+
+    sp<IEvsCameraStream>        mStream = nullptr;  // The callback used to deliver each frame
+
+    struct BufferRecord {
+        buffer_handle_t     handle;
+        bool                inUse;
+        explicit BufferRecord(buffer_handle_t h) : handle(h), inUse(false) {};
+    };
+    std::vector<BufferRecord>   mBuffers;           // Graphics buffers to transfer images
+    unsigned                    mFramesAllowed;     // How many buffers are we currently using
+    unsigned                    mFramesInUse;       // How many buffers are currently outstanding
 
     enum StreamStateValues {
         STOPPED,
         RUNNING,
         STOPPING,
     };
-    StreamStateValues       mStreamState;
-    bool                    mFrameBusy;         // A flag telling us our one buffer is in use
+    StreamStateValues           mStreamState;
 
-    std::mutex              mAccessLock;
+    // Syncrhonization necessary to deconflict mCaptureThread from the main service thread
+    std::mutex                  mAccessLock;
 };
 
 } // namespace implementation
diff --git a/evs/1.0/default/EvsDisplay.cpp b/evs/1.0/default/EvsDisplay.cpp
index 9dba6fc..dff4c49 100644
--- a/evs/1.0/default/EvsDisplay.cpp
+++ b/evs/1.0/default/EvsDisplay.cpp
@@ -39,6 +39,7 @@
     ALOGD("EvsDisplay instantiated");
 
     // Set up our self description
+    // NOTE:  These are arbitrary values chosen for testing
     mInfo.displayId             = "Mock Display";
     mInfo.vendorFlags           = 3870;
     mInfo.defaultHorResolution  = 320;
@@ -50,16 +51,17 @@
     ALOGD("EvsDisplay being destroyed");
     std::lock_guard<std::mutex> lock(mAccessLock);
 
-    // Report if we're going away while a buffer is outstanding.  This could be bad.
+    // Report if we're going away while a buffer is outstanding
     if (mFrameBusy) {
-        ALOGE("EvsDisplay going down while client is holding a buffer\n");
+        ALOGE("EvsDisplay going down while client is holding a buffer");
     }
 
     // Make sure we release our frame buffer
-    if (mBuffer) {
+    if (mBuffer.memHandle) {
         // Drop the graphics buffer we've been using
         GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
-        alloc.free(mBuffer);
+        alloc.free(mBuffer.memHandle);
+        mBuffer.memHandle = nullptr;
     }
     ALOGD("EvsDisplay destroyed");
 }
@@ -135,36 +137,60 @@
     std::lock_guard<std::mutex> lock(mAccessLock);
 
     // If we don't already have a buffer, allocate one now
-    if (!mBuffer) {
+    if (!mBuffer.memHandle) {
+        // Assemble the buffer description we'll use for our render target
+        mBuffer.width       = mInfo.defaultHorResolution;
+        mBuffer.height      = mInfo.defaultVerResolution;
+        mBuffer.format      = HAL_PIXEL_FORMAT_RGBA_8888;
+        mBuffer.usage       = GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_COMPOSER;
+        mBuffer.bufferId    = 0x3870;  // Arbitrary magic number for self recognition
+
+        buffer_handle_t handle = nullptr;
         GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
-        status_t result = alloc.allocate(mInfo.defaultHorResolution, mInfo.defaultVerResolution,
-                                         HAL_PIXEL_FORMAT_RGBA_8888, 1,
-                                         GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_HW_COMPOSER,
-                                         &mBuffer, &mStride, 0, "EvsDisplay");
+        status_t result = alloc.allocate(mBuffer.width, mBuffer.height,
+                                         mBuffer.format, 1, mBuffer.usage,
+                                         &handle, &mBuffer.stride,
+                                         0, "EvsDisplay");
+        if (result != NO_ERROR) {
+            ALOGE("Error %d allocating %d x %d graphics buffer",
+                  result, mBuffer.width, mBuffer.height);
+            BufferDesc nullBuff = {};
+            _hidl_cb(nullBuff);
+            return Void();
+        }
+        if (!handle) {
+            ALOGE("We didn't get a buffer handle back from the allocator");
+            BufferDesc nullBuff = {};
+            _hidl_cb(nullBuff);
+            return Void();
+        }
+
+        mBuffer.memHandle = handle;
         mFrameBusy = false;
-        ALOGD("Allocated new buffer %p with stride %u", mBuffer, mStride);
+        ALOGD("Allocated new buffer %p with stride %u",
+              mBuffer.memHandle.getNativeHandle(), mStride);
     }
 
     // Do we have a frame available?
     if (mFrameBusy) {
         // This means either we have a 2nd client trying to compete for buffers
         // (an unsupported mode of operation) or else the client hasn't returned
-        // a previously issues buffer yet (they're behaving badly).
-        // NOTE:  We have to make callback even if we have nothing to provide
+        // a previously issued buffer yet (they're behaving badly).
+        // NOTE:  We have to make the callback even if we have nothing to provide
         ALOGE("getTargetBuffer called while no buffers available.");
-        _hidl_cb(nullptr);
-    }
-    else {
+        BufferDesc nullBuff = {};
+        _hidl_cb(nullBuff);
+        return Void();
+    } else {
         // Mark our buffer as busy
         mFrameBusy = true;
 
         // Send the buffer to the client
-        ALOGD("Providing display buffer %p", mBuffer);
+        ALOGD("Providing display buffer handle %p as id %d",
+              mBuffer.memHandle.getNativeHandle(), mBuffer.bufferId);
         _hidl_cb(mBuffer);
+        return Void();
     }
-
-    // All done
-    return Void();
 }
 
 
@@ -172,22 +198,19 @@
  * This call tells the display that the buffer is ready for display.
  * The buffer is no longer valid for use by the client after this call.
  */
-Return<EvsResult> EvsDisplay::returnTargetBufferForDisplay(const hidl_handle& bufferHandle)  {
-    ALOGD("returnTargetBufferForDisplay %p", bufferHandle.getNativeHandle());
+Return<EvsResult> EvsDisplay::returnTargetBufferForDisplay(const BufferDesc& buffer)  {
+    ALOGD("returnTargetBufferForDisplay %p", buffer.memHandle.getNativeHandle());
     std::lock_guard<std::mutex> lock(mAccessLock);
 
-    // This shouldn't happen if we haven't issued the buffer!
-    if (!bufferHandle) {
+    // Nobody should call us with a null handle
+    if (!buffer.memHandle.getNativeHandle()) {
         ALOGE ("returnTargetBufferForDisplay called without a valid buffer handle.\n");
         return EvsResult::INVALID_ARG;
     }
-    /* TODO(b/33492405): It would be nice to validate we got back the buffer we expect,
-     * but HIDL doesn't support that (yet?)
-    if (bufferHandle != mBuffer) {
+    if (buffer.bufferId != mBuffer.bufferId) {
         ALOGE ("Got an unrecognized frame returned.\n");
         return EvsResult::INVALID_ARG;
     }
-    */
     if (!mFrameBusy) {
         ALOGE ("A frame was returned with no outstanding frames.\n");
         return EvsResult::BUFFER_NOT_AVAILABLE;
@@ -204,10 +227,71 @@
     if (mRequestedState != DisplayState::VISIBLE) {
         // We shouldn't get frames back when we're not visible.
         ALOGE ("Got an unexpected frame returned while not visible - ignoring.\n");
-    }
-    else {
-        // Make this buffer visible
-        // TODO:  Add code to put this image on the screen (or validate it somehow?)
+    } else {
+        // This is where the buffer would be made visible.
+        // For now we simply validate it has the data we expect in it by reading it back
+
+        // Lock our display buffer for reading
+        uint32_t* pixels = nullptr;
+        GraphicBufferMapper &mapper = GraphicBufferMapper::get();
+        mapper.lock(mBuffer.memHandle,
+                    GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_NEVER,
+                    android::Rect(mBuffer.width, mBuffer.height),
+                    (void **)&pixels);
+
+        // If we failed to lock the pixel buffer, we're about to crash, but log it first
+        if (!pixels) {
+            ALOGE("Camera failed to gain access to image buffer for reading");
+        }
+
+        // Check the test pixels
+        bool frameLooksGood = true;
+        for (unsigned row = 0; row < mInfo.defaultVerResolution; row++) {
+            for (unsigned col = 0; col < mInfo.defaultHorResolution; col++) {
+                // Index into the row to check the pixel at this column.
+                // We expect 0xFF in the LSB channel, a vertical gradient in the
+                // second channel, a horitzontal gradient in the third channel, and
+                // 0xFF in the MSB.
+                // The exception is the very first 32 bits which is used for the
+                // time varying frame signature to avoid getting fooled by a static image.
+                uint32_t expectedPixel = 0xFF0000FF           | // MSB and LSB
+                                         ((row & 0xFF) <<  8) | // vertical gradient
+                                         ((col & 0xFF) << 16);  // horizontal gradient
+                if ((row | col) == 0) {
+                    // we'll check the "uniqueness" of the frame signature below
+                    continue;
+                }
+                // Walk across this row (we'll step rows below)
+                if (pixels[col] != expectedPixel) {
+                    ALOGE("Pixel check mismatch in frame buffer");
+                    frameLooksGood = false;
+                    break;
+                }
+            }
+
+            if (!frameLooksGood) {
+                break;
+            }
+
+            // Point to the next row
+            pixels = pixels + (mStride / sizeof(*pixels));
+        }
+
+        // Ensure we don't see the same buffer twice without it being rewritten
+        static uint32_t prevSignature = ~0;
+        uint32_t signature = pixels[0] & 0xFF;
+        if (prevSignature == signature) {
+            frameLooksGood = false;
+            ALOGE("Duplicate, likely stale frame buffer detected");
+        }
+
+
+        // Release our output buffer
+        mapper.unlock(mBuffer.memHandle);
+
+        if (!frameLooksGood) {
+            return EvsResult::UNDERLYING_SERVICE_ERROR;
+        }
     }
 
     return EvsResult::OK;
diff --git a/evs/1.0/default/EvsDisplay.h b/evs/1.0/default/EvsDisplay.h
index a2d5d3e..6e0111e 100644
--- a/evs/1.0/default/EvsDisplay.h
+++ b/evs/1.0/default/EvsDisplay.h
@@ -33,7 +33,7 @@
     Return<EvsResult> setDisplayState(DisplayState state)  override;
     Return<DisplayState> getDisplayState()  override;
     Return<void> getTargetBuffer(getTargetBuffer_cb _hidl_cb)  override;
-    Return<EvsResult> returnTargetBufferForDisplay(const hidl_handle& bufferHandle)  override;
+    Return<EvsResult> returnTargetBufferForDisplay(const BufferDesc& buffer)  override;
 
     // Implementation details
     EvsDisplay();
@@ -41,10 +41,10 @@
 
 private:
     DisplayDesc     mInfo           = {};
-    buffer_handle_t mBuffer         = nullptr;      // A graphics buffer into which we'll store images
-    uint32_t        mStride         = 0;            // Bytes per line in the buffer
+    BufferDesc      mBuffer         = {};       // A graphics buffer into which we'll store images
+    uint32_t        mStride         = 0;        // Bytes per line in the buffer
 
-    bool            mFrameBusy      = false;        // A flag telling us our buffer is in use
+    bool            mFrameBusy      = false;    // A flag telling us our buffer is in use
     DisplayState    mRequestedState = DisplayState::NOT_VISIBLE;
 
     std::mutex      mAccessLock;
diff --git a/evs/1.0/default/EvsEnumerator.cpp b/evs/1.0/default/EvsEnumerator.cpp
index ba8da00..4bf77f3 100644
--- a/evs/1.0/default/EvsEnumerator.cpp
+++ b/evs/1.0/default/EvsEnumerator.cpp
@@ -27,6 +27,11 @@
 namespace implementation {
 
 
+// TODO(b/31632518):  Need to get notification when our client dies so we can close the camera.
+// As it stands, if the client dies suddenly, the camera will be stuck "open".
+// NOTE:  Display should already be safe by virtue of holding only a weak pointer.
+
+
 EvsEnumerator::EvsEnumerator() {
     ALOGD("EvsEnumerator created");
 
@@ -78,15 +83,11 @@
     if (!pRecord) {
         ALOGE("Requested camera %s not found", cameraId.c_str());
         return nullptr;
-    }
-    else if (pRecord->inUse) {
+    } else if (pRecord->inUse) {
         ALOGE("Cannot open camera %s which is already in use", cameraId.c_str());
         return nullptr;
-    }
-    else {
-        /* TODO(b/33492405):  Do this, When HIDL can give us back a recognizable pointer
+    } else {
         pRecord->inUse = true;
-         */
         return(pRecord->pCamera);
     }
 }
@@ -96,14 +97,21 @@
 
     if (camera == nullptr) {
         ALOGE("Ignoring call to closeCamera with null camera pointer");
-    }
-    else {
-        // Make sure the camera has stopped streaming
-        camera->stopVideoStream();
+    } else {
+        // Find this camera in our list
+        auto it = std::find_if(mCameraList.begin(),
+                               mCameraList.end(),
+                               [camera](const CameraRecord& rec) {
+                                   return (rec.pCamera == camera);
+                               });
+        if (it == mCameraList.end()) {
+            ALOGE("Ignoring close on unrecognized camera");
+        } else {
+            // Make sure the camera has stopped streaming
+            camera->stopVideoStream();
 
-        /* TODO(b/33492405):  Do this, When HIDL can give us back a recognizable pointer
-        pRecord->inUse = false;
-         */
+            it->inUse = false;
+        }
     }
 
     return Void();
@@ -113,41 +121,49 @@
     ALOGD("openDisplay");
 
     // If we already have a display active, then this request must be denied
-    if (mActiveDisplay != nullptr) {
+    sp<IEvsDisplay> pActiveDisplay = mActiveDisplay.promote();
+    if (pActiveDisplay != nullptr) {
         ALOGW("Rejecting openDisplay request the display is already in use.");
         return nullptr;
-    }
-    else {
+    } else {
         // Create a new display interface and return it
-        mActiveDisplay = new EvsDisplay();
-        ALOGD("Returning new EvsDisplay object %p", mActiveDisplay.get());
-        return mActiveDisplay;
+        pActiveDisplay = new EvsDisplay();
+        mActiveDisplay = pActiveDisplay;
+        ALOGD("Returning new EvsDisplay object %p", pActiveDisplay.get());
+        return pActiveDisplay;
     }
 }
 
 Return<void> EvsEnumerator::closeDisplay(const ::android::sp<IEvsDisplay>& display) {
     ALOGD("closeDisplay");
 
-    if (mActiveDisplay == nullptr) {
-        ALOGE("Ignoring closeDisplay when display is not active");
-    }
-    else if (display == nullptr) {
-        ALOGE("Ignoring closeDisplay with null display pointer");
-    }
-    else {
+    // Do we still have a display object we think should be active?
+    sp<IEvsDisplay> pActiveDisplay = mActiveDisplay.promote();
+
+    if (pActiveDisplay == nullptr) {
+        ALOGE("Ignoring closeDisplay when there is no active display.");
+    } else if (display != pActiveDisplay) {
+        ALOGE("Ignoring closeDisplay on a display we didn't issue");
+        ALOGI("Got %p while active display is %p.", display.get(), pActiveDisplay.get());
+    } else {
         // Drop the active display
-        // TODO(b/33492405):  When HIDL provides recognizable pointers, add validation here.
         mActiveDisplay = nullptr;
     }
 
     return Void();
 }
 
+Return<DisplayState> EvsEnumerator::getDisplayState()  {
+    ALOGD("getDisplayState");
 
-// TODO(b/31632518):  Need to get notification when our client dies so we can close the camera.
-// As possible work around would be to give the client a HIDL object to exclusively hold
-// and use it's destructor to perform some work in the server side.
-
+    // Do we still have a display object we think should be active?
+    sp<IEvsDisplay> pActiveDisplay = mActiveDisplay.promote();
+    if (pActiveDisplay != nullptr) {
+        return pActiveDisplay->getDisplayState();
+    } else {
+        return DisplayState::NOT_OPEN;
+    }
+}
 
 } // namespace implementation
 } // namespace V1_0
diff --git a/evs/1.0/default/EvsEnumerator.h b/evs/1.0/default/EvsEnumerator.h
index 90df837..0e719bd 100644
--- a/evs/1.0/default/EvsEnumerator.h
+++ b/evs/1.0/default/EvsEnumerator.h
@@ -38,6 +38,7 @@
     Return<void> closeCamera(const ::android::sp<IEvsCamera>& carCamera)  override;
     Return<sp<IEvsDisplay>> openDisplay()  override;
     Return<void> closeDisplay(const ::android::sp<IEvsDisplay>& display)  override;
+    Return<DisplayState> getDisplayState()  override;
 
     // Implementation details
     EvsEnumerator();
@@ -50,7 +51,7 @@
     };
     std::list<CameraRecord> mCameraList;
 
-    sp<IEvsDisplay>         mActiveDisplay;
+    wp<IEvsDisplay>         mActiveDisplay; // Weak pointer -> object destructs if client dies
 };
 
 } // namespace implementation
diff --git a/evs/1.0/types.hal b/evs/1.0/types.hal
index fd9dcdc..6b580cf 100644
--- a/evs/1.0/types.hal
+++ b/evs/1.0/types.hal
@@ -72,6 +72,29 @@
 
 
 /*
+ * Structure representing an image buffer through our APIs
+ *
+ * In addition to the handle to the graphics memory, we need to retain
+ * the properties of the buffer for easy reference and reconstruction of
+ * an ANativeWindowBuffer object on the remote side of API calls.
+ * (Not least because OpenGL expect an ANativeWindowBuffer* for us as a
+ * texture via eglCreateImageKHR().
+ * See also related types from android.hardware.graphics.common
+ * TODO:  b/34722508  Review details of interaction of this structure with gralloc and OpenGL.
+ *        Specifically consider if format and/or usage should become enumerated types.
+ */
+struct BufferDesc {
+    uint32_t    width;      // Units of pixels
+    uint32_t    height;     // Units of pixels
+    uint32_t    stride;     // Units of bytes
+    uint32_t    format;     // May contain values from android_pixel_format_t
+    uint32_t    usage;      // May contain values from from Gralloc.h
+    uint32_t    bufferId;   // Opaque value from driver
+    handle      memHandle;  // gralloc memory buffer handle
+};
+
+
+/*
  * States for control of the EVS display
  *
  * The DisplayInfo structure describes the basic properties of an EVS display. Any EVS
@@ -81,7 +104,8 @@
  * presentation device.
  */
 enum DisplayState : uint32_t {
-    NOT_VISIBLE = 0,        // Display is inhibited
+    NOT_OPEN = 0,           // Display has not been requested by any application
+    NOT_VISIBLE,            // Display is inhibited
     VISIBLE_ON_NEXT_FRAME,  // Will become visible with next frame
     VISIBLE,                // Display is currently active
     NUM_STATES              // Must be last
@@ -94,4 +118,5 @@
     INVALID_ARG,
     STREAM_ALREADY_RUNNING,
     BUFFER_NOT_AVAILABLE,
+    UNDERLYING_SERVICE_ERROR,
 };
\ No newline at end of file
diff --git a/gatekeeper/1.0/vts/Android.mk b/gatekeeper/1.0/vts/Android.mk
new file mode 100644
index 0000000..58c2dca
--- /dev/null
+++ b/gatekeeper/1.0/vts/Android.mk
@@ -0,0 +1,19 @@
+#
+# Copyright (C) 2016 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.
+
+
+LOCAL_PATH := $(call my-dir)
+
+include $(LOCAL_PATH)/functional/vts/testcases/hal/gatekeeper/hidl/Android.mk
diff --git a/gatekeeper/1.0/vts/functional/gatekeeper_hidl_hal_test.cpp b/gatekeeper/1.0/vts/functional/gatekeeper_hidl_hal_test.cpp
index 09690f8..67b4482 100644
--- a/gatekeeper/1.0/vts/functional/gatekeeper_hidl_hal_test.cpp
+++ b/gatekeeper/1.0/vts/functional/gatekeeper_hidl_hal_test.cpp
@@ -187,7 +187,7 @@
   GatekeeperHidlTest() : uid_(0) {}
   virtual void SetUp() override {
     GatekeeperResponse rsp;
-    gatekeeper_ = IGatekeeper::getService("gatekeeper", false);
+    gatekeeper_ = IGatekeeper::getService("gatekeeper");
     ASSERT_NE(nullptr, gatekeeper_.get());
     doDeleteAllUsers(rsp);
   }
diff --git a/gatekeeper/1.0/vts/functional/vts/testcases/hal/gatekeeper/hidl/Android.mk b/gatekeeper/1.0/vts/functional/vts/testcases/hal/gatekeeper/hidl/Android.mk
new file mode 100644
index 0000000..f9e3276
--- /dev/null
+++ b/gatekeeper/1.0/vts/functional/vts/testcases/hal/gatekeeper/hidl/Android.mk
@@ -0,0 +1,19 @@
+#
+# Copyright (C) 2016 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(call all-subdir-makefiles)
diff --git a/graphics/common/1.0/types.hal b/graphics/common/1.0/types.hal
index 6fddfaf..7663701 100644
--- a/graphics/common/1.0/types.hal
+++ b/graphics/common/1.0/types.hal
@@ -38,6 +38,16 @@
     BGRA_8888          = 5,
 
     /*
+     * The following formats use 10bit integers for R, G, and B and
+     * 2 bits for alpha. This is used to improve color precision on
+     * wide-color devices, e.g. Display-P3 or scRGB.
+     *
+     * When used with ANativeWindow, the dataSpace field describes the color
+     * space of the buffer.
+     */
+    RGBA_1010102       = 0x2B,
+
+    /*
      * The following formats use a 16bit float per color component.
      *
      * When used with ANativeWindow, the dataSpace field describes the color
@@ -322,6 +332,7 @@
      * -------------------------------+-----------------------------------------
      *  HAL_DATASPACE_JFIF            | An encoded JPEG image
      *  HAL_DATASPACE_DEPTH           | An android_depth_points buffer
+     *  HAL_DATASPACE_SENSOR          | Sensor event data.
      *  Other                         | Unsupported
      *
      */
@@ -1080,7 +1091,17 @@
      *       The point cloud will be represented with the android_depth_points
      *       structure.
      */
-    DEPTH = 0x1000
+    DEPTH = 0x1000,
+
+
+    /*
+     * The buffer contains sensor events from sensor direct report.
+     * This value is valid with formats:
+     *    HAL_PIXEL_FORMAT_BLOB: an array of sensor event structure that forms
+     *       a lock free queue. Format of sensor event structure is specified
+     *       in Sensors HAL.
+     */
+    SENSOR = 0x1001
 };
 
 /*
diff --git a/graphics/composer/2.1/default/Android.bp b/graphics/composer/2.1/default/Android.bp
index 0d63c3c..a366fa2 100644
--- a/graphics/composer/2.1/default/Android.bp
+++ b/graphics/composer/2.1/default/Android.bp
@@ -1,7 +1,28 @@
+cc_library_static {
+    name: "libhwcomposer-client",
+    export_include_dirs: ["."],
+    srcs: ["ComposerClient.cpp"],
+    cppflags: ["-DBINDERIZED"],
+    shared_libs: [
+        "android.hardware.graphics.allocator@2.0",
+        "android.hardware.graphics.composer@2.1",
+        "libbase",
+        "libcutils",
+        "libfmq",
+        "libhardware",
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libsync",
+        "libutils",
+    ],
+}
+
 cc_library_shared {
     name: "android.hardware.graphics.composer@2.1-impl",
     relative_install_path: "hw",
-    srcs: ["Hwc.cpp", "HwcClient.cpp"],
+    srcs: ["Hwc.cpp", "ComposerClient.cpp"],
     shared_libs: [
         "android.hardware.graphics.allocator@2.0",
         "android.hardware.graphics.composer@2.1",
@@ -21,10 +42,13 @@
 cc_binary {
     name: "android.hardware.graphics.composer@2.1-service",
     relative_install_path: "hw",
-    srcs: ["service.cpp", "Hwc.cpp", "HwcClient.cpp"],
+    srcs: ["service.cpp", "Hwc.cpp"],
     cppflags: ["-DBINDERIZED"],
     init_rc: ["android.hardware.graphics.composer@2.1-service.rc"],
 
+    static_libs: [
+        "libhwcomposer-client",
+    ],
     shared_libs: [
         "android.hardware.graphics.allocator@2.0",
         "android.hardware.graphics.composer@2.1",
diff --git a/graphics/composer/2.1/default/ComposerBase.h b/graphics/composer/2.1/default/ComposerBase.h
new file mode 100644
index 0000000..85b1a4d
--- /dev/null
+++ b/graphics/composer/2.1/default/ComposerBase.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2017 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.
+ */
+
+#ifndef ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_BASE_H
+#define ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_BASE_H
+
+#include <android/hardware/graphics/composer/2.1/IComposer.h>
+#include <hardware/hwcomposer2.h>
+
+namespace android {
+namespace hardware {
+namespace graphics {
+namespace composer {
+namespace V2_1 {
+namespace implementation {
+
+using android::hardware::graphics::common::V1_0::PixelFormat;
+using android::hardware::graphics::common::V1_0::Transform;
+using android::hardware::graphics::common::V1_0::Dataspace;
+using android::hardware::graphics::common::V1_0::ColorMode;
+using android::hardware::graphics::common::V1_0::ColorTransform;
+using android::hardware::graphics::common::V1_0::Hdr;
+
+class ComposerBase {
+public:
+    virtual ~ComposerBase() {};
+
+    virtual void removeClient() = 0;
+    virtual void enableCallback(bool enable) = 0;
+    virtual uint32_t getMaxVirtualDisplayCount() = 0;
+    virtual Error createVirtualDisplay(uint32_t width, uint32_t height,
+        PixelFormat* format, Display* outDisplay) = 0;
+    virtual Error destroyVirtualDisplay(Display display) = 0;
+    virtual Error createLayer(Display display, Layer* outLayer) = 0;
+    virtual Error destroyLayer(Display display, Layer layer) = 0;
+
+    virtual Error getActiveConfig(Display display, Config* outConfig) = 0;
+    virtual Error getClientTargetSupport(Display display,
+            uint32_t width, uint32_t height,
+            PixelFormat format, Dataspace dataspace) = 0;
+    virtual Error getColorModes(Display display,
+            hidl_vec<ColorMode>* outModes) = 0;
+    virtual Error getDisplayAttribute(Display display, Config config,
+            IComposerClient::Attribute attribute, int32_t* outValue) = 0;
+    virtual Error getDisplayConfigs(Display display,
+            hidl_vec<Config>* outConfigs) = 0;
+    virtual Error getDisplayName(Display display, hidl_string* outName) = 0;
+    virtual Error getDisplayType(Display display,
+            IComposerClient::DisplayType* outType) = 0;
+    virtual Error getDozeSupport(Display display, bool* outSupport) = 0;
+    virtual Error getHdrCapabilities(Display display, hidl_vec<Hdr>* outTypes,
+            float* outMaxLuminance, float* outMaxAverageLuminance,
+            float* outMinLuminance) = 0;
+
+    virtual Error setActiveConfig(Display display, Config config) = 0;
+    virtual Error setColorMode(Display display, ColorMode mode) = 0;
+    virtual Error setPowerMode(Display display,
+            IComposerClient::PowerMode mode) = 0;
+    virtual Error setVsyncEnabled(Display display,
+            IComposerClient::Vsync enabled) = 0;
+
+    virtual Error setColorTransform(Display display, const float* matrix,
+            int32_t hint) = 0;
+    virtual Error setClientTarget(Display display, buffer_handle_t target,
+            int32_t acquireFence, int32_t dataspace,
+            const std::vector<hwc_rect_t>& damage) = 0;
+    virtual Error setOutputBuffer(Display display, buffer_handle_t buffer,
+            int32_t releaseFence) = 0;
+    virtual Error validateDisplay(Display display,
+            std::vector<Layer>* outChangedLayers,
+            std::vector<IComposerClient::Composition>* outCompositionTypes,
+            uint32_t* outDisplayRequestMask,
+            std::vector<Layer>* outRequestedLayers,
+            std::vector<uint32_t>* outRequestMasks) = 0;
+    virtual Error acceptDisplayChanges(Display display) = 0;
+    virtual Error presentDisplay(Display display, int32_t* outPresentFence,
+            std::vector<Layer>* outLayers,
+            std::vector<int32_t>* outReleaseFences) = 0;
+
+    virtual Error setLayerCursorPosition(Display display, Layer layer,
+            int32_t x, int32_t y) = 0;
+    virtual Error setLayerBuffer(Display display, Layer layer,
+            buffer_handle_t buffer, int32_t acquireFence) = 0;
+    virtual Error setLayerSurfaceDamage(Display display, Layer layer,
+            const std::vector<hwc_rect_t>& damage) = 0;
+    virtual Error setLayerBlendMode(Display display, Layer layer,
+            int32_t mode) = 0;
+    virtual Error setLayerColor(Display display, Layer layer,
+            IComposerClient::Color color) = 0;
+    virtual Error setLayerCompositionType(Display display, Layer layer,
+            int32_t type) = 0;
+    virtual Error setLayerDataspace(Display display, Layer layer,
+            int32_t dataspace) = 0;
+    virtual Error setLayerDisplayFrame(Display display, Layer layer,
+            const hwc_rect_t& frame) = 0;
+    virtual Error setLayerPlaneAlpha(Display display, Layer layer,
+            float alpha) = 0;
+    virtual Error setLayerSidebandStream(Display display, Layer layer,
+            buffer_handle_t stream) = 0;
+    virtual Error setLayerSourceCrop(Display display, Layer layer,
+            const hwc_frect_t& crop) = 0;
+    virtual Error setLayerTransform(Display display, Layer layer,
+            int32_t transform) = 0;
+    virtual Error setLayerVisibleRegion(Display display, Layer layer,
+            const std::vector<hwc_rect_t>& visible) = 0;
+    virtual Error setLayerZOrder(Display display, Layer layer,
+            uint32_t z) = 0;
+};
+
+}  // namespace implementation
+}  // namespace V2_1
+}  // namespace composer
+}  // namespace graphics
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_BASE_H
diff --git a/graphics/composer/2.1/default/HwcClient.cpp b/graphics/composer/2.1/default/ComposerClient.cpp
similarity index 76%
rename from graphics/composer/2.1/default/HwcClient.cpp
rename to graphics/composer/2.1/default/ComposerClient.cpp
index edd161a..49415ee 100644
--- a/graphics/composer/2.1/default/HwcClient.cpp
+++ b/graphics/composer/2.1/default/ComposerClient.cpp
@@ -20,8 +20,8 @@
 #include <hardware/gralloc1.h>
 #include <log/log.h>
 
+#include "ComposerClient.h"
 #include "Hwc.h"
-#include "HwcClient.h"
 #include "IComposerCommandBuffer.h"
 
 namespace android {
@@ -230,15 +230,12 @@
     }
 }
 
-HwcClient::HwcClient(HwcHal& hal)
-    : mHal(hal), mReader(*this), mWriter(kWriterInitialSize)
+ComposerClient::ComposerClient(ComposerBase& hal)
+    : mHal(hal), mWriter(kWriterInitialSize)
 {
-    if (!sHandleImporter.initialize()) {
-        LOG_ALWAYS_FATAL("failed to initialize handle importer");
-    }
 }
 
-HwcClient::~HwcClient()
+ComposerClient::~ComposerClient()
 {
     mHal.enableCallback(false);
     mHal.removeClient();
@@ -264,7 +261,15 @@
     sHandleImporter.cleanup();
 }
 
-void HwcClient::onHotplug(Display display,
+void ComposerClient::initialize()
+{
+    mReader = createCommandReader();
+    if (!sHandleImporter.initialize()) {
+        LOG_ALWAYS_FATAL("failed to initialize handle importer");
+    }
+}
+
+void ComposerClient::onHotplug(Display display,
         IComposerCallback::Connection connected)
 {
     {
@@ -280,17 +285,18 @@
     mCallback->onHotplug(display, connected);
 }
 
-void HwcClient::onRefresh(Display display)
+void ComposerClient::onRefresh(Display display)
 {
     mCallback->onRefresh(display);
 }
 
-void HwcClient::onVsync(Display display, int64_t timestamp)
+void ComposerClient::onVsync(Display display, int64_t timestamp)
 {
     mCallback->onVsync(display, timestamp);
 }
 
-Return<void> HwcClient::registerCallback(const sp<IComposerCallback>& callback)
+Return<void> ComposerClient::registerCallback(
+        const sp<IComposerCallback>& callback)
 {
     // no locking as we require this function to be called only once
     mCallback = callback;
@@ -299,13 +305,13 @@
     return Void();
 }
 
-Return<uint32_t> HwcClient::getMaxVirtualDisplayCount()
+Return<uint32_t> ComposerClient::getMaxVirtualDisplayCount()
 {
     return mHal.getMaxVirtualDisplayCount();
 }
 
-Return<void> HwcClient::createVirtualDisplay(uint32_t width, uint32_t height,
-        PixelFormat formatHint, uint32_t outputBufferSlotCount,
+Return<void> ComposerClient::createVirtualDisplay(uint32_t width,
+        uint32_t height, PixelFormat formatHint, uint32_t outputBufferSlotCount,
         createVirtualDisplay_cb hidl_cb)
 {
     Display display = 0;
@@ -322,7 +328,7 @@
     return Void();
 }
 
-Return<Error> HwcClient::destroyVirtualDisplay(Display display)
+Return<Error> ComposerClient::destroyVirtualDisplay(Display display)
 {
     Error err = mHal.destroyVirtualDisplay(display);
     if (err == Error::NONE) {
@@ -334,8 +340,8 @@
     return err;
 }
 
-Return<void> HwcClient::createLayer(Display display, uint32_t bufferSlotCount,
-        createLayer_cb hidl_cb)
+Return<void> ComposerClient::createLayer(Display display,
+        uint32_t bufferSlotCount, createLayer_cb hidl_cb)
 {
     Layer layer = 0;
     Error err = mHal.createLayer(display, &layer);
@@ -351,7 +357,7 @@
     return Void();
 }
 
-Return<Error> HwcClient::destroyLayer(Display display, Layer layer)
+Return<Error> ComposerClient::destroyLayer(Display display, Layer layer)
 {
     Error err = mHal.destroyLayer(display, layer);
     if (err == Error::NONE) {
@@ -364,7 +370,7 @@
     return err;
 }
 
-Return<void> HwcClient::getActiveConfig(Display display,
+Return<void> ComposerClient::getActiveConfig(Display display,
         getActiveConfig_cb hidl_cb)
 {
     Config config = 0;
@@ -374,7 +380,7 @@
     return Void();
 }
 
-Return<Error> HwcClient::getClientTargetSupport(Display display,
+Return<Error> ComposerClient::getClientTargetSupport(Display display,
         uint32_t width, uint32_t height,
         PixelFormat format, Dataspace dataspace)
 {
@@ -383,7 +389,8 @@
     return err;
 }
 
-Return<void> HwcClient::getColorModes(Display display, getColorModes_cb hidl_cb)
+Return<void> ComposerClient::getColorModes(Display display,
+          getColorModes_cb hidl_cb)
 {
     hidl_vec<ColorMode> modes;
     Error err = mHal.getColorModes(display, &modes);
@@ -392,7 +399,7 @@
     return Void();
 }
 
-Return<void> HwcClient::getDisplayAttribute(Display display,
+Return<void> ComposerClient::getDisplayAttribute(Display display,
         Config config, Attribute attribute,
         getDisplayAttribute_cb hidl_cb)
 {
@@ -403,7 +410,7 @@
     return Void();
 }
 
-Return<void> HwcClient::getDisplayConfigs(Display display,
+Return<void> ComposerClient::getDisplayConfigs(Display display,
         getDisplayConfigs_cb hidl_cb)
 {
     hidl_vec<Config> configs;
@@ -413,7 +420,7 @@
     return Void();
 }
 
-Return<void> HwcClient::getDisplayName(Display display,
+Return<void> ComposerClient::getDisplayName(Display display,
         getDisplayName_cb hidl_cb)
 {
     hidl_string name;
@@ -423,7 +430,7 @@
     return Void();
 }
 
-Return<void> HwcClient::getDisplayType(Display display,
+Return<void> ComposerClient::getDisplayType(Display display,
         getDisplayType_cb hidl_cb)
 {
     DisplayType type = DisplayType::INVALID;
@@ -433,7 +440,7 @@
     return Void();
 }
 
-Return<void> HwcClient::getDozeSupport(Display display,
+Return<void> ComposerClient::getDozeSupport(Display display,
         getDozeSupport_cb hidl_cb)
 {
     bool support = false;
@@ -443,7 +450,7 @@
     return Void();
 }
 
-Return<void> HwcClient::getHdrCapabilities(Display display,
+Return<void> ComposerClient::getHdrCapabilities(Display display,
         getHdrCapabilities_cb hidl_cb)
 {
     hidl_vec<Hdr> types;
@@ -457,7 +464,7 @@
     return Void();
 }
 
-Return<Error> HwcClient::setClientTargetSlotCount(Display display,
+Return<Error> ComposerClient::setClientTargetSlotCount(Display display,
         uint32_t clientTargetSlotCount)
 {
     std::lock_guard<std::mutex> lock(mDisplayDataMutex);
@@ -472,39 +479,39 @@
     return Error::NONE;
 }
 
-Return<Error> HwcClient::setActiveConfig(Display display, Config config)
+Return<Error> ComposerClient::setActiveConfig(Display display, Config config)
 {
     Error err = mHal.setActiveConfig(display, config);
     return err;
 }
 
-Return<Error> HwcClient::setColorMode(Display display, ColorMode mode)
+Return<Error> ComposerClient::setColorMode(Display display, ColorMode mode)
 {
     Error err = mHal.setColorMode(display, mode);
     return err;
 }
 
-Return<Error> HwcClient::setPowerMode(Display display, PowerMode mode)
+Return<Error> ComposerClient::setPowerMode(Display display, PowerMode mode)
 {
     Error err = mHal.setPowerMode(display, mode);
     return err;
 }
 
-Return<Error> HwcClient::setVsyncEnabled(Display display, Vsync enabled)
+Return<Error> ComposerClient::setVsyncEnabled(Display display, Vsync enabled)
 {
     Error err = mHal.setVsyncEnabled(display, enabled);
     return err;
 }
 
-Return<Error> HwcClient::setInputCommandQueue(
+Return<Error> ComposerClient::setInputCommandQueue(
         const MQDescriptorSync<uint32_t>& descriptor)
 {
     std::lock_guard<std::mutex> lock(mCommandMutex);
-    return mReader.setMQDescriptor(descriptor) ?
+    return mReader->setMQDescriptor(descriptor) ?
         Error::NONE : Error::NO_RESOURCES;
 }
 
-Return<void> HwcClient::getOutputCommandQueue(
+Return<void> ComposerClient::getOutputCommandQueue(
         getOutputCommandQueue_cb hidl_cb)
 {
     // no locking as we require this function to be called inside
@@ -520,7 +527,7 @@
     return Void();
 }
 
-Return<void> HwcClient::executeCommands(uint32_t inLength,
+Return<void> ComposerClient::executeCommands(uint32_t inLength,
         const hidl_vec<hidl_handle>& inHandles,
         executeCommands_cb hidl_cb)
 {
@@ -530,12 +537,12 @@
     uint32_t outLength = 0;
     hidl_vec<hidl_handle> outHandles;
 
-    if (!mReader.readQueue(inLength, inHandles)) {
+    if (!mReader->readQueue(inLength, inHandles)) {
         hidl_cb(Error::BAD_PARAMETER, outChanged, outLength, outHandles);
         return Void();
     }
 
-    Error err = mReader.parse();
+    Error err = mReader->parse();
     if (err == Error::NONE &&
             !mWriter.writeQueue(&outChanged, &outLength, &outHandles)) {
         err = Error::NO_RESOURCES;
@@ -543,18 +550,29 @@
 
     hidl_cb(err, outChanged, outLength, outHandles);
 
-    mReader.reset();
+    mReader->reset();
     mWriter.reset();
 
     return Void();
 }
 
-HwcClient::CommandReader::CommandReader(HwcClient& client)
+std::unique_ptr<ComposerClient::CommandReader>
+ComposerClient::createCommandReader()
+{
+    return std::unique_ptr<ComposerClient::CommandReader>(
+        new CommandReader(*this));
+}
+
+ComposerClient::CommandReader::CommandReader(ComposerClient& client)
     : mClient(client), mHal(client.mHal), mWriter(client.mWriter)
 {
 }
 
-Error HwcClient::CommandReader::parse()
+ComposerClient::CommandReader::~CommandReader()
+{
+}
+
+Error ComposerClient::CommandReader::parse()
 {
     IComposerClient::Command command;
     uint16_t length = 0;
@@ -564,79 +582,7 @@
             break;
         }
 
-        bool parsed = false;
-        switch (command) {
-        case IComposerClient::Command::SELECT_DISPLAY:
-            parsed = parseSelectDisplay(length);
-            break;
-        case IComposerClient::Command::SELECT_LAYER:
-            parsed = parseSelectLayer(length);
-            break;
-        case IComposerClient::Command::SET_COLOR_TRANSFORM:
-            parsed = parseSetColorTransform(length);
-            break;
-        case IComposerClient::Command::SET_CLIENT_TARGET:
-            parsed = parseSetClientTarget(length);
-            break;
-        case IComposerClient::Command::SET_OUTPUT_BUFFER:
-            parsed = parseSetOutputBuffer(length);
-            break;
-        case IComposerClient::Command::VALIDATE_DISPLAY:
-            parsed = parseValidateDisplay(length);
-            break;
-        case IComposerClient::Command::ACCEPT_DISPLAY_CHANGES:
-            parsed = parseAcceptDisplayChanges(length);
-            break;
-        case IComposerClient::Command::PRESENT_DISPLAY:
-            parsed = parsePresentDisplay(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_CURSOR_POSITION:
-            parsed = parseSetLayerCursorPosition(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_BUFFER:
-            parsed = parseSetLayerBuffer(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_SURFACE_DAMAGE:
-            parsed = parseSetLayerSurfaceDamage(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_BLEND_MODE:
-            parsed = parseSetLayerBlendMode(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_COLOR:
-            parsed = parseSetLayerColor(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_COMPOSITION_TYPE:
-            parsed = parseSetLayerCompositionType(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_DATASPACE:
-            parsed = parseSetLayerDataspace(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_DISPLAY_FRAME:
-            parsed = parseSetLayerDisplayFrame(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_PLANE_ALPHA:
-            parsed = parseSetLayerPlaneAlpha(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_SIDEBAND_STREAM:
-            parsed = parseSetLayerSidebandStream(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_SOURCE_CROP:
-            parsed = parseSetLayerSourceCrop(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_TRANSFORM:
-            parsed = parseSetLayerTransform(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_VISIBLE_REGION:
-            parsed = parseSetLayerVisibleRegion(length);
-            break;
-        case IComposerClient::Command::SET_LAYER_Z_ORDER:
-            parsed = parseSetLayerZOrder(length);
-            break;
-        default:
-            parsed = false;
-            break;
-        }
-
+        bool parsed = parseCommand(command, length);
         endCommand();
 
         if (!parsed) {
@@ -649,7 +595,59 @@
     return (isEmpty()) ? Error::NONE : Error::BAD_PARAMETER;
 }
 
-bool HwcClient::CommandReader::parseSelectDisplay(uint16_t length)
+bool ComposerClient::CommandReader::parseCommand(
+        IComposerClient::Command command, uint16_t length) {
+    switch (command) {
+    case IComposerClient::Command::SELECT_DISPLAY:
+        return parseSelectDisplay(length);
+    case IComposerClient::Command::SELECT_LAYER:
+        return parseSelectLayer(length);
+    case IComposerClient::Command::SET_COLOR_TRANSFORM:
+        return parseSetColorTransform(length);
+    case IComposerClient::Command::SET_CLIENT_TARGET:
+        return parseSetClientTarget(length);
+    case IComposerClient::Command::SET_OUTPUT_BUFFER:
+        return parseSetOutputBuffer(length);
+    case IComposerClient::Command::VALIDATE_DISPLAY:
+        return parseValidateDisplay(length);
+    case IComposerClient::Command::ACCEPT_DISPLAY_CHANGES:
+        return parseAcceptDisplayChanges(length);
+    case IComposerClient::Command::PRESENT_DISPLAY:
+        return parsePresentDisplay(length);
+    case IComposerClient::Command::SET_LAYER_CURSOR_POSITION:
+        return parseSetLayerCursorPosition(length);
+    case IComposerClient::Command::SET_LAYER_BUFFER:
+        return parseSetLayerBuffer(length);
+    case IComposerClient::Command::SET_LAYER_SURFACE_DAMAGE:
+        return parseSetLayerSurfaceDamage(length);
+    case IComposerClient::Command::SET_LAYER_BLEND_MODE:
+        return parseSetLayerBlendMode(length);
+    case IComposerClient::Command::SET_LAYER_COLOR:
+        return parseSetLayerColor(length);
+    case IComposerClient::Command::SET_LAYER_COMPOSITION_TYPE:
+        return parseSetLayerCompositionType(length);
+    case IComposerClient::Command::SET_LAYER_DATASPACE:
+        return parseSetLayerDataspace(length);
+    case IComposerClient::Command::SET_LAYER_DISPLAY_FRAME:
+        return parseSetLayerDisplayFrame(length);
+    case IComposerClient::Command::SET_LAYER_PLANE_ALPHA:
+        return parseSetLayerPlaneAlpha(length);
+    case IComposerClient::Command::SET_LAYER_SIDEBAND_STREAM:
+        return parseSetLayerSidebandStream(length);
+    case IComposerClient::Command::SET_LAYER_SOURCE_CROP:
+        return parseSetLayerSourceCrop(length);
+    case IComposerClient::Command::SET_LAYER_TRANSFORM:
+        return parseSetLayerTransform(length);
+    case IComposerClient::Command::SET_LAYER_VISIBLE_REGION:
+        return parseSetLayerVisibleRegion(length);
+    case IComposerClient::Command::SET_LAYER_Z_ORDER:
+        return parseSetLayerZOrder(length);
+    default:
+        return false;
+    }
+}
+
+bool ComposerClient::CommandReader::parseSelectDisplay(uint16_t length)
 {
     if (length != CommandWriterBase::kSelectDisplayLength) {
         return false;
@@ -661,7 +659,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSelectLayer(uint16_t length)
+bool ComposerClient::CommandReader::parseSelectLayer(uint16_t length)
 {
     if (length != CommandWriterBase::kSelectLayerLength) {
         return false;
@@ -672,7 +670,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetColorTransform(uint16_t length)
+bool ComposerClient::CommandReader::parseSetColorTransform(uint16_t length)
 {
     if (length != CommandWriterBase::kSetColorTransformLength) {
         return false;
@@ -692,7 +690,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetClientTarget(uint16_t length)
+bool ComposerClient::CommandReader::parseSetClientTarget(uint16_t length)
 {
     // 4 parameters followed by N rectangles
     if ((length - 4) % 4 != 0) {
@@ -720,7 +718,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetOutputBuffer(uint16_t length)
+bool ComposerClient::CommandReader::parseSetOutputBuffer(uint16_t length)
 {
     if (length != CommandWriterBase::kSetOutputBufferLength) {
         return false;
@@ -744,7 +742,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseValidateDisplay(uint16_t length)
+bool ComposerClient::CommandReader::parseValidateDisplay(uint16_t length)
 {
     if (length != CommandWriterBase::kValidateDisplayLength) {
         return false;
@@ -771,7 +769,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseAcceptDisplayChanges(uint16_t length)
+bool ComposerClient::CommandReader::parseAcceptDisplayChanges(uint16_t length)
 {
     if (length != CommandWriterBase::kAcceptDisplayChangesLength) {
         return false;
@@ -785,7 +783,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parsePresentDisplay(uint16_t length)
+bool ComposerClient::CommandReader::parsePresentDisplay(uint16_t length)
 {
     if (length != CommandWriterBase::kPresentDisplayLength) {
         return false;
@@ -805,7 +803,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerCursorPosition(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerCursorPosition(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerCursorPositionLength) {
         return false;
@@ -820,7 +818,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerBuffer(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerBuffer(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerBufferLength) {
         return false;
@@ -844,7 +842,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerSurfaceDamage(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerSurfaceDamage(uint16_t length)
 {
     // N rectangles
     if (length % 4 != 0) {
@@ -860,7 +858,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerBlendMode(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerBlendMode(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerBlendModeLength) {
         return false;
@@ -874,7 +872,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerColor(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerColor(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerColorLength) {
         return false;
@@ -888,7 +886,8 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerCompositionType(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerCompositionType(
+        uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerCompositionTypeLength) {
         return false;
@@ -902,7 +901,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerDataspace(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerDataspace(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerDataspaceLength) {
         return false;
@@ -916,7 +915,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerDisplayFrame(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerDisplayFrame(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerDisplayFrameLength) {
         return false;
@@ -930,7 +929,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerPlaneAlpha(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerPlaneAlpha(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerPlaneAlphaLength) {
         return false;
@@ -944,7 +943,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerSidebandStream(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerSidebandStream(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerSidebandStreamLength) {
         return false;
@@ -963,7 +962,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerSourceCrop(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerSourceCrop(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerSourceCropLength) {
         return false;
@@ -977,7 +976,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerTransform(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerTransform(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerTransformLength) {
         return false;
@@ -991,7 +990,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerVisibleRegion(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerVisibleRegion(uint16_t length)
 {
     // N rectangles
     if (length % 4 != 0) {
@@ -1007,7 +1006,7 @@
     return true;
 }
 
-bool HwcClient::CommandReader::parseSetLayerZOrder(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerZOrder(uint16_t length)
 {
     if (length != CommandWriterBase::kSetLayerZOrderLength) {
         return false;
@@ -1021,7 +1020,7 @@
     return true;
 }
 
-hwc_rect_t HwcClient::CommandReader::readRect()
+hwc_rect_t ComposerClient::CommandReader::readRect()
 {
     return hwc_rect_t{
         readSigned(),
@@ -1031,7 +1030,7 @@
     };
 }
 
-std::vector<hwc_rect_t> HwcClient::CommandReader::readRegion(size_t count)
+std::vector<hwc_rect_t> ComposerClient::CommandReader::readRegion(size_t count)
 {
     std::vector<hwc_rect_t> region;
     region.reserve(count);
@@ -1043,7 +1042,7 @@
     return region;
 }
 
-hwc_frect_t HwcClient::CommandReader::readFRect()
+hwc_frect_t ComposerClient::CommandReader::readFRect()
 {
     return hwc_frect_t{
         readFloat(),
@@ -1053,8 +1052,8 @@
     };
 }
 
-Error HwcClient::CommandReader::lookupBuffer(BufferCache cache, uint32_t slot,
-        bool useCache, buffer_handle_t& handle)
+Error ComposerClient::CommandReader::lookupBuffer(BufferCache cache,
+        uint32_t slot, bool useCache, buffer_handle_t& handle)
 {
     std::lock_guard<std::mutex> lock(mClient.mDisplayDataMutex);
 
diff --git a/graphics/composer/2.1/default/HwcClient.h b/graphics/composer/2.1/default/ComposerClient.h
similarity index 89%
rename from graphics/composer/2.1/default/HwcClient.h
rename to graphics/composer/2.1/default/ComposerClient.h
index 35a0450..d351cfb 100644
--- a/graphics/composer/2.1/default/HwcClient.h
+++ b/graphics/composer/2.1/default/ComposerClient.h
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_HWC_CLIENT_H
-#define ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_HWC_CLIENT_H
+#ifndef ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_CLIENT_H
+#define ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_CLIENT_H
 
 #include <mutex>
 #include <unordered_map>
@@ -50,10 +50,12 @@
     buffer_handle_t mHandle;
 };
 
-class HwcClient : public IComposerClient {
+class ComposerClient : public IComposerClient {
 public:
-    HwcClient(HwcHal& hal);
-    virtual ~HwcClient();
+    ComposerClient(ComposerBase& hal);
+    virtual ~ComposerClient();
+
+    void initialize();
 
     void onHotplug(Display display, IComposerCallback::Connection connected);
     void onRefresh(Display display);
@@ -104,7 +106,7 @@
             const hidl_vec<hidl_handle>& inHandles,
             executeCommands_cb hidl_cb) override;
 
-private:
+protected:
     struct LayerBuffers {
         std::vector<BufferClone> Buffers;
         BufferClone SidebandStream;
@@ -123,10 +125,15 @@
 
     class CommandReader : public CommandReaderBase {
     public:
-        CommandReader(HwcClient& client);
+        CommandReader(ComposerClient& client);
+        virtual ~CommandReader();
+
         Error parse();
 
-    private:
+    protected:
+        virtual bool parseCommand(IComposerClient::Command command,
+                uint16_t length);
+
         bool parseSelectDisplay(uint16_t length);
         bool parseSelectLayer(uint16_t length);
         bool parseSetColorTransform(uint16_t length);
@@ -169,21 +176,23 @@
                     0, false, handle);
         }
 
-        HwcClient& mClient;
-        HwcHal& mHal;
+        ComposerClient& mClient;
+        ComposerBase& mHal;
         CommandWriterBase& mWriter;
 
         Display mDisplay;
         Layer mLayer;
     };
 
-    HwcHal& mHal;
+    virtual std::unique_ptr<CommandReader> createCommandReader();
+
+    ComposerBase& mHal;
 
     // 64KiB minus a small space for metadata such as read/write pointers
     static constexpr size_t kWriterInitialSize =
         64 * 1024 / sizeof(uint32_t) - 16;
     std::mutex mCommandMutex;
-    CommandReader mReader;
+    std::unique_ptr<CommandReader> mReader;
     CommandWriterBase mWriter;
 
     sp<IComposerCallback> mCallback;
@@ -199,4 +208,4 @@
 } // namespace hardware
 } // namespace android
 
-#endif  // ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_HWC_CLIENT_H
+#endif  // ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_CLIENT_H
diff --git a/graphics/composer/2.1/default/Hwc.cpp b/graphics/composer/2.1/default/Hwc.cpp
index 4efb12b..cf82967 100644
--- a/graphics/composer/2.1/default/Hwc.cpp
+++ b/graphics/composer/2.1/default/Hwc.cpp
@@ -20,8 +20,8 @@
 
 #include <log/log.h>
 
+#include "ComposerClient.h"
 #include "Hwc.h"
-#include "HwcClient.h"
 
 namespace android {
 namespace hardware {
@@ -184,14 +184,15 @@
 Return<void> HwcHal::createClient(createClient_cb hidl_cb)
 {
     Error err = Error::NONE;
-    sp<HwcClient> client;
+    sp<ComposerClient> client;
 
     {
         std::lock_guard<std::mutex> lock(mClientMutex);
 
         // only one client is allowed
         if (mClient == nullptr) {
-            client = new HwcClient(*this);
+            client = new ComposerClient(*this);
+            client->initialize();
             mClient = client;
         } else {
             err = Error::NO_RESOURCES;
@@ -203,7 +204,7 @@
     return Void();
 }
 
-sp<HwcClient> HwcHal::getClient()
+sp<ComposerClient> HwcHal::getClient()
 {
     std::lock_guard<std::mutex> lock(mClientMutex);
     return (mClient != nullptr) ? mClient.promote() : nullptr;
diff --git a/graphics/composer/2.1/default/Hwc.h b/graphics/composer/2.1/default/Hwc.h
index 6420b31..ca08cf0 100644
--- a/graphics/composer/2.1/default/Hwc.h
+++ b/graphics/composer/2.1/default/Hwc.h
@@ -24,6 +24,8 @@
 #include <android/hardware/graphics/composer/2.1/IComposer.h>
 #include <hardware/hwcomposer2.h>
 
+#include "ComposerBase.h"
+
 namespace android {
 namespace hardware {
 namespace graphics {
@@ -38,96 +40,101 @@
 using android::hardware::graphics::common::V1_0::ColorTransform;
 using android::hardware::graphics::common::V1_0::Hdr;
 
-class HwcClient;
+class ComposerClient;
 
-class HwcHal : public IComposer {
+class HwcHal : public IComposer, public ComposerBase {
 public:
     HwcHal(const hw_module_t* module);
     virtual ~HwcHal();
 
+    bool hasCapability(Capability capability) const;
+
     // IComposer interface
     Return<void> getCapabilities(getCapabilities_cb hidl_cb) override;
     Return<void> dumpDebugInfo(dumpDebugInfo_cb hidl_cb) override;
     Return<void> createClient(createClient_cb hidl_cb) override;
 
-    bool hasCapability(Capability capability) const;
-
-    void removeClient();
-
-    void enableCallback(bool enable);
-
-    uint32_t getMaxVirtualDisplayCount();
+    // ComposerBase interface
+    void removeClient() override;
+    void enableCallback(bool enable) override;
+    uint32_t getMaxVirtualDisplayCount() override;
     Error createVirtualDisplay(uint32_t width, uint32_t height,
-        PixelFormat* format, Display* outDisplay);
-    Error destroyVirtualDisplay(Display display);
+        PixelFormat* format, Display* outDisplay) override;
+    Error destroyVirtualDisplay(Display display) override;
 
-    Error createLayer(Display display, Layer* outLayer);
-    Error destroyLayer(Display display, Layer layer);
+    Error createLayer(Display display, Layer* outLayer) override;
+    Error destroyLayer(Display display, Layer layer) override;
 
-    Error getActiveConfig(Display display, Config* outConfig);
+    Error getActiveConfig(Display display, Config* outConfig) override;
     Error getClientTargetSupport(Display display,
             uint32_t width, uint32_t height,
-            PixelFormat format, Dataspace dataspace);
-    Error getColorModes(Display display, hidl_vec<ColorMode>* outModes);
+            PixelFormat format, Dataspace dataspace) override;
+    Error getColorModes(Display display,
+            hidl_vec<ColorMode>* outModes) override;
     Error getDisplayAttribute(Display display, Config config,
-            IComposerClient::Attribute attribute, int32_t* outValue);
-    Error getDisplayConfigs(Display display, hidl_vec<Config>* outConfigs);
-    Error getDisplayName(Display display, hidl_string* outName);
+            IComposerClient::Attribute attribute, int32_t* outValue) override;
+    Error getDisplayConfigs(Display display,
+            hidl_vec<Config>* outConfigs) override;
+    Error getDisplayName(Display display, hidl_string* outName) override;
     Error getDisplayType(Display display,
-            IComposerClient::DisplayType* outType);
-    Error getDozeSupport(Display display, bool* outSupport);
+            IComposerClient::DisplayType* outType) override;
+    Error getDozeSupport(Display display, bool* outSupport) override;
     Error getHdrCapabilities(Display display, hidl_vec<Hdr>* outTypes,
             float* outMaxLuminance, float* outMaxAverageLuminance,
-            float* outMinLuminance);
+            float* outMinLuminance) override;
 
-    Error setActiveConfig(Display display, Config config);
-    Error setColorMode(Display display, ColorMode mode);
-    Error setPowerMode(Display display, IComposerClient::PowerMode mode);
-    Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled);
+    Error setActiveConfig(Display display, Config config) override;
+    Error setColorMode(Display display, ColorMode mode) override;
+    Error setPowerMode(Display display,
+            IComposerClient::PowerMode mode) override;
+    Error setVsyncEnabled(Display display,
+            IComposerClient::Vsync enabled) override;
 
     Error setColorTransform(Display display, const float* matrix,
-            int32_t hint);
+            int32_t hint) override;
     Error setClientTarget(Display display, buffer_handle_t target,
             int32_t acquireFence, int32_t dataspace,
-            const std::vector<hwc_rect_t>& damage);
+            const std::vector<hwc_rect_t>& damage) override;
     Error setOutputBuffer(Display display, buffer_handle_t buffer,
-            int32_t releaseFence);
+            int32_t releaseFence) override;
     Error validateDisplay(Display display,
             std::vector<Layer>* outChangedLayers,
             std::vector<IComposerClient::Composition>* outCompositionTypes,
             uint32_t* outDisplayRequestMask,
             std::vector<Layer>* outRequestedLayers,
-            std::vector<uint32_t>* outRequestMasks);
-    Error acceptDisplayChanges(Display display);
+            std::vector<uint32_t>* outRequestMasks) override;
+    Error acceptDisplayChanges(Display display) override;
     Error presentDisplay(Display display, int32_t* outPresentFence,
             std::vector<Layer>* outLayers,
-            std::vector<int32_t>* outReleaseFences);
+            std::vector<int32_t>* outReleaseFences) override;
 
     Error setLayerCursorPosition(Display display, Layer layer,
-            int32_t x, int32_t y);
+            int32_t x, int32_t y) override;
     Error setLayerBuffer(Display display, Layer layer,
-            buffer_handle_t buffer, int32_t acquireFence);
+            buffer_handle_t buffer, int32_t acquireFence) override;
     Error setLayerSurfaceDamage(Display display, Layer layer,
-            const std::vector<hwc_rect_t>& damage);
-    Error setLayerBlendMode(Display display, Layer layer, int32_t mode);
+            const std::vector<hwc_rect_t>& damage) override;
+    Error setLayerBlendMode(Display display, Layer layer,
+            int32_t mode) override;
     Error setLayerColor(Display display, Layer layer,
-            IComposerClient::Color color);
+            IComposerClient::Color color) override;
     Error setLayerCompositionType(Display display, Layer layer,
-            int32_t type);
+            int32_t type) override;
     Error setLayerDataspace(Display display, Layer layer,
-            int32_t dataspace);
+            int32_t dataspace) override;
     Error setLayerDisplayFrame(Display display, Layer layer,
-            const hwc_rect_t& frame);
-    Error setLayerPlaneAlpha(Display display, Layer layer, float alpha);
+            const hwc_rect_t& frame) override;
+    Error setLayerPlaneAlpha(Display display, Layer layer,
+            float alpha) override;
     Error setLayerSidebandStream(Display display, Layer layer,
-            buffer_handle_t stream);
+            buffer_handle_t stream) override;
     Error setLayerSourceCrop(Display display, Layer layer,
-            const hwc_frect_t& crop);
+            const hwc_frect_t& crop) override;
     Error setLayerTransform(Display display, Layer layer,
-            int32_t transform);
+            int32_t transform) override;
     Error setLayerVisibleRegion(Display display, Layer layer,
-            const std::vector<hwc_rect_t>& visible);
-    Error setLayerZOrder(Display display, Layer layer, uint32_t z);
+            const std::vector<hwc_rect_t>& visible) override;
+    Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;
 
 private:
     void initCapabilities();
@@ -136,7 +143,7 @@
     void initDispatch(hwc2_function_descriptor_t desc, T* outPfn);
     void initDispatch();
 
-    sp<HwcClient> getClient();
+    sp<ComposerClient> getClient();
 
     static void hotplugHook(hwc2_callback_data_t callbackData,
         hwc2_display_t display, int32_t connected);
@@ -196,7 +203,7 @@
     } mDispatch;
 
     std::mutex mClientMutex;
-    wp<HwcClient> mClient;
+    wp<ComposerClient> mClient;
 };
 
 extern "C" IComposer* HIDL_FETCH_IComposer(const char* name);
diff --git a/media/1.0/types.hal b/media/1.0/types.hal
index 89b7fa2..1f9c4dc 100644
--- a/media/1.0/types.hal
+++ b/media/1.0/types.hal
@@ -40,7 +40,9 @@
     uint32_t stride;
     PixelFormat format;
     uint32_t usage; // TODO: convert to an enum
+    uint32_t generationNumber;
     uint64_t layerCount;
+    uint64_t id;
 };
 
 /**
@@ -52,25 +54,18 @@
 };
 
 /**
- * Ref: frameworks/native/include/binder/IMemory.h
- * Ref: frameworks/native/libs/binder/IMemory.cpp
+ * Ref: frameworks/native/include/android/rect.h
+ * Ref: frameworks/native/include/ui/Rect.h
  */
-
-/**
- * This struct contains attributes for a shared memory buffer that can be put
- * into a union.
- */
-struct SharedMemoryAttributes {
-    uint32_t size;
-    uint32_t flags; // TODO: convert to an enum
-    uint32_t offset;
+struct Rect {
+    int32_t left;
+    int32_t top;
+    int32_t right;
+    int32_t bottom;
 };
 
 /**
- * A SharedMemory is simply SharedMemoryAttributes plus a native handle.
+ * Ref: frameworks/native/include/ui/Region.h
  */
-struct SharedMemory {
-    handle nativeHandle;
-    SharedMemoryAttributes attr;
-};
+typedef vec<Rect> Region;
 
diff --git a/media/omx/1.0/Android.bp b/media/omx/1.0/Android.bp
index 657c23b..f79aabb 100644
--- a/media/omx/1.0/Android.bp
+++ b/media/omx/1.0/Android.bp
@@ -8,17 +8,21 @@
         "types.hal",
         "IGraphicBufferSource.hal",
         "IOmx.hal",
+        "IOmxBufferProducer.hal",
         "IOmxBufferSource.hal",
         "IOmxNode.hal",
         "IOmxObserver.hal",
+        "IOmxProducerListener.hal",
     ],
     out: [
         "android/hardware/media/omx/1.0/types.cpp",
         "android/hardware/media/omx/1.0/GraphicBufferSourceAll.cpp",
         "android/hardware/media/omx/1.0/OmxAll.cpp",
+        "android/hardware/media/omx/1.0/OmxBufferProducerAll.cpp",
         "android/hardware/media/omx/1.0/OmxBufferSourceAll.cpp",
         "android/hardware/media/omx/1.0/OmxNodeAll.cpp",
         "android/hardware/media/omx/1.0/OmxObserverAll.cpp",
+        "android/hardware/media/omx/1.0/OmxProducerListenerAll.cpp",
     ],
 }
 
@@ -30,9 +34,11 @@
         "types.hal",
         "IGraphicBufferSource.hal",
         "IOmx.hal",
+        "IOmxBufferProducer.hal",
         "IOmxBufferSource.hal",
         "IOmxNode.hal",
         "IOmxObserver.hal",
+        "IOmxProducerListener.hal",
     ],
     out: [
         "android/hardware/media/omx/1.0/types.h",
@@ -46,6 +52,11 @@
         "android/hardware/media/omx/1.0/BnHwOmx.h",
         "android/hardware/media/omx/1.0/BpHwOmx.h",
         "android/hardware/media/omx/1.0/BsOmx.h",
+        "android/hardware/media/omx/1.0/IOmxBufferProducer.h",
+        "android/hardware/media/omx/1.0/IHwOmxBufferProducer.h",
+        "android/hardware/media/omx/1.0/BnOmxBufferProducer.h",
+        "android/hardware/media/omx/1.0/BpOmxBufferProducer.h",
+        "android/hardware/media/omx/1.0/BsOmxBufferProducer.h",
         "android/hardware/media/omx/1.0/IOmxBufferSource.h",
         "android/hardware/media/omx/1.0/IHwOmxBufferSource.h",
         "android/hardware/media/omx/1.0/BnHwOmxBufferSource.h",
@@ -61,6 +72,11 @@
         "android/hardware/media/omx/1.0/BnHwOmxObserver.h",
         "android/hardware/media/omx/1.0/BpHwOmxObserver.h",
         "android/hardware/media/omx/1.0/BsOmxObserver.h",
+        "android/hardware/media/omx/1.0/IOmxProducerListener.h",
+        "android/hardware/media/omx/1.0/IHwOmxProducerListener.h",
+        "android/hardware/media/omx/1.0/BnOmxProducerListener.h",
+        "android/hardware/media/omx/1.0/BpOmxProducerListener.h",
+        "android/hardware/media/omx/1.0/BsOmxProducerListener.h",
     ],
 }
 
diff --git a/media/omx/1.0/IOmx.hal b/media/omx/1.0/IOmx.hal
index e9f0b76..acb1aae 100644
--- a/media/omx/1.0/IOmx.hal
+++ b/media/omx/1.0/IOmx.hal
@@ -20,6 +20,8 @@
 
 import IOmxNode;
 import IOmxObserver;
+import IOmxBufferProducer;
+import IGraphicBufferSource;
 
 /**
  * Ref: frameworks/av/include/media/IOMX.h: IOMX
@@ -32,15 +34,15 @@
      * Information for an IOmxNode component.
      */
     struct ComponentInfo {
-        string mName;       //< Name of the component.
-        vec<string> mRoles; //< Roles of the component.
+        string mName;
+        vec<string> mRoles;
     };
 
     /**
      * List available components.
      *
-     * @param[out] status will be the status of the call.
-     * @param[out] nodeList will be a list of ComponentInfo.
+     * @param[out] status The status of the call.
+     * @param[out] nodeList The list of ComponentInfo.
      */
     listNodes(
         ) generates (
@@ -51,11 +53,11 @@
     /**
      * Allocate an IOmxNode instance with the specified component name.
      *
-     * @param[in] name is the name of the component to create.
-     * @param[in] observer is an observer object that will receive messages from
+     * @param[in] name The name of the component to create.
+     * @param[in] observer An observer object that will receive messages from
      * the created instance.
-     * @param[out] status will be the status of the call.
-     * @param[out] omxNode will be the allocated instance of IOmxNode.
+     * @param[out] status The status of the call.
+     * @param[out] omxNode The allocated instance of IOmxNode.
      */
     allocateNode(
             string name,
@@ -65,5 +67,17 @@
             IOmxNode omxNode
         );
 
+    /**
+     * Create an input surface for recording.
+     *
+     * @param[out] producer The associated producer end of the buffer queue.
+     * @param[out] source The associated `IGraphicBufferSource`.
+     */
+    createInputSurface(
+        ) generates (
+            Status status,
+            IOmxBufferProducer producer,
+            IGraphicBufferSource source
+        );
 };
 
diff --git a/media/omx/1.0/IOmxBufferProducer.hal b/media/omx/1.0/IOmxBufferProducer.hal
new file mode 100644
index 0000000..12b5d14
--- /dev/null
+++ b/media/omx/1.0/IOmxBufferProducer.hal
@@ -0,0 +1,693 @@
+/*
+ * Copyright (C) 2016 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 android.hardware.media.omx@1.0;
+
+import android.hardware.graphics.common@1.0::Dataspace;
+import android.hardware.graphics.common@1.0::PixelFormat;
+
+import android.hardware.media@1.0::types;
+import IOmxProducerListener;
+
+/**
+ * Ref: frameworks/native/include/gui/IGraphicBufferProducer.h:
+ *      IGraphicBufferProducer
+ * This is a wrapper/wrapped HAL interface for the actual binder interface.
+ */
+interface IOmxBufferProducer {
+
+    /**
+     * Ref: frameworks/native/include/ui/FenceTime.h: FenceTime::Snapshot
+     *
+     * An atomic snapshot of the FenceTime that is flattenable.
+     */
+    struct FenceTimeSnapshot {
+        enum State : int32_t {
+            EMPTY,
+            FENCE,
+            SIGNAL_TIME,
+        };
+        State state;
+        Fence fence;
+        int64_t signalTimeNs;
+    };
+
+    /**
+     * Ref: frameworks/native/include/gui/FrameTimestamp.h: FrameEventsDelta
+     *
+     * A single frame update from the consumer to producer that can be sent
+     * through a HIDL interface. Although this may be sent multiple times for
+     * the same frame as new timestamps are set, Fences only need to be sent
+     * once.
+     */
+    struct FrameEventsDelta {
+        uint32_t index;
+        uint64_t frameNumber;
+        bool addPostCompositeCalled;
+        bool addRetireCalled;
+        bool addReleaseCalled;
+        int64_t postedTimeNs;
+        int64_t requestedPresentTimeNs;
+        int64_t latchTimeNs;
+        int64_t firstRefreshStartTimeNs;
+        int64_t lastRefreshStartTimeNs;
+        int64_t dequeueReadyTime;
+        FenceTimeSnapshot gpuCompositionDoneFence;
+        FenceTimeSnapshot displayPresentFence;
+        FenceTimeSnapshot displayRetireFence;
+        FenceTimeSnapshot releaseFence;
+    };
+
+    /**
+     * Ref: frameworks/native/include/gui/FrameTimestamp.h: FrameEventHistoryDelta
+     *
+     * A collection of updates from consumer to producer that can be sent
+     * through a HIDL interface.
+     */
+    typedef vec<FrameEventsDelta> FrameEventHistoryDelta;
+
+    /**
+     * Modes for disconnection.
+     */
+    enum DisconnectMode : int32_t {
+        /** Disconnect only the specified API. */
+        API,
+        /** Disconnect any API originally connected from the process calling
+         *  disconnect. */
+        ALL_LOCAL
+    };
+
+    struct QueueBufferInput {
+        /** A monotonically increasing value in nanoseconds. */
+        int64_t timestamp;
+        /** Whether the timestamp was synthesized at queue time. */
+        int32_t isAutoTimestamp;
+        /** Description of the contents, interpretation depends on format. */
+        Dataspace dataSpace;
+        /** A crop rectangle that's used as a hint to the consumer. */
+        Rect crop;
+        /** A set of flags from NATIVE_WINDOW_SCALING_* in <window.h>. */
+        int32_t scalingMode;
+        /** A set of flags from NATIVE_WINDOW_TRANSFORM_* in <window.h>. */
+        uint32_t transform;
+        /** The sticky transform set in Surface (only used by the LEGACY camera
+         *  mode). */
+        uint32_t stickyTransform;
+        /** A fence that the consumer must wait on before reading the buffer;
+         *  set this to Fence::NO_FENCE if the buffer is ready immediately. */
+        Fence fence;
+        Region surfaceDamage;
+        /** Whether or not the latest frame timestamps should be retrieved from
+         *  the consumer. */
+        bool getFrameTimestamps;
+    };
+
+    struct QueueBufferOutput {
+        uint32_t width;
+        uint32_t height;
+        uint32_t transformHint;
+        uint32_t numPendingBuffers;
+        uint64_t nextFrameNumber;
+        FrameEventHistoryDelta frameTimestamps;
+    };
+
+    /**
+     * requestBuffer requests a new buffer for the given index. The server (i.e.
+     * the IOmxBufferProducer implementation) assigns the newly created
+     * buffer to the given slot index, and the client is expected to mirror the
+     * slot->buffer mapping so that it's not necessary to transfer an
+     * AnwBuffer for every dequeue operation.
+     *
+     * The slot must be in the range of [0, NUM_BUFFER_SLOTS).
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned or the producer is not
+     *             connected.
+     * * BAD_VALUE - one of the two conditions occurred:
+     *              * slot was out of range (see above)
+     *              * buffer specified by the slot is not dequeued
+     */
+    requestBuffer(
+            int32_t slot
+        ) generates (
+            Status status,
+            AnwBuffer buffer
+        );
+
+    /**
+     * setMaxDequeuedBufferCount sets the maximum number of buffers that can be
+     * dequeued by the producer at one time. If this method succeeds, any new
+     * buffer slots will be both unallocated and owned by the BufferQueue object
+     * (i.e. they are not owned by the producer or consumer). Calling this may
+     * also cause some buffer slots to be emptied. If the caller is caching the
+     * contents of the buffer slots, it should empty that cache after calling
+     * this method.
+     *
+     * This function should not be called with a value of maxDequeuedBuffers
+     * that is less than the number of currently dequeued buffer slots. Doing so
+     * will result in a BAD_VALUE error.
+     *
+     * The buffer count should be at least 1 (inclusive), but at most
+     * (NUM_BUFFER_SLOTS - the minimum undequeued buffer count) (exclusive). The
+     * minimum undequeued buffer count can be obtained by calling
+     * query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS).
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned.
+     * * BAD_VALUE - one of the below conditions occurred:
+     *     * bufferCount was out of range (see above).
+     *     * client would have more than the requested number of dequeued
+     *       buffers after this call.
+     *     * this call would cause the maxBufferCount value to be exceeded.
+     *     * failure to adjust the number of available slots.
+     */
+    setMaxDequeuedBufferCount(
+            int32_t maxDequeuedBuffers
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Set the async flag if the producer intends to asynchronously queue
+     * buffers without blocking. Typically this is used for triple-buffering
+     * and/or when the swap interval is set to zero.
+     *
+     * Enabling async mode will internally allocate an additional buffer to
+     * allow for the asynchronous behavior. If it is not enabled queue/dequeue
+     * calls may block.
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned.
+     * * BAD_VALUE - one of the following has occurred:
+     *             * this call would cause the maxBufferCount value to be
+     *               exceeded
+     *             * failure to adjust the number of available slots.
+     */
+    setAsyncMode(
+            bool async
+        ) generates (
+            Status status
+        );
+
+    /**
+     * dequeueBuffer requests a new buffer slot for the client to use. Ownership
+     * of the slot is transfered to the client, meaning that the server will not
+     * use the contents of the buffer associated with that slot.
+     *
+     * The slot index returned may or may not contain a buffer (client-side).
+     * If the slot is empty the client should call requestBuffer to assign a new
+     * buffer to that slot.
+     *
+     * Once the client is done filling this buffer, it is expected to transfer
+     * buffer ownership back to the server with either cancelBuffer on
+     * the dequeued slot or to fill in the contents of its associated buffer
+     * contents and call queueBuffer.
+     *
+     * If dequeueBuffer returns the BUFFER_NEEDS_REALLOCATION flag, the client is
+     * expected to call requestBuffer immediately.
+     *
+     * If dequeueBuffer returns the RELEASE_ALL_BUFFERS flag, the client is
+     * expected to release all of the mirrored slot->buffer mappings.
+     *
+     * The fence parameter will be updated to hold the fence associated with
+     * the buffer. The contents of the buffer must not be overwritten until the
+     * fence signals. If the fence is Fence::NO_FENCE, the buffer may be written
+     * immediately.
+     *
+     * The width and height parameters must be no greater than the minimum of
+     * GL_MAX_VIEWPORT_DIMS and GL_MAX_TEXTURE_SIZE (see: glGetIntegerv).
+     * An error due to invalid dimensions might not be reported until
+     * updateTexImage() is called.  If width and height are both zero, the
+     * default values specified by setDefaultBufferSize() are used instead.
+     *
+     * If the format is 0, the default format will be used.
+     *
+     * The usage argument specifies gralloc buffer usage flags.  The values
+     * are enumerated in <gralloc.h>, e.g. GRALLOC_USAGE_HW_RENDER.  These
+     * will be merged with the usage flags specified by
+     * IGraphicBufferConsumer::setConsumerUsageBits.
+     *
+     * This call will block until a buffer is available to be dequeued. If
+     * both the producer and consumer are controlled by the app, then this call
+     * can never block and will return WOULD_BLOCK if no buffer is available.
+     *
+     * A non-negative value with flags set (see above) will be returned upon
+     * success as status.
+     *
+     * Return of a negative means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned or the producer is not
+     *             connected.
+     * * BAD_VALUE - both in async mode and buffer count was less than the
+     *               max numbers of buffers that can be allocated at once.
+     * * INVALID_OPERATION - cannot attach the buffer because it would cause
+     *                       too many buffers to be dequeued, either because
+     *                       the producer already has a single buffer dequeued
+     *                       and did not set a buffer count, or because a
+     *                       buffer count was set and this call would cause
+     *                       it to be exceeded.
+     * * WOULD_BLOCK - no buffer is currently available, and blocking is disabled
+     *                 since both the producer/consumer are controlled by app
+     * * NO_MEMORY - out of memory, cannot allocate the graphics buffer.
+     * * TIMED_OUT - the timeout set by setDequeueTimeout was exceeded while
+     *               waiting for a buffer to become available.
+     *
+     * All other negative values are an unknown error returned downstream
+     * from the graphics allocator (typically errno).
+     */
+    dequeueBuffer(
+            uint32_t width,
+            uint32_t height,
+            PixelFormat format,
+            uint32_t usage,
+            bool getFrameTimestamps
+        ) generates (
+            Status status,
+            int32_t slot,
+            Fence fence,
+            FrameEventHistoryDelta outTimestamps
+        );
+
+    /**
+     * detachBuffer attempts to remove all ownership of the buffer in the given
+     * slot from the buffer queue. If this call succeeds, the slot will be
+     * freed, and there will be no way to obtain the buffer from this interface.
+     * The freed slot will remain unallocated until either it is selected to
+     * hold a freshly allocated buffer in dequeueBuffer or a buffer is attached
+     * to the slot. The buffer must have already been dequeued, and the caller
+     * must already possesses the sp<AnwBuffer> (i.e., must have called
+     * requestBuffer).
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned or the producer is not
+     *             connected.
+     * * BAD_VALUE - the given slot number is invalid, either because it is
+     *               out of the range [0, NUM_BUFFER_SLOTS), or because the slot
+     *               it refers to is not currently dequeued and requested.
+     */
+    detachBuffer(
+            int32_t slot
+        ) generates (
+            Status status
+        );
+
+    /**
+     * detachNextBuffer is equivalent to calling dequeueBuffer, requestBuffer,
+     * and detachBuffer in sequence, except for two things:
+     *
+     * 1) It is unnecessary to know the dimensions, format, or usage of the
+     *    next buffer.
+     * 2) It will not block, since if it cannot find an appropriate buffer to
+     *    return, it will return an error instead.
+     *
+     * Only slots that are free but still contain an AnwBuffer will be
+     * considered, and the oldest of those will be returned. buffer is
+     * equivalent to buffer from the requestBuffer call, and fence is
+     * equivalent to fence from the dequeueBuffer call.
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned or the producer is not
+     *             connected.
+     * * BAD_VALUE - either outBuffer or outFence were NULL.
+     * * NO_MEMORY - no slots were found that were both free and contained a
+     *               AnwBuffer.
+     */
+    detachNextBuffer(
+        ) generates (
+            Status status,
+            AnwBuffer buffer,
+            Fence fence
+        );
+
+    /**
+     * attachBuffer attempts to transfer ownership of a buffer to the buffer
+     * queue. If this call succeeds, it will be as if this buffer was dequeued
+     * from the returned slot number. As such, this call will fail if attaching
+     * this buffer would cause too many buffers to be simultaneously dequeued.
+     *
+     * If attachBuffer returns the RELEASE_ALL_BUFFERS flag, the caller is
+     * expected to release all of the mirrored slot->buffer mappings.
+     *
+     * A non-negative value with flags set (see above) will be returned upon
+     * success.
+     *
+     * Return of a negative value means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned or the producer is not
+     *             connected.
+     * * BAD_VALUE - outSlot or buffer were NULL, invalid combination of
+     *               async mode and buffer count override, or the generation
+     *               number of the buffer did not match the buffer queue.
+     * * INVALID_OPERATION - cannot attach the buffer because it would cause
+     *                       too many buffers to be dequeued, either because
+     *                       the producer already has a single buffer dequeued
+     *                       and did not set a buffer count, or because a
+     *                       buffer count was set and this call would cause
+     *                       it to be exceeded.
+     * * WOULD_BLOCK - no buffer slot is currently available, and blocking is
+     *                 disabled since both the producer/consumer are
+     *                 controlled by the app.
+     * * TIMED_OUT - the timeout set by setDequeueTimeout was exceeded while
+     *               waiting for a slot to become available.
+     */
+    attachBuffer(
+            AnwBuffer buffer
+        ) generates (
+            Status status,
+            int32_t slot
+        );
+
+    /**
+     * queueBuffer indicates that the client has finished filling in the
+     * contents of the buffer associated with slot and transfers ownership of
+     * that slot back to the server.
+     *
+     * It is not valid to call queueBuffer on a slot that is not owned
+     * by the client or one for which a buffer associated via requestBuffer
+     * (an attempt to do so will fail with a return value of BAD_VALUE).
+     *
+     * In addition, the input must be described by the client (as documented
+     * below). Any other properties (zero point, etc)
+     * are client-dependent, and should be documented by the client.
+     *
+     * The slot must be in the range of [0, NUM_BUFFER_SLOTS).
+     *
+     * Upon success, the output will be filled with meaningful values
+     * (refer to the documentation below).
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned or the producer is not
+     *             connected.
+     * * BAD_VALUE - one of the below conditions occurred:
+     *              * fence was NULL
+     *              * scaling mode was unknown
+     *              * both in async mode and buffer count was less than the
+     *                max numbers of buffers that can be allocated at once
+     *              * slot index was out of range (see above).
+     *              * the slot was not in the dequeued state
+     *              * the slot was enqueued without requesting a buffer
+     *              * crop rect is out of bounds of the buffer dimensions
+     */
+    queueBuffer(
+            int32_t slot,
+            QueueBufferInput input
+        ) generates (
+            Status status,
+            QueueBufferOutput output
+        );
+
+    /**
+     * cancelBuffer indicates that the client does not wish to fill in the
+     * buffer associated with slot and transfers ownership of the slot back to
+     * the server.
+     *
+     * The buffer is not queued for use by the consumer.
+     *
+     * The slot must be in the range of [0, NUM_BUFFER_SLOTS).
+     *
+     * The buffer will not be overwritten until the fence signals.  The fence
+     * will usually be the one obtained from dequeueBuffer.
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned or the producer is not
+     *             connected.
+     * * BAD_VALUE - one of the below conditions occurred:
+     *              * fence was NULL
+     *              * slot index was out of range (see above).
+     *              * the slot was not in the dequeued state
+     */
+    cancelBuffer(
+            int32_t slot,
+            Fence fence
+        ) generates (
+            Status status
+        );
+
+    /**
+     * query retrieves some information for this surface
+     * 'what' tokens allowed are that of NATIVE_WINDOW_* in <window.h>
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * NO_INIT - the buffer queue has been abandoned.
+     * * BAD_VALUE - what was out of range
+     */
+    query(
+            int32_t what
+        ) generates (
+            int32_t result,
+            int32_t value
+        );
+
+    /**
+     * connect attempts to connect a client API to the IOmxBufferProducer.
+     * This must be called before any other IOmxBufferProducer methods are
+     * called except for getAllocator. A consumer must be already connected.
+     *
+     * This method will fail if the connect was previously called on the
+     * IOmxBufferProducer and no corresponding disconnect call was made.
+     *
+     * The listener is an optional binder callback object that can be used if
+     * the producer wants to be notified when the consumer releases a buffer
+     * back to the BufferQueue. It is also used to detect the death of the
+     * producer. If only the latter functionality is desired, there is a
+     * DummyProducerListener class in IProducerListener.h that can be used.
+     *
+     * The api should be one of the NATIVE_WINDOW_API_* values in <window.h>
+     *
+     * The producerControlledByApp should be set to true if the producer is hosted
+     * by an untrusted process (typically app_process-forked processes). If both
+     * the producer and the consumer are app-controlled then all buffer queues
+     * will operate in async mode regardless of the async flag.
+     *
+     * Upon success, the output will be filled with meaningful data
+     * (refer to QueueBufferOutput documentation above).
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * NO_INIT - one of the following occurred:
+     *             * the buffer queue was abandoned
+     *             * no consumer has yet connected
+     * * BAD_VALUE - one of the following has occurred:
+     *             * the producer is already connected
+     *             * api was out of range (see above).
+     *             * output was NULL.
+     *             * Failure to adjust the number of available slots. This can
+     *               happen because of trying to allocate/deallocate the async
+     *               buffer in response to the value of producerControlledByApp.
+     * * DEAD_OBJECT - the token is hosted by an already-dead process
+     *
+     * Additional negative errors may be returned by the internals, they
+     * should be treated as opaque fatal unrecoverable errors.
+     */
+    connect(
+            IOmxProducerListener listener,
+            int32_t api,
+            bool producerControlledByApp
+        ) generates (
+            Status status,
+            QueueBufferOutput output
+        );
+
+    /**
+     * disconnect attempts to disconnect a client API from the
+     * IOmxBufferProducer.  Calling this method will cause any subsequent
+     * calls to other IOmxBufferProducer methods to fail except for
+     * getAllocator and connect.  Successfully calling connect after this will
+     * allow the other methods to succeed again.
+     *
+     * The api should be one of the NATIVE_WINDOW_API_* values in <window.h>
+     *
+     * Alternatively if mode is AllLocal, then the API value is ignored, and any API
+     * connected from the same PID calling disconnect will be disconnected.
+     *
+     * Disconnecting from an abandoned IOmxBufferProducer is legal and
+     * is considered a no-op.
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * BAD_VALUE - one of the following has occurred:
+     *             * the api specified does not match the one that was connected
+     *             * api was out of range (see above).
+     * * DEAD_OBJECT - the token is hosted by an already-dead process
+     */
+    disconnect(
+            int32_t api,
+            DisconnectMode mode /* = DisconnectMode::API */
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Attaches a sideband buffer stream to the IOmxBufferProducer.
+     *
+     * A sideband stream is a device-specific mechanism for passing buffers
+     * from the producer to the consumer without using dequeueBuffer/
+     * queueBuffer. If a sideband stream is present, the consumer can choose
+     * whether to acquire buffers from the sideband stream or from the queued
+     * buffers.
+     *
+     * Passing NULL or a different stream handle will detach the previous
+     * handle if any.
+     */
+    setSidebandStream(
+            handle stream
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Allocates buffers based on the given dimensions/format.
+     *
+     * This function will allocate up to the maximum number of buffers
+     * permitted by the current BufferQueue configuration. It will use the
+     * given format, dimensions, and usage bits, which are interpreted in the
+     * same way as for dequeueBuffer, and the async flag must be set the same
+     * way as for dequeueBuffer to ensure that the correct number of buffers are
+     * allocated. This is most useful to avoid an allocation delay during
+     * dequeueBuffer. If there are already the maximum number of buffers
+     * allocated, this function has no effect.
+     */
+    allocateBuffers(
+            uint32_t width,
+            uint32_t height,
+            PixelFormat format,
+            uint32_t usage
+        );
+
+    /**
+     * Sets whether dequeueBuffer is allowed to allocate new buffers.
+     *
+     * Normally dequeueBuffer does not discriminate between free slots which
+     * already have an allocated buffer and those which do not, and will
+     * allocate a new buffer if the slot doesn't have a buffer or if the slot's
+     * buffer doesn't match the requested size, format, or usage. This method
+     * allows the producer to restrict the eligible slots to those which already
+     * have an allocated buffer of the correct size, format, and usage. If no
+     * eligible slot is available, dequeueBuffer will block or return an error
+     * as usual.
+     */
+    allowAllocation(
+            bool allow
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Sets the current generation number of the BufferQueue.
+     *
+     * This generation number will be inserted into any buffers allocated by the
+     * BufferQueue, and any attempts to attach a buffer with a different
+     * generation number will fail. Buffers already in the queue are not
+     * affected and will retain their current generation number. The generation
+     * number defaults to 0.
+     */
+    setGenerationNumber(
+            uint32_t generationNumber
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Returns the name of the connected consumer.
+     */
+    getConsumerName(
+        ) generates (
+            string name
+        );
+
+    /**
+     * Used to enable/disable shared buffer mode.
+     *
+     * When shared buffer mode is enabled the first buffer that is queued or
+     * dequeued will be cached and returned to all subsequent calls to
+     * dequeueBuffer and acquireBuffer. This allows the producer and consumer to
+     * simultaneously access the same buffer.
+     */
+    setSharedBufferMode(
+            bool sharedBufferMode
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Used to enable/disable auto-refresh.
+     *
+     * Auto refresh has no effect outside of shared buffer mode. In shared
+     * buffer mode, when enabled, it indicates to the consumer that it should
+     * attempt to acquire buffers even if it is not aware of any being
+     * available.
+     */
+    setAutoRefresh(
+            bool autoRefresh
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Sets how long dequeueBuffer will wait for a buffer to become available
+     * before returning an error (TIMED_OUT).
+     *
+     * This timeout also affects the attachBuffer call, which will block if
+     * there is not a free slot available into which the attached buffer can be
+     * placed.
+     *
+     * By default, the BufferQueue will wait forever, which is indicated by a
+     * timeout of -1. If set (to a value other than -1), this will disable
+     * non-blocking mode and its corresponding spare buffer (which is used to
+     * ensure a buffer is always available).
+     *
+     * Return of a value other than NO_ERROR means an error has occurred:
+     * * BAD_VALUE - Failure to adjust the number of available slots. This can
+     *               happen because of trying to allocate/deallocate the async
+     *               buffer.
+     */
+    setDequeueTimeout(
+            int64_t timeoutNs
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Returns the last queued buffer along with a fence which must signal
+     * before the contents of the buffer are read. If there are no buffers in
+     * the queue, buffer.nativeHandle and fence will be null handles.
+     *
+     * transformMatrix is meaningless if buffer.nativeHandle is null.
+     */
+    getLastQueuedBuffer(
+        ) generates (
+            Status status,
+            AnwBuffer buffer,
+            Fence fence,
+            float[16] transformMatrix
+        );
+
+    /**
+     * Gets the frame events that haven't already been retrieved.
+     */
+    getFrameTimestamps(
+        ) generates (
+            FrameEventHistoryDelta timeStamps
+        );
+
+    /**
+     * Returns a unique id for this BufferQueue.
+     */
+    getUniqueId(
+        ) generates (
+            Status status,
+            uint64_t outId
+        );
+
+};
+
+
diff --git a/media/omx/1.0/IOmxNode.hal b/media/omx/1.0/IOmxNode.hal
index 5945b44..8729637 100644
--- a/media/omx/1.0/IOmxNode.hal
+++ b/media/omx/1.0/IOmxNode.hal
@@ -35,7 +35,7 @@
     /**
      * Free the node.
      *
-     * @param[out] status will be the status of the call.
+     * @param[out] status Status of the call.
      */
     freeNode(
         ) generates (
@@ -45,9 +45,9 @@
     /**
      * Invoke a command on the node.
      *
-     * @param[in] cmd indicates the type of the command.
-     * @param[in] param is a parameter for the command.
-     * @param[out] status will be the status of the call.
+     * @param[in] cmd Type of the command.
+     * @param[in] param Parameter for the command.
+     * @param[out] status Status of the call.
      *
      * @see OMX_SendCommand() in the OpenMax IL standard.
      */
@@ -61,33 +61,33 @@
     /**
      * Retrieve a parameter setting from the node.
      *
-     * @param[in] index indicates the type of the parameter to retrieve.
-     * @param[in] inParams holds some information about the retrieval.
-     * @param[out] status will be the status of the call.
-     * @param[out] outParams will be the current parameter setting.
+     * @param[in] index Type of the parameter to retrieve.
+     * @param[in] inParams Information about the retrieval.
+     * @param[out] status Status of the call.
+     * @param[out] outParams Current parameter setting.
      *
      * @see OMX_GetParameter() in the OpenMax IL standard.
      */
     getParameter(
             uint32_t index,
-            Bytes inParams // TODO: describe structure better or point at standard
+            Bytes inParams
         ) generates (
             Status status,
-            Bytes outParams // TODO: describe structure better or point at standard
+            Bytes outParams
         );
 
     /**
      * Change a parameter setting of the node.
      *
-     * @param[in] index indicates the type of the parameter to change.
-     * @param[in] params holds the new parameter setting.
-     * @param[out] status will be the status of the call.
+     * @param[in] index Type of the parameter to change.
+     * @param[in] params New parameter setting.
+     * @param[out] status Status of the call.
      *
      * @see OMX_SetParameter() in the OpenMax IL standard.
      */
     setParameter(
             uint32_t index,
-            Bytes params // TODO: describe structure better or point at standard
+            Bytes params
         ) generates (
             Status status
         );
@@ -95,33 +95,33 @@
     /**
      * Retrieve a configuration from the node.
      *
-     * @param[in] index indicates the type of the configuration to retrieve.
-     * @param[in] inConfig holds some information about the retrieval.
-     * @param[out] status will be the status of the call.
-     * @param[out] outConfig will be the current configuration.
+     * @param[in] index Type of the configuration to retrieve.
+     * @param[in] inConfig Information about the retrieval.
+     * @param[out] status Status of the call.
+     * @param[out] outConfig Current configuration.
      *
      * @see OMX_GetConfig() in the OpenMax IL standard.
      */
     getConfig(
             uint32_t index,
-            Bytes inConfig // TODO: describe structure better or point at standard
+            Bytes inConfig
         ) generates (
             Status status,
-            Bytes outConfig // TODO: describe structure better or point at standard
+            Bytes outConfig
         );
 
     /**
      * Change a configuration of the node.
      *
-     * @param[in] index indicates the type of the configuration to change.
-     * @param[in] config holds the new configuration.
-     * @param[out] status will be the status of the call.
+     * @param[in] index Type of the configuration to change.
+     * @param[in] config New configuration.
+     * @param[out] status Status of the call.
      *
      * @see OMX_SetConfig() in the OpenMax IL standard.
      */
     setConfig(
             uint32_t index,
-            Bytes config // TODO: describe structure better or point at standard
+            Bytes config
         ) generates (
             Status status
         );
@@ -129,8 +129,9 @@
     /**
      * Set the mode of a port on the node.
      *
-     * @param[in] portIndex is the index of the port.
-     * @param[in] mode is the target mode on the specified port.
+     * @param[in] portIndex Index of the port.
+     * @param[in] mode Target mode on the specified port.
+     * @param[out] status Status of the call.
      */
     setPortMode(
             uint32_t portIndex,
@@ -143,11 +144,11 @@
      * Prepare a port for adaptive playback. This is based on the extension
      * "OMX.google.android.index.prepareForAdaptivePlayback".
      *
-     * @param[in] portIndex is the index of the port.
-     * @param[in] enable indicates whether adaptive playback is enabled or not.
-     * @param[in] maxFrameWidth specifies the maximum frame width.
-     * @param[in] maxFrameHeight specifies the maximum frame height.
-     * @param[out] status status will be the status of the call.
+     * @param[in] portIndex Index of the port.
+     * @param[in] enable Whether the adaptive playback is enabled or not.
+     * @param[in] maxFrameWidth Maximum frame width.
+     * @param[in] maxFrameHeight Maximum frame height.
+     * @param[out] status Status of the call.
      */
     prepareForAdaptivePlayback(
             uint32_t portIndex,
@@ -162,13 +163,12 @@
      * Configure a port for a tunneled playback mode. This is based on the
      * extension "OMX.google.android.index.configureVideoTunnelMode".
      *
-     * @param[in] portIndex is the index of the port.
-     * @param[in] tunneled indicates whether the tunneled mode is used or not.
-     * @param[in] audioHwSync is the HW SYNC ID of the audio HAL output stream
-     * to sync the video with.
-     * @param[out] status will be the status of the call.
-     * @param[out] sidebandHandle will contain the codec-allocated sideband
-     * window handle.
+     * @param[in] portIndex Index of the port.
+     * @param[in] tunneled Whether the tunneled mode is used or not.
+     * @param[in] audioHwSync HW SYNC ID of the audio HAL output stream to sync
+     * the video with.
+     * @param[out] status Status of the call.
+     * @param[out] sidebandHandle Codec-allocated sideband window handle.
      */
     configureVideoTunnelMode(
             uint32_t portIndex,
@@ -183,23 +183,23 @@
      * Retrieve the buffer usage on a port. This is based on the extension
      * "OMX.google.android.index.getAndroidNativeBufferUsage".
      *
-     * @param[in] portIndex is the index of the port.
-     * @param[out] status will be the status of the call.
-     * @param[out] usage will be the usage.
+     * @param[in] portIndex Index of the port.
+     * @param[out] status Status of the call.
+     * @param[out] usage Current graphic buffer usage.
      */
     getGraphicBufferUsage(
             uint32_t portIndex
         ) generates (
             Status status,
-            uint32_t usage // TODO: Ask graphics team to define an enum.
+            uint32_t usage
         );
 
     /**
      * Set up a listener to events related to the input surface.
      *
-     * @param[in] bufferSource is the listener object that implements
+     * @param[in] bufferSource Listener object that implements
      * IOmxBufferSource.
-     * @param[out] status will be the status of the call.
+     * @param[out] status Status of the call.
      *
      * @see IOmxBufferSource.
      */
@@ -212,13 +212,12 @@
     /**
      * Allocate an opaque buffer on a port as a native handle.
      *
-     * @param[in] portIndex is the index of the port.
-     * @param[in] size is the desired size of the buffer.
-     * @param[out] status will be the status of the call.
-     * @param[out] buffer will be the id of the allocated buffer, which will be
-     * needed in some other buffer-related function calls.
-     * @param[out] nativeHandle will be the native handle of the allocated
-     * buffer.
+     * @param[in] portIndex Index of the port.
+     * @param[in] size Desired size of the buffer.
+     * @param[out] status Status of the call.
+     * @param[out] buffer Id of the allocated buffer, which will be needed in
+     * other buffer-related functions.
+     * @param[out] nativeHandle Native handle of the allocated buffer.
      *
      * @see OMX_AllocateBuffer() in the OpenMax IL standard.
      */
@@ -234,11 +233,11 @@
     /**
      * Assign a buffer to a port.
      *
-     * @param[in] portIndex is the index of the port.
-     * @param[in] omxBuffer is the buffer to be assigned to the port.
-     * @param[out] status will be the status of the call.
-     * @param[out] buffer will be the id of the assigned buffer, which will be
-     * needed in some other buffer-related function calls.
+     * @param[in] portIndex Index of the port.
+     * @param[in] omxBuffer Buffer to be assigned to the port.
+     * @param[out] status Status of the call.
+     * @param[out] buffer Id of the assigned buffer, which will be needed in
+     * other buffer-related functions.
      *
      * @see OMX_UseBuffer() in the OpenMax IL standard.
      */
@@ -254,9 +253,9 @@
      * Free a buffer previously assigned to a port by allocateSecureBuffer() or
      * useBuffer().
      *
-     * @param[in] portIndex is the index of the port.
-     * @param[in] buffer is the id of the buffer to be freed.
-     * @param[out] status will be the status of the call.
+     * @param[in] portIndex Index of the port.
+     * @param[in] buffer Id of the buffer to be freed.
+     * @param[out] status Status of the call.
      *
      * @see OMX_FreeBuffer() in the OpenMax IL standard.
      */
@@ -276,10 +275,10 @@
      * the new buffer passed in via \p omxBuffer before OMX_FillThisBuffer() is
      * called. Otherwise, \p omxBuffer is not used.
      *
-     * @param[in] buffer is the id of the buffer to fill.
-     * @param[in] omxBuffer points to the new buffer in metadata mode.
-     * @param[in] fence is the fence to wait for (if not null).
-     * @param[out] status is the status of the call.
+     * @param[in] buffer Id of the buffer to fill.
+     * @param[in] omxBuffer New buffer information (in metadata mode).
+     * @param[in] fence Fence to wait for (if not null).
+     * @param[out] status Status of the call.
      *
      * @see OMX_FillThisBuffer() in the OpenMax IL standard.
      */
@@ -300,21 +299,19 @@
      * the new buffer passed in via \p omxBuffer before OMX_EmptyThisBuffer() is
      * called. Otherwise, \p omxBuffer is not used.
      *
-     * @param[in] buffer is the id of the buffer to fill.
-     * @param[in] omxBuffer points to the new buffer in metadata mode.
-     * @param[in] flags is put into the header information that is passed to
-     * OMX_EmptyBuffer().
-     * @param[in] timestampUs is put into the header information that is passed
-     * to OMX_EmptyBuffer().
-     * @param[in] fence is the fence to wait for (if not null).
-     * @param[out] status is the status of the call.
+     * @param[in] buffer Id of the buffer to fill.
+     * @param[in] omxBuffer New buffer information (in metadata mode).
+     * @param[in] flags Flags to be passed to OMX_EmptyBuffer().
+     * @param[in] timestampUs Timestamp OMX_EmptyBuffer().
+     * @param[in] fence Fence to wait for (if not null).
+     * @param[out] status Status of the call.
      *
      * @see OMX_EmptyThisBuffer() in the OpenMax IL standard.
      */
     emptyBuffer(
             BufferId buffer,
             CodecBuffer omxBuffer,
-            uint32_t flags, // TODO: describe structure better or point at standard
+            uint32_t flags,
             uint64_t timestampUs,
             Fence fence
         ) generates (
@@ -324,9 +321,9 @@
     /**
      * Request the node to translate an extension string to an index.
      *
-     * @param[in] parameterName is the requested extension string.
-     * @param[out] status is the status of the call.
-     * @param[out] index is the translated index.
+     * @param[in] parameterName Requested extension string.
+     * @param[out] status Status of the call.
+     * @param[out] index Translated index.
      *
      * @see OMX_GetExtensionIndex() in the OpenMax IL standard.
      */
@@ -343,8 +340,8 @@
      * receive the message in batches by the callback
      * IOmxObserver::onMessages().
      *
-     * @param[in] msg is the message to send.
-     * @param[out] status is the status of the call.
+     * @param[in] msg Message to send.
+     * @param[out] status Status of the call.
      *
      * @see IOmxObserver::onMessages().
      */
@@ -354,5 +351,15 @@
             Status status
         );
 
+    /**
+     * Set quirks.
+     *
+     * @param[in] quirks Quirks for the component, generally obtained from
+     * MediaCodecList::getQuirksFor().
+     */
+    oneway setQuirks(
+            uint32_t quirks
+        );
+
 };
 
diff --git a/media/omx/1.0/IOmxProducerListener.hal b/media/omx/1.0/IOmxProducerListener.hal
new file mode 100644
index 0000000..7fde93b
--- /dev/null
+++ b/media/omx/1.0/IOmxProducerListener.hal
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2016 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 android.hardware.media.omx@1.0;
+
+/**
+ * Ref: frameworks/native/include/gui/IProducerListener.h: IProducerListener
+ * This is a wrapper/wrapped HAL interface for the actual binder interface.
+ */
+interface IOmxProducerListener {
+    oneway onBufferReleased();
+    needsReleaseNotify() generates (bool result);
+};
+
diff --git a/media/omx/1.0/types.hal b/media/omx/1.0/types.hal
index ccb2ddf..5413344 100644
--- a/media/omx/1.0/types.hal
+++ b/media/omx/1.0/types.hal
@@ -33,10 +33,18 @@
     NO_ERROR                = 0,
 
     NAME_NOT_FOUND          = -2,
+    WOULD_BLOCK             = -11,
     NO_MEMORY               = -12,
+    NO_INIT                 = -19,
     BAD_VALUE               = -22,
+    DEAD_OBJECT             = -32,
+    INVALID_OPERATION       = -38,
+    TIMED_OUT               = -110,
     ERROR_UNSUPPORTED       = -1010,
     UNKNOWN_ERROR           = -2147483648,
+
+    BUFFER_NEEDS_REALLOCATION = 0x1,
+    RELEASE_ALL_BUFFERS       = 0x2,
 };
 
 /**
@@ -135,10 +143,11 @@
         PRESET,
         SHARED_MEM,
         ANW_BUFFER,
-        NATIVE_HANDLE
+        NATIVE_HANDLE,
     };
 
     struct PresetAttributes {
+        uint32_t rangeOffset;
         uint32_t rangeLength;
     };
 
@@ -147,7 +156,7 @@
         PresetAttributes preset;
 
         // if bufferType == SHARED_MEM
-        SharedMemoryAttributes sharedMem;
+        // No additional attributes.
 
         // if bufferType == ANW_BUFFER
         AnwBufferAttributes anwBuffer;
@@ -167,14 +176,18 @@
     Attributes attr;
 
     /**
-     * \p nativeHandle is used only for types SHARED_MEM, ANW_BUFFER and
-     * NATIVE_HANDLE.
+     * Used only for types ANW_BUFFER and NATIVE_HANDLE.
      *
      * (A native handle cannot be put into a union as HIDL currently does not
      * support discriminated unions.)
      */
     handle nativeHandle;
 
+    /**
+     * Used only for type SHARED_MEM.
+     */
+    memory sharedMemory;
+
 };
 
 /**
diff --git a/memtrack/1.0/default/Memtrack.cpp b/memtrack/1.0/default/Memtrack.cpp
index cc2d341..33a6906 100644
--- a/memtrack/1.0/default/Memtrack.cpp
+++ b/memtrack/1.0/default/Memtrack.cpp
@@ -73,19 +73,19 @@
 }
 
 
-IMemtrack* HIDL_FETCH_IMemtrack(const char* name) {
+IMemtrack* HIDL_FETCH_IMemtrack(const char* /* name */) {
     const hw_module_t* hw_module = nullptr;
     const memtrack_module_t* memtrack_module = nullptr;
-    int err = hw_get_module(name, &hw_module);
+    int err = hw_get_module(MEMTRACK_HARDWARE_MODULE_ID, &hw_module);
     if (err) {
-        ALOGE ("hw_get_module %s failed: %d", name, err);
+        ALOGE ("hw_get_module %s failed: %d", MEMTRACK_HARDWARE_MODULE_ID, err);
         return nullptr;
     }
 
     if (!hw_module->methods || !hw_module->methods->open) {
         memtrack_module = reinterpret_cast<const memtrack_module_t*>(hw_module);
     } else {
-        err = hw_module->methods->open(hw_module, name,
+        err = hw_module->methods->open(hw_module, MEMTRACK_HARDWARE_MODULE_ID,
                 reinterpret_cast<hw_device_t**>(const_cast<memtrack_module_t**>(&memtrack_module)));
         if (err) {
             ALOGE("Passthrough failed to load legacy HAL.");
diff --git a/memtrack/1.0/default/service.cpp b/memtrack/1.0/default/service.cpp
index f705b15..f079743 100644
--- a/memtrack/1.0/default/service.cpp
+++ b/memtrack/1.0/default/service.cpp
@@ -23,5 +23,5 @@
 using android::hardware::defaultPassthroughServiceImplementation;
 
 int main() {
-    return defaultPassthroughServiceImplementation<IMemtrack>("memtrack");
+    return defaultPassthroughServiceImplementation<IMemtrack>();
 }
diff --git a/memtrack/1.0/vts/Android.mk b/memtrack/1.0/vts/Android.mk
index 397f946..fbb5951 100644
--- a/memtrack/1.0/vts/Android.mk
+++ b/memtrack/1.0/vts/Android.mk
@@ -16,6 +16,4 @@
 
 LOCAL_PATH := $(call my-dir)
 
-include $(call all-subdir-makefiles)
-
-include $(LOCAL_PATH)/functional/vts/testcases/hal/memtrack/hidl/target/Android.mk
+include $(LOCAL_PATH)/functional/vts/testcases/hal/memtrack/hidl/Android.mk
diff --git a/memtrack/1.0/vts/functional/memtrack_hidl_hal_test.cpp b/memtrack/1.0/vts/functional/memtrack_hidl_hal_test.cpp
index 597b5da..a4b4fa9 100644
--- a/memtrack/1.0/vts/functional/memtrack_hidl_hal_test.cpp
+++ b/memtrack/1.0/vts/functional/memtrack_hidl_hal_test.cpp
@@ -37,7 +37,7 @@
 class MemtrackHidlTest : public ::testing::Test {
  public:
   virtual void SetUp() override {
-    memtrack = IMemtrack::getService("memtrack");
+    memtrack = IMemtrack::getService();
     ASSERT_NE(memtrack, nullptr);
   }
 
diff --git a/memtrack/1.0/vts/functional/vts/testcases/hal/memtrack/hidl/Android.mk b/memtrack/1.0/vts/functional/vts/testcases/hal/memtrack/hidl/Android.mk
new file mode 100644
index 0000000..f9e3276
--- /dev/null
+++ b/memtrack/1.0/vts/functional/vts/testcases/hal/memtrack/hidl/Android.mk
@@ -0,0 +1,19 @@
+#
+# Copyright (C) 2016 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(call all-subdir-makefiles)
diff --git a/nfc/1.0/vts/functional/nfc_hidl_hal_test.cpp b/nfc/1.0/vts/functional/nfc_hidl_hal_test.cpp
index a50d88f..a0c5f1a 100644
--- a/nfc/1.0/vts/functional/nfc_hidl_hal_test.cpp
+++ b/nfc/1.0/vts/functional/nfc_hidl_hal_test.cpp
@@ -40,6 +40,8 @@
 /* NCI Commands */
 #define CORE_RESET_CMD \
   { 0x20, 0x00, 0x01, 0x00 }
+#define CORE_RESET_CMD_CONFIG_RESET \
+  { 0x20, 0x00, 0x01, 0x01 }
 #define CORE_CONN_CREATE_CMD \
   { 0x20, 0x04, 0x02, 0x01, 0x00 }
 #define INVALID_COMMAND \
@@ -166,7 +168,7 @@
  * WriteCoreReset:
  * Sends CORE_RESET_CMD
  * Waits for CORE_RESET_RSP
- * Checks the status and the version number
+ * Checks the status, version number and configuration status
  */
 TEST_F(NfcHidlTest, WriteCoreReset) {
   std::vector<uint8_t> cmd = CORE_RESET_CMD;
@@ -178,6 +180,26 @@
   EXPECT_EQ(6ul, last_data_[0].size());
   EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
   EXPECT_GE(VERSION, last_data_[0][4]);
+  EXPECT_EQ(0ul, last_data_[0][5]);
+}
+
+/*
+ * WriteCoreResetConfigReset:
+ * Sends CORE_RESET_CMD_CONFIG_RESET
+ * Waits for CORE_RESET_RSP
+ * Checks the status, version number and configuration status
+ */
+TEST_F(NfcHidlTest, WriteCoreResetConfigReset) {
+  std::vector<uint8_t> cmd = CORE_RESET_CMD_CONFIG_RESET;
+  NfcData data = cmd;
+  EXPECT_EQ(data.size(), nfc_->write(data));
+  // Wait for CORE_RESET_RSP
+  EXPECT_EQ(std::cv_status::no_timeout, wait());
+  EXPECT_EQ(1ul, last_data_.size());
+  EXPECT_EQ(6ul, last_data_[0].size());
+  EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
+  EXPECT_GE(VERSION, last_data_[0][4]);
+  EXPECT_EQ(1ul, last_data_[0][5]);
 }
 
 /*
@@ -273,14 +295,18 @@
     EXPECT_EQ(std::cv_status::no_timeout, wait());
     // Check if the same data was recieved back
     EXPECT_EQ(2ul, last_data_.size());
-    EXPECT_EQ(data.size(), last_data_[0].size());
+
+    /* It is possible that CORE_CONN_CREDITS_NTF is received before data,
+     * Find the order and do further checks depending on that */
+    uint8_t data_index = last_data_[0].size() == data.size() ? 0 : 1;
+    EXPECT_EQ(data.size(), last_data_[data_index].size());
     for (size_t i = 0; i < data.size(); i++) {
-      EXPECT_EQ(data[i], last_data_[0][i]);
+      EXPECT_EQ(data[i], last_data_[data_index][i]);
     }
 
-    EXPECT_EQ(6ul, last_data_[1].size());
+    EXPECT_EQ(6ul, last_data_[!data_index].size());
     // Check if the credit is refilled to 1
-    EXPECT_EQ(1, last_data_[1][5]);
+    EXPECT_EQ(1, last_data_[!data_index][5]);
   }
 }
 
diff --git a/nfc/1.0/vts/functional/vts/testcases/hal/nfc/hidl/target_profiling/AndroidTest.xml b/nfc/1.0/vts/functional/vts/testcases/hal/nfc/hidl/target_profiling/AndroidTest.xml
index 42c7e22..3b570f9 100644
--- a/nfc/1.0/vts/functional/vts/testcases/hal/nfc/hidl/target_profiling/AndroidTest.xml
+++ b/nfc/1.0/vts/functional/vts/testcases/hal/nfc/hidl/target_profiling/AndroidTest.xml
@@ -25,7 +25,7 @@
             _64bit::DATA/nativetest64/nfc_hidl_hal_test/nfc_hidl_hal_test,
             "/>
         <option name="binary-test-type" value="gtest" />
-        <option name="test-timeout" value="20m" />
+        <option name="test-timeout" value="25m" />
     <option name="enable-profiling" value="true" />
     </test>
 </configuration>
diff --git a/radio/1.0/IRadioIndication.hal b/radio/1.0/IRadioIndication.hal
index 79ebf30..fb8666f 100644
--- a/radio/1.0/IRadioIndication.hal
+++ b/radio/1.0/IRadioIndication.hal
@@ -342,10 +342,6 @@
    oneway exitEmergencyCallbackMode(RadioIndicationType type);
 
    /*
-    * TODO(Consider moving this to separate interface. Client will receive this function with an
-    * IRadioResponse interface so that all requests in that IRadioResponse will fail before
-    * rilConnected() is received)
-    *
     * Indicates the ril connects and returns the version
     *
     * @param type Type of radio indication
@@ -472,4 +468,4 @@
     *        restart" that explains the cause of the modem restart
     */
    oneway modemReset(RadioIndicationType type, string reason);
-};
\ No newline at end of file
+};
diff --git a/radio/1.0/types.hal b/radio/1.0/types.hal
index 593dc92..c0a6475 100644
--- a/radio/1.0/types.hal
+++ b/radio/1.0/types.hal
@@ -117,9 +117,6 @@
     ABORTED = 65,                         // Operation aborted
     INVALID_RESPONSE = 66,                // Response from vendor had invalid data
 
-    // TODO(May be moved to vendor HAL extension)
-    // OEM specific error codes. To be used by OEM when they don't want to reveal
-    // specific error codes which would be replaced by Generic failure.
     OEM_ERROR_1 = 501,
     OEM_ERROR_2 = 502,
     OEM_ERROR_3 = 503,
@@ -462,9 +459,6 @@
     AUTH_FAILURE_ON_EMERGENCY_CALL = 0x7A,
     OEM_DCFAILCAUSE_1 = 0x1001,
 
-    // OEM specific error codes. To be used by OEMs when they don't want to
-    // reveal error code which would be replaced by PDP_FAIL_ERROR_UNSPECIFIED
-    // TODO(May be moved to vendor HAL extension)
     OEM_DCFAILCAUSE_2 = 0x1002,
     OEM_DCFAILCAUSE_3 = 0x1003,
     OEM_DCFAILCAUSE_4 = 0x1004,
diff --git a/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/AndroidTest.xml b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/AndroidTest.xml
index 9339165..d450315 100644
--- a/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/AndroidTest.xml
+++ b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/AndroidTest.xml
@@ -26,7 +26,8 @@
             "/>
         <option name="test-config-path" value="vts/testcases/hal/soundtrigger/hidl/target/HalSoundTriggerHidlTargetBasicTest.config" />
         <option name="binary-test-type" value="hal_hidl_gtest" />
-        <option name="precondition-file-path-prefix" value="*/lib/hw/sound_trigger.primary." />
+        <option name="precondition-file-path-prefix" value="/*/lib/hw/sound_trigger.primary." />
+        <option name="skip-on-64bit-abi" value="true" />
         <option name="test-timeout" value="1m" />
     </test>
 </configuration>
diff --git a/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target_profiling/AndroidTest.xml b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target_profiling/AndroidTest.xml
index e95a406..cd95b5f 100644
--- a/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target_profiling/AndroidTest.xml
+++ b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target_profiling/AndroidTest.xml
@@ -19,12 +19,13 @@
     </target_preparer>
     <target_preparer class="com.android.tradefed.targetprep.VtsPythonVirtualenvPreparer" />
     <test class="com.android.tradefed.testtype.VtsMultiDeviceTest">
-        <option name="test-module-name" value="HalSoundTriggerHidlTargetBasicTest" />
+        <option name="test-module-name" value="HalSoundTriggerHidlTargetBasicProfilingTest" />
         <option name="binary-test-sources" value="
             _32bit::DATA/nativetest/soundtrigger_hidl_hal_test/soundtrigger_hidl_hal_test,
             _64bit::DATA/nativetest64/soundtrigger_hidl_hal_test/soundtrigger_hidl_hal_test,
             "/>
-        <option name="binary-test-type" value="gtest" />
+        <option name="binary-test-type" value="hal_hidl_gtest" />
+        <option name="precondition-file-path-prefix" value="*/lib/hw/sound_trigger.primary." />
         <option name="test-timeout" value="1m" />
         <option name="enable-profiling" value="true" />
     </test>
diff --git a/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp b/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp
index d922169..3c887c8 100644
--- a/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp
+++ b/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp
@@ -50,7 +50,7 @@
 class ThermalHidlTest : public ::testing::Test {
  public:
   virtual void SetUp() override {
-    thermal_ = IThermal::getService(THERMAL_SERVICE_NAME, false);
+    thermal_ = IThermal::getService(THERMAL_SERVICE_NAME);
     ASSERT_NE(thermal_, nullptr);
     baseSize_ = 0;
     names_.clear();
diff --git a/tv/Android.bp b/tv/Android.bp
index 5ad82f4..ac54910 100644
--- a/tv/Android.bp
+++ b/tv/Android.bp
@@ -2,4 +2,5 @@
 subdirs = [
     "cec/1.0",
     "input/1.0",
+    "input/1.0/vts/functional",
 ]
diff --git a/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/Android.mk b/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/Android.mk
index ece38d7..14a57a6 100644
--- a/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/Android.mk
+++ b/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/Android.mk
@@ -16,8 +16,6 @@
 
 LOCAL_PATH := $(call my-dir)
 
-include $(call all-subdir-makefiles)
-
 include $(CLEAR_VARS)
 
 LOCAL_MODULE := TvCecHidlTest
diff --git a/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/TvCecHidlTest.py b/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/TvCecHidlTest.py
index 5f7aaf1..7cb1b06 100644
--- a/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/TvCecHidlTest.py
+++ b/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/TvCecHidlTest.py
@@ -21,8 +21,10 @@
 from vts.runners.host import asserts
 from vts.runners.host import base_test_with_webdb
 from vts.runners.host import const
+from vts.runners.host import keys
 from vts.runners.host import test_runner
 from vts.utils.python.controllers import android_device
+from vts.utils.python.coverage import coverage_utils
 
 
 class TvCecHidlTest(base_test_with_webdb.BaseTestWithWebDbClass):
@@ -38,6 +40,9 @@
         self.dut.shell.one.Execute(
             "setprop vts.hal.vts.hidl.get_stub true")
 
+        if getattr(self, keys.ConfigKeys.IKEY_ENABLE_COVERAGE, False):
+            coverage_utils.InitializeDeviceCoverage(self.dut)
+
         self.dut.hal.InitHidlHal(
             target_type="tv_cec",
             target_basepaths=self.dut.libPaths,
@@ -47,6 +52,11 @@
             hw_binder_service_name="cec-hal-1-0",
             bits=64 if self.dut.is64Bit else 32)
 
+    def tearDownClass(self):
+        """To be executed when all test cases are finished."""
+        if getattr(self, keys.ConfigKeys.IKEY_ENABLE_COVERAGE, False):
+            self.SetCoverageData(coverage_utils.GetGcdaDict(self.dut))
+
     def testGetCecVersion1(self):
         """A simple test case which queries the cec version."""
         logging.info('DIR HAL %s', dir(self.dut.hal))
diff --git a/tv/input/1.0/vts/functional/Android.bp b/tv/input/1.0/vts/functional/Android.bp
new file mode 100644
index 0000000..979eb99
--- /dev/null
+++ b/tv/input/1.0/vts/functional/Android.bp
@@ -0,0 +1,43 @@
+//
+// Copyright (C) 2017 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.
+//
+
+cc_test {
+    name: "tv_input_hidl_hal_test",
+    gtest: true,
+    srcs: ["tv_input_hidl_hal_test.cpp"],
+    shared_libs: [
+        "libbase",
+        "liblog",
+        "libcutils",
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libnativehelper",
+        "libutils",
+        "android.hardware.tv.input@1.0",
+    ],
+    static_libs: ["libgtest"],
+    cflags: [
+// TODO: add --coverage when the segfault issue is fixed.
+//        "--coverage",
+        "-O0",
+        "-g",
+    ],
+//    ldflags: [
+//        "--coverage"
+//    ]
+}
+
diff --git a/tv/input/1.0/vts/functional/tv_input_hidl_hal_test.cpp b/tv/input/1.0/vts/functional/tv_input_hidl_hal_test.cpp
new file mode 100644
index 0000000..1279ecd
--- /dev/null
+++ b/tv/input/1.0/vts/functional/tv_input_hidl_hal_test.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#define LOG_TAG "tv_input_hidl_hal_test"
+#include <android-base/logging.h>
+
+#include <android/hardware/tv/input/1.0/types.h>
+#include <android/hardware/tv/input/1.0/ITvInput.h>
+#include <android/hardware/tv/input/1.0/ITvInputCallback.h>
+
+#include <gtest/gtest.h>
+
+using ::android::hardware::tv::input::V1_0::ITvInput;
+using ::android::hardware::tv::input::V1_0::ITvInputCallback;
+using ::android::hardware::tv::input::V1_0::Result;
+using ::android::hardware::tv::input::V1_0::TvInputType;
+using ::android::hardware::tv::input::V1_0::TvInputDeviceInfo;
+using ::android::hardware::tv::input::V1_0::TvInputEventType;
+using ::android::hardware::tv::input::V1_0::TvInputEvent;
+using ::android::hardware::tv::input::V1_0::TvStreamConfig;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::sp;
+
+
+// Simple ITvInputCallback used as part of testing.
+class TvInputCallback : public ITvInputCallback {
+  public:
+   TvInputCallback() {};
+
+   virtual ~TvInputCallback() = default;
+
+   // notify callback function - currently no-op.
+   // TODO: modify it later.
+   Return<void> notify(const TvInputEvent& event) override {
+     return Void();
+   };
+};
+
+
+// The main test class for TV Input HIDL HAL.
+class TvInputHidlTest : public ::testing::Test {
+ public:
+  virtual void SetUp() override {
+    // currently test passthrough mode only
+    tv_input = ITvInput::getService();
+    ASSERT_NE(tv_input, nullptr);
+
+    tv_input_callback = new TvInputCallback();
+    ASSERT_NE(tv_input_callback, nullptr);
+  }
+
+  virtual void TearDown() override {}
+
+  sp<ITvInput> tv_input;
+  sp<ITvInputCallback> tv_input_callback;
+};
+
+
+// A class for test environment setup.
+class TvInputHidlEnvironment : public ::testing::Environment {
+ public:
+  virtual void SetUp() {}
+  virtual void TearDown() {}
+
+ private:
+};
+
+// TODO: remove this test and add meaningful tests.
+TEST_F(TvInputHidlTest, DummyTest) {
+  EXPECT_NE(tv_input, nullptr);
+}
+
+int main(int argc, char **argv) {
+  ::testing::AddGlobalTestEnvironment(new TvInputHidlEnvironment);
+  ::testing::InitGoogleTest(&argc, argv);
+  int status = RUN_ALL_TESTS();
+  ALOGI("Test result = %d", status);
+  return status;
+}
+
diff --git a/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/Android.mk b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/Android.mk
index 2703d8c..1757bfe 100644
--- a/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/Android.mk
+++ b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/Android.mk
@@ -16,8 +16,6 @@
 
 LOCAL_PATH := $(call my-dir)
 
-include $(call all-subdir-makefiles)
-
 include $(CLEAR_VARS)
 
 LOCAL_MODULE := TvInputHidlTest
diff --git a/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/TvInputHidlTest.py b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/TvInputHidlTest.py
index b5becd6..828b9dd 100644
--- a/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/TvInputHidlTest.py
+++ b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/TvInputHidlTest.py
@@ -20,8 +20,10 @@
 from vts.runners.host import asserts
 from vts.runners.host import base_test_with_webdb
 from vts.runners.host import const
+from vts.runners.host import keys
 from vts.runners.host import test_runner
 from vts.utils.python.controllers import android_device
+from vts.utils.python.coverage import coverage_utils
 
 
 class TvInputHidlTest(base_test_with_webdb.BaseTestWithWebDbClass):
@@ -34,6 +36,9 @@
         self.dut.shell.InvokeTerminal("one")
         self.dut.shell.one.Execute("setenforce 0")  # SELinux permissive mode
 
+        if getattr(self, keys.ConfigKeys.IKEY_ENABLE_COVERAGE, False):
+            coverage_utils.InitializeDeviceCoverage(self.dut)
+
         self.dut.hal.InitHidlHal(target_type="tv_input",
                                  target_basepaths=["/system/lib64"],
                                  target_version=1.0,
@@ -43,6 +48,11 @@
 
         self.dut.shell.InvokeTerminal("one")
 
+    def tearDownClass(self):
+        """To be executed when all test cases are finished."""
+        if getattr(self, keys.ConfigKeys.IKEY_ENABLE_COVERAGE, False):
+            self.SetCoverageData(coverage_utils.GetGcdaDict(self.dut))
+
     def testGetStreamConfigurations(self):
         configs = self.dut.hal.tv_input.getStreamConfigurations(0)
         logging.info('return value of getStreamConfigurations(0): %s', configs)
diff --git a/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/target/Android.mk b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/target/Android.mk
new file mode 100644
index 0000000..153da0b
--- /dev/null
+++ b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/target/Android.mk
@@ -0,0 +1,26 @@
+#
+# Copyright (C) 2017 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(call all-subdir-makefiles)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := HalTvInputHidlTargetTest
+VTS_CONFIG_SRC_DIR := testcases/hal/tv_input/hidl/target
+include test/vts/tools/build/Android.host_config.mk
+
diff --git a/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/target/AndroidTest.xml b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/target/AndroidTest.xml
new file mode 100644
index 0000000..4f98940
--- /dev/null
+++ b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/target/AndroidTest.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+<configuration description="Config for VTS TV Input HIDL HAL's target-side test cases">
+    <target_preparer class="com.android.compatibility.common.tradefed.targetprep.VtsFilePusher">
+        <option name="push-group" value="HidlHalTest.push" />
+    </target_preparer>
+    <target_preparer class="com.android.tradefed.targetprep.VtsPythonVirtualenvPreparer" />
+    <test class="com.android.tradefed.testtype.VtsMultiDeviceTest">
+        <option name="test-module-name" value="HalTvInputHidlTargetTest"/>
+        <option name="binary-test-sources" value="
+            _32bit::DATA/nativetest/tv_input_hidl_hal_test/tv_input_hidl_hal_test,
+            "/>
+        <option name="binary-test-type" value="gtest" />
+        <option name="test-timeout" value="1m" />
+    </test>
+</configuration>
+
diff --git a/vehicle/2.0/Android.mk b/vehicle/2.0/Android.mk
index 9544960..1dd0f45 100644
--- a/vehicle/2.0/Android.mk
+++ b/vehicle/2.0/Android.mk
@@ -1081,6 +1081,25 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build types.hal (Wheel)
+#
+GEN := $(intermediates)/android/hardware/vehicle/V2_0/Wheel.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.hal
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+        -Ljava \
+        -randroid.hardware:hardware/interfaces \
+        -randroid.hidl:system/libhidl/transport \
+        android.hardware.vehicle@2.0::types.Wheel
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build IVehicle.hal
 #
 GEN := $(intermediates)/android/hardware/vehicle/V2_0/IVehicle.java
@@ -2205,6 +2224,25 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build types.hal (Wheel)
+#
+GEN := $(intermediates)/android/hardware/vehicle/V2_0/Wheel.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.hal
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+        -Ljava \
+        -randroid.hardware:hardware/interfaces \
+        -randroid.hidl:system/libhidl/transport \
+        android.hardware.vehicle@2.0::types.Wheel
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build IVehicle.hal
 #
 GEN := $(intermediates)/android/hardware/vehicle/V2_0/IVehicle.java
diff --git a/vehicle/2.0/default/tests/VehicleHalManager_test.cpp b/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
index 4a20ea5..dc32252 100644
--- a/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
+++ b/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
@@ -67,7 +67,7 @@
                     pValue = getValuePool()->obtainFloat(42.42);
                 }
                 break;
-            case VehicleProperty::VEHICLE_MAPS_DATA_SERVICE:
+            case VehicleProperty::VEHICLE_MAP_SERVICE:
                 pValue = getValuePool()->obtainComplex();
                 pValue->value.int32Values = hidl_vec<int32_t> { 10, 20 };
                 pValue->value.int64Values = hidl_vec<int64_t> { 30, 40 };
@@ -317,10 +317,10 @@
 }
 
 TEST_F(VehicleHalManagerTest, get_Complex) {
-    invokeGet(VehicleProperty::VEHICLE_MAPS_DATA_SERVICE, 0);
+    invokeGet(VehicleProperty::VEHICLE_MAP_SERVICE, 0);
 
     ASSERT_EQ(StatusCode::OK, actualStatusCode);
-    ASSERT_EQ(VehicleProperty::VEHICLE_MAPS_DATA_SERVICE, actualValue.prop);
+    ASSERT_EQ(VehicleProperty::VEHICLE_MAP_SERVICE, actualValue.prop);
 
     ASSERT_EQ(3, actualValue.value.bytes.size());
     ASSERT_EQ(1, actualValue.value.bytes[0]);
diff --git a/vehicle/2.0/default/tests/VehicleHalTestUtils.h b/vehicle/2.0/default/tests/VehicleHalTestUtils.h
index b6a5c31..538c022 100644
--- a/vehicle/2.0/default/tests/VehicleHalTestUtils.h
+++ b/vehicle/2.0/default/tests/VehicleHalTestUtils.h
@@ -107,7 +107,7 @@
 
     // Complex data type.
     {
-        .prop = VehicleProperty::VEHICLE_MAPS_DATA_SERVICE,
+        .prop = VehicleProperty::VEHICLE_MAP_SERVICE,
         .access = VehiclePropertyAccess::READ_WRITE,
         .changeMode = VehiclePropertyChangeMode::ON_CHANGE
     }
diff --git a/vehicle/2.0/types.hal b/vehicle/2.0/types.hal
index a9b706d..9fda4fd 100644
--- a/vehicle/2.0/types.hal
+++ b/vehicle/2.0/types.hal
@@ -226,6 +226,28 @@
         | VehicleArea:GLOBAL),
 
     /*
+     * Reports wheel rotational distance in meters since last wheel tick
+     * event
+     *
+     * The value is a vector each element represents distance for individual
+     * wheel in the following order: left front, right front, left rear,
+     * right rear. VehiclePropValue.timestamp must be correctly filled in.
+     *
+     * Vendors must specify wheels that support this sensor in
+     * VehiclePropConfig.configFlags. The format of this field is a bitset of
+     * values from Wheel enum.
+     *
+     * @change_mode VehiclePropertyChangeMode:ON_CHANGE|VehiclePropertyChangeMode:CONTINUOUS
+     * @access VehiclePropertyAccess:READ
+     * @unit VehicleUnit:METER
+     */
+    WHEEL_TICK = (
+        0x0306
+        | VehiclePropertyGroup:SYSTEM
+        | VehiclePropertyType:FLOAT_VEC
+        | VehicleArea:GLOBAL),
+
+    /*
      * Currently selected gear
      *
      * @change_mode VehiclePropertyChangeMode:ON_CHANGE
@@ -964,6 +986,7 @@
      *
      * @change_mode VehiclePropertyChangeMode:ON_CHANGE
      * @access VehiclePropertyAccess:READ_WRITE
+     */
     AUDIO_PARAMETERS = (
         0x907
         | VehiclePropertyGroup:SYSTEM
@@ -971,23 +994,44 @@
         | VehicleArea:GLOBAL),
 
     /*
-     * Index in int32Values for AP_POWER_STATE property.
+     * Property to control power state of application processor
+     *
+     * It is assumed that AP's power state is controller by separate power
+     * controller.
+     *
+     * For configuration information, VehiclePropConfig.configFlags can
+     * have bit flag combining values in VehicleApPowerStateConfigFlag.
+     *
+     * Value format for IVehicle#get / IVehicle#subscribe:
+     *   int32Values[0] : vehicle_ap_power_state_type
+     *   int32Values[1] : additional parameter relevant for each state,
+     *                    0 if not used.
+     * Value format for IVehicle#set:
+     *   int32Values[0] : vehicle_ap_power_state_set_type
+     *   int32Values[1] : additional parameter relevant for each request. should be 0 if not used.
+     *
+     * @change_mode VEHICLE_PROP_CHANGE_MODE_ON_CHANGE
+     * @access VEHICLE_PROP_ACCESS_READ_WRITE
      */
-    AP_POWER_STATE = (0x00000A00),
+    AP_POWER_STATE = (
+        0x0A00
+        | VehiclePropertyGroup:SYSTEM
+        | VehiclePropertyType:INT32_VEC
+        | VehicleArea:GLOBAL),
 
-  /*
-   * Property to represent brightness of the display. Some cars have single
-   * control for the brightness of all displays and this property is to share
-   * change in that control.
-   *
-   * If this is writable, android side can set this value when user changes
-   * display brightness from Settings. If this is read only, user may still
-   * change display brightness from Settings, but that will not be reflected
-   * to other displays.
-   *
-   * @change_mode VehiclePropertyChangeMode:ON_CHANGE
-   * @access VehiclePropertyAccess:READ_WRITE
-   */
+    /*
+     * Property to represent brightness of the display. Some cars have single
+     * control for the brightness of all displays and this property is to share
+     * change in that control.
+     *
+     * If this is writable, android side can set this value when user changes
+     * display brightness from Settings. If this is read only, user may still
+     * change display brightness from Settings, but that will not be reflected
+     * to other displays.
+     *
+     * @change_mode VehiclePropertyChangeMode:ON_CHANGE
+     * @access VehiclePropertyAccess:READ_WRITE
+     */
     DISPLAY_BRIGHTNESS = (
         0x0A01
         | VehiclePropertyGroup:SYSTEM
@@ -1713,12 +1757,20 @@
         | VehicleArea:GLOBAL),
 
     /*
-     * Vehicle Maps Data Service (VMDS) message
+     * Vehicle Maps Service (VMS) message
+     *
+     * This property uses COMPLEX data to communicate vms messages.
+     *
+     * Its contents are to be interpreted as follows:
+     * the indices defined in VmsMessageIntegerValuesIndex are to be used to
+     * read from int32Values;
+     * stringValue is a serialized VMS message as defined in the vms protocol
+     * which is opaque to the framework;
      *
      * @change_mode VehiclePropertyChangeMode:ON_CHANGE
      * @access VehiclePropertyAccess:READ_WRITE
      */
-    VEHICLE_MAPS_DATA_SERVICE = (
+    VEHICLE_MAP_SERVICE = (
         0x0C00
         | VehiclePropertyGroup:SYSTEM
         | VehiclePropertyType:COMPLEX
@@ -2744,6 +2796,15 @@
   NMHC_CATALYST_INCOMPLETE = 0x1 << 17,
 };
 
+enum Wheel : int32_t {
+    UNKNOWN = 0x0,
+
+    LEFT_FRONT = 0x1,
+    RIGHT_FRONT = 0x2,
+    LEFT_REAR = 0x4,
+    RIGHT_REAR = 0x8,
+};
+
 enum SecondaryAirStatus : int32_t {
   UPSTREAM = 1,
 
@@ -3043,3 +3104,32 @@
 
   VENDOR_START_INDEX = LAST_SYSTEM_INDEX + 1,
 };
+
+/*
+ * This enum lists the types of supported VMS messages.
+ */
+enum VmsMessageType : int32_t {
+  /* A client subscribes to a layer. */
+  SUBSCRIBE = 1,
+
+  /* A client unsubscribes from a layer. */
+  UNSUBSCRIBE = 2,
+
+  /* A client publishes a data packet. */
+  DATA = 3,
+};
+
+/*
+ * This enum provides the canonical mapping for VMS properties that have an
+ * integer value.
+ */
+enum VmsMessageIntegerValuesIndex : int32_t {
+  /* The message type as enumerated by VmsMessageType enum. */
+  VMS_MESSAGE_TYPE = 1,
+
+  /* The layer ID as defined in the vms protocol. */
+  VMS_LAYER_ID = 2,
+
+  /* The version of the VMS layer. */
+  VMS_LAYER_VERSION = 3,
+};
diff --git a/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py b/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py
index cd52abf..2c32836 100644
--- a/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py
+++ b/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py
@@ -21,9 +21,11 @@
 from vts.runners.host import asserts
 from vts.runners.host import base_test_with_webdb
 from vts.runners.host import const
+from vts.runners.host import keys
 from vts.runners.host import test_runner
 from vts.utils.python.controllers import android_device
 from vts.utils.python.profiling import profiling_utils
+from vts.utils.python.coverage import coverage_utils
 
 
 class VehicleHidlTest(base_test_with_webdb.BaseTestWithWebDbClass):
@@ -40,6 +42,9 @@
         system_uid = results[const.STDOUT][0].strip()
         logging.info("system_uid: %s", system_uid)
 
+        if getattr(self, keys.ConfigKeys.IKEY_ENABLE_COVERAGE, False):
+            coverage_utils.InitializeDeviceCoverage(self.dut)
+
         self.dut.hal.InitHidlHal(
             target_type="vehicle",
             target_basepaths=self.dut.libPaths,
@@ -63,6 +68,9 @@
         if self.enable_profiling:
             self.ProcessAndUploadTraceData()
 
+        if getattr(self, keys.ConfigKeys.IKEY_ENABLE_COVERAGE, False):
+            self.SetCoverageData(coverage_utils.GetGcdaDict(self.dut))
+
     def setUpTest(self):
         if self.enable_profiling:
             profiling_utils.EnableVTSProfiling(self.dut.shell.one)
@@ -108,19 +116,89 @@
                 break
         return isLiveSupported, isFreezeSupported
 
+    def readVhalProperty(self, propertyId, areaId=0):
+        """Reads a specified property from Vehicle HAL.
+
+        Args:
+            propertyId: the numeric identifier of the property to be read.
+            areaId: the numeric identifier of the vehicle area to retrieve the
+                    property for. 0, or omitted, for global.
+
+        Returns:
+            the value of the property as read from Vehicle HAL, or None
+            if it could not read successfully.
+        """
+        vp_dict = {
+            'prop' : propertyId,
+            'timestamp' : 0,
+            'areaId' : areaId,
+            'value' : {
+                'int32Values' : [],
+                'floatValues' : [],
+                'int64Values' : [],
+                'bytes' : [],
+                'stringValue' : ""
+            }
+        }
+        vp = self.vtypes.Py2Pb("VehiclePropValue", vp_dict)
+        status, value = self.vehicle.get(vp)
+        if self.vtypes.OK == status:
+            return value
+        else:
+            logging.warning("attempt to read property %s returned error %d",
+                            propertyId, status)
+
     def testObd2SensorProperties(self):
         """Test reading the live and freeze OBD2 frame properties.
 
         OBD2 (On-Board Diagnostics 2) is the industry standard protocol
         for retrieving diagnostic sensor information from vehicles.
         """
+        class CheckRead(object):
+            """This class wraps the logic of an actual property read.
+
+            Attributes:
+                testobject: the test case this object is used on behalf of.
+                propertyId: the identifier of the Vehiche HAL property to read.
+                name: the engineer-readable name of this test operation.
+            """
+
+            def __init__(self, testobject, propertyId, name):
+                self.testobject = testobject
+                self.propertyId = propertyId
+                self.name = name
+
+            def onReadSuccess(self, propValue):
+                """Override this to perform any post-read validation.
+
+                Args:
+                    propValue: the property value obtained from Vehicle HAL.
+                """
+                pass
+
+            def __call__(self):
+                """Reads the specified property and validates the result."""
+                propValue = self.testobject.readVhalProperty(self.propertyId)
+                asserts.assertNotEqual(propValue, None,
+                                       msg="reading %s should not return None" %
+                                       self.name)
+                logging.info("%s = %s", self.name, propValue)
+                self.onReadSuccess(propValue)
+                logging.info("%s pass" % self.name)
+
         def checkLiveFrameRead():
             """Validates reading the OBD2_LIVE_FRAME (if available)."""
-            logging.info("checkLiveFrameRead no-op pass")
+            checker = CheckRead(self,
+                                self.vtypes.OBD2_LIVE_FRAME,
+                                "OBD2_LIVE_FRAME")
+            checker()
 
         def checkFreezeFrameRead():
             """Validates reading the OBD2_FREEZE_FRAME (if available)."""
-            logging.info("checkLiveFrameRead no-op pass")
+            checker = CheckRead(self,
+                                self.vtypes.OBD2_FREEZE_FRAME,
+                                "OBD2_FREEZE_FRAME")
+            checker()
 
         isLiveSupported, isFreezeSupported = self.getSupportInfo()
         logging.info("isLiveSupported = %s, isFreezeSupported = %s",
@@ -130,5 +208,39 @@
         if isFreezeSupported:
             checkFreezeFrameRead()
 
+    def createVehiclePropValue(self, propId):
+        value = {
+            "int32Values" : [],
+            "floatValues" : [],
+            "int64Values" : [],
+            "bytes": [],
+            "stringValue": ""
+        }
+        propValue = {
+            "prop": propId,
+            "timestamp": 0,
+            "areaId": 0,
+            "value": value
+        }
+        return self.vtypes.Py2Pb("VehiclePropValue", propValue)
+
+    def testDrivingStatus(self):
+        """Checks that DRIVING_STATUS property returns correct result."""
+        request = self.createVehiclePropValue(self.vtypes.DRIVING_STATUS)
+        logging.info("Driving status request: %s", request)
+        response = self.vehicle.get(request)
+        logging.info("Driving status response: %s", response)
+        status = response[0]
+        asserts.assertEqual(self.vtypes.OK, status)
+        propValue = response[1]
+        assertEqual(1, len(propValue.value.int32Values))
+        drivingStatus = propValue.value.int32Values[0]
+
+        allStatuses = (self.vtypes.UNRESTRICTED | self.vtypes.NO_VIDEO
+               | self.vtypes.NO_KEYBOARD_INPUT | self.vtypes.NO_VOICE_INPUT
+               | self.vtypes.NO_CONFIG | self.vtypes.LIMIT_MESSAGE_LEN)
+
+        assertEqual(allStatuses, allStatuses | drivingStatus)
+
 if __name__ == "__main__":
     test_runner.main()
diff --git a/vehicle/2.0/vts/types.vts b/vehicle/2.0/vts/types.vts
index fa7d892..067a7d6 100644
--- a/vehicle/2.0/vts/types.vts
+++ b/vehicle/2.0/vts/types.vts
@@ -494,7 +494,7 @@
         scalar_value: {
             int32_t: 287312836
         }
-        enumerator: "VEHICLE_MAPS_DATA_SERVICE"
+        enumerator: "VEHICLE_MAP_SERVICE"
         scalar_value: {
             int32_t: 299895808
         }
diff --git a/vibrator/1.0/default/service.cpp b/vibrator/1.0/default/service.cpp
index 064e1e2..7cc0744 100644
--- a/vibrator/1.0/default/service.cpp
+++ b/vibrator/1.0/default/service.cpp
@@ -22,5 +22,5 @@
 using android::hardware::defaultPassthroughServiceImplementation;
 
 int main() {
-    return defaultPassthroughServiceImplementation<IVibrator>("vibrator");
+    return defaultPassthroughServiceImplementation<IVibrator>();
 }
diff --git a/vibrator/1.0/vts/functional/vibrator_hidl_hal_test.cpp b/vibrator/1.0/vts/functional/vibrator_hidl_hal_test.cpp
index 782a763..435b002 100644
--- a/vibrator/1.0/vts/functional/vibrator_hidl_hal_test.cpp
+++ b/vibrator/1.0/vts/functional/vibrator_hidl_hal_test.cpp
@@ -32,7 +32,7 @@
 class VibratorHidlTest : public ::testing::Test {
  public:
   virtual void SetUp() override {
-    vibrator = IVibrator::getService(false);
+    vibrator = IVibrator::getService();
     ASSERT_NE(vibrator, nullptr);
   }
 
diff --git a/vr/1.0/vts/functional/vr_hidl_hal_test.cpp b/vr/1.0/vts/functional/vr_hidl_hal_test.cpp
index 85ecbdc..7e85337 100644
--- a/vr/1.0/vts/functional/vr_hidl_hal_test.cpp
+++ b/vr/1.0/vts/functional/vr_hidl_hal_test.cpp
@@ -32,8 +32,7 @@
 class VrHidlTest : public ::testing::Test {
  public:
   void SetUp() override {
-    // currently test passthrough mode only
-    vr = IVr::getService(VR_SERVICE_NAME, true);
+    vr = IVr::getService(VR_SERVICE_NAME);
     ASSERT_NE(vr, nullptr);
     ASSERT_TRUE(!vr->isRemote());
   }
diff --git a/wifi/1.0/Android.mk b/wifi/1.0/Android.mk
index 1058cc7..708c14c 100644
--- a/wifi/1.0/Android.mk
+++ b/wifi/1.0/Android.mk
@@ -1589,6 +1589,8 @@
 $(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiApIface.hal
 $(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiIface.hal
 $(GEN): $(LOCAL_PATH)/IWifiIface.hal
+$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/types.hal
+$(GEN): $(LOCAL_PATH)/types.hal
 $(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
 $(GEN): PRIVATE_CUSTOM_TOOL = \
         $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
@@ -3447,6 +3449,8 @@
 $(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiApIface.hal
 $(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiIface.hal
 $(GEN): $(LOCAL_PATH)/IWifiIface.hal
+$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/types.hal
+$(GEN): $(LOCAL_PATH)/types.hal
 $(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
 $(GEN): PRIVATE_CUSTOM_TOOL = \
         $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
diff --git a/wifi/1.0/IWifiApIface.hal b/wifi/1.0/IWifiApIface.hal
index 6bc3580..aeca2cd 100644
--- a/wifi/1.0/IWifiApIface.hal
+++ b/wifi/1.0/IWifiApIface.hal
@@ -22,5 +22,15 @@
  * Interface used to represent a single AP iface.
  */
 interface IWifiApIface extends IWifiIface {
-  /** TODO(rpius): Add methods to the interface. */
+  /**
+   * Set country code for this iface.
+   *
+   * @param code 2 byte country code (as defined in ISO 3166) to set.
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.FAILURE_UNKNOWN|,
+   *         |WifiStatusCode.FAILURE_IFACE_INVALID|
+   */
+  setCountryCode(int8_t[2] code) generates (WifiStatus status);
 };
diff --git a/wifi/1.0/IWifiStaIface.hal b/wifi/1.0/IWifiStaIface.hal
index 6a738a9..2c72ead 100644
--- a/wifi/1.0/IWifiStaIface.hal
+++ b/wifi/1.0/IWifiStaIface.hal
@@ -439,7 +439,8 @@
 
   /**
    * API to start packet fate monitoring.
-   * - Once stared, monitoring must remain active until HAL is unloaded.
+   * - Once started, monitoring must remain active until HAL is stopped or the
+   *   chip is reconfigured.
    * - When HAL is unloaded, all packet fate buffers must be cleared.
    * - The packet fates are used to monitor the state of packets transmitted/
    *   received during association.
@@ -455,20 +456,6 @@
   startDebugPacketFateMonitoring() generates (WifiStatus status);
 
   /**
-   * API to stop packet fate monitoring.
-   *
-   * @return status WifiStatus of the operation.
-   *         Possible status codes:
-   *         |WifiStatusCode.SUCCESS|,
-   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
-   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
-   *         |WifiStatusCode.ERROR_NOT_STARTED|,
-   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
-   *         |WifiStatusCode.ERROR_UNKNOWN|
-   */
-  stopDebugPacketFateMonitoring() generates (WifiStatus status);
-
-  /**
    * API to retrieve fates of outbound packets.
    * - HAL implementation must return the fates of
    *   all the frames transmitted for the most recent association.
diff --git a/wifi/1.0/default/Android.mk b/wifi/1.0/default/Android.mk
index f0c78ea..144c067 100644
--- a/wifi/1.0/default/Android.mk
+++ b/wifi/1.0/default/Android.mk
@@ -16,7 +16,7 @@
 include $(CLEAR_VARS)
 LOCAL_MODULE := android.hardware.wifi@1.0-service
 LOCAL_MODULE_RELATIVE_PATH := hw
-LOCAL_CPPFLAGS := -Wall -Wno-unused-parameter -Werror -Wextra
+LOCAL_CPPFLAGS := -Wall -Werror -Wextra
 LOCAL_SRC_FILES := \
     hidl_struct_util.cpp \
     service.cpp \
diff --git a/wifi/1.0/default/wifi.cpp b/wifi/1.0/default/wifi.cpp
index c06abe8..8feb836 100644
--- a/wifi/1.0/default/wifi.cpp
+++ b/wifi/1.0/default/wifi.cpp
@@ -107,11 +107,6 @@
         LOG(ERROR) << "Failed to invoke onStart callback";
       };
     }
-    for (const auto& callback : event_callbacks_) {
-      if (!callback->onFailure(wifi_status).isOk()) {
-        LOG(ERROR) << "Failed to invoke onFailure callback";
-      }
-    }
   } else {
     for (const auto& callback : event_callbacks_) {
       if (!callback->onFailure(wifi_status).isOk()) {
diff --git a/wifi/1.0/default/wifi_ap_iface.cpp b/wifi/1.0/default/wifi_ap_iface.cpp
index b8b7a3a..1a8b31d 100644
--- a/wifi/1.0/default/wifi_ap_iface.cpp
+++ b/wifi/1.0/default/wifi_ap_iface.cpp
@@ -55,6 +55,15 @@
                          hidl_status_cb);
 }
 
+Return<void> WifiApIface::setCountryCode(const hidl_array<int8_t, 2>& code,
+                                         setCountryCode_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiApIface::setCountryCodeInternal,
+                         hidl_status_cb,
+                         code);
+}
+
 std::pair<WifiStatus, std::string> WifiApIface::getNameInternal() {
   return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
 }
@@ -63,6 +72,13 @@
   return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::AP};
 }
 
+WifiStatus WifiApIface::setCountryCodeInternal(
+    const std::array<int8_t, 2>& code) {
+  legacy_hal::wifi_error legacy_status =
+      legacy_hal_.lock()->setCountryCode(code);
+  return createWifiStatusFromLegacyError(legacy_status);
+}
+
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace wifi
diff --git a/wifi/1.0/default/wifi_ap_iface.h b/wifi/1.0/default/wifi_ap_iface.h
index ee5dc56..23d6435 100644
--- a/wifi/1.0/default/wifi_ap_iface.h
+++ b/wifi/1.0/default/wifi_ap_iface.h
@@ -42,11 +42,14 @@
   // HIDL methods exposed.
   Return<void> getName(getName_cb hidl_status_cb) override;
   Return<void> getType(getType_cb hidl_status_cb) override;
+  Return<void> setCountryCode(const hidl_array<int8_t, 2>& code,
+                              setCountryCode_cb hidl_status_cb) override;
 
  private:
   // Corresponding worker functions for the HIDL methods.
   std::pair<WifiStatus, std::string> getNameInternal();
   std::pair<WifiStatus, IfaceType> getTypeInternal();
+  WifiStatus setCountryCodeInternal(const std::array<int8_t, 2>& code);
 
   std::string ifname_;
   std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
diff --git a/wifi/1.0/default/wifi_legacy_hal.cpp b/wifi/1.0/default/wifi_legacy_hal.cpp
index 3bfd2bb..e4eddcd 100644
--- a/wifi/1.0/default/wifi_legacy_hal.cpp
+++ b/wifi/1.0/default/wifi_legacy_hal.cpp
@@ -22,12 +22,7 @@
 #include "wifi_legacy_hal.h"
 #include "wifi_legacy_hal_stubs.h"
 
-namespace android {
-namespace hardware {
-namespace wifi {
-namespace V1_0 {
-namespace implementation {
-namespace legacy_hal {
+namespace {
 // Constants ported over from the legacy HAL calling code
 // (com_android_server_wifi_WifiNative.cpp). This will all be thrown
 // away when this shim layer is replaced by the real vendor
@@ -39,6 +34,21 @@
 static constexpr uint32_t kMaxWakeReasonStatsArraySize = 32;
 static constexpr uint32_t kMaxRingBuffers = 10;
 
+// Helper function to create a non-const char* for legacy Hal API's.
+std::vector<char> makeCharVec(const std::string& str) {
+  std::vector<char> vec(str.size() + 1);
+  vec.assign(str.begin(), str.end());
+  vec.push_back('\0');
+  return vec;
+}
+}  // namespace
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_0 {
+namespace implementation {
+namespace legacy_hal {
 // Legacy HAL functions accept "C" style function pointers, so use global
 // functions to pass to the legacy HAL function and store the corresponding
 // std::function methods to be invoked.
@@ -804,19 +814,17 @@
                                                  uint32_t verbose_level,
                                                  uint32_t max_interval_sec,
                                                  uint32_t min_data_size) {
-  std::vector<char> ring_name_internal(ring_name.begin(), ring_name.end());
   return global_func_table_.wifi_start_logging(wlan_interface_handle_,
                                                verbose_level,
                                                0,
                                                max_interval_sec,
                                                min_data_size,
-                                               ring_name_internal.data());
+                                               makeCharVec(ring_name).data());
 }
 
 wifi_error WifiLegacyHal::getRingBufferData(const std::string& ring_name) {
-  std::vector<char> ring_name_internal(ring_name.begin(), ring_name.end());
   return global_func_table_.wifi_get_ring_data(wlan_interface_handle_,
-                                               ring_name_internal.data());
+                                               makeCharVec(ring_name).data());
 }
 
 wifi_error WifiLegacyHal::registerErrorAlertCallbackHandler(
@@ -1091,16 +1099,14 @@
 
 wifi_error WifiLegacyHal::nanDataInterfaceCreate(
     transaction_id id, const std::string& iface_name) {
-  std::vector<char> iface_name_internal(iface_name.begin(), iface_name.end());
   return global_func_table_.wifi_nan_data_interface_create(
-      id, wlan_interface_handle_, iface_name_internal.data());
+      id, wlan_interface_handle_, makeCharVec(iface_name).data());
 }
 
 wifi_error WifiLegacyHal::nanDataInterfaceDelete(
     transaction_id id, const std::string& iface_name) {
-  std::vector<char> iface_name_internal(iface_name.begin(), iface_name.end());
   return global_func_table_.wifi_nan_data_interface_delete(
-      id, wlan_interface_handle_, iface_name_internal.data());
+      id, wlan_interface_handle_, makeCharVec(iface_name).data());
 }
 
 wifi_error WifiLegacyHal::nanDataRequestInitiator(
@@ -1124,6 +1130,12 @@
       id, wlan_interface_handle_, &msg_internal);
 }
 
+wifi_error WifiLegacyHal::setCountryCode(std::array<int8_t, 2> code) {
+  std::string code_str(code.data(), code.data() + code.size());
+  return global_func_table_.wifi_set_country_code(wlan_interface_handle_,
+                                                  code_str.c_str());
+}
+
 wifi_error WifiLegacyHal::retrieveWlanInterfaceHandle() {
   const std::string& ifname_to_find = getStaIfaceName();
   wifi_interface_handle* iface_handles = nullptr;
diff --git a/wifi/1.0/default/wifi_legacy_hal.h b/wifi/1.0/default/wifi_legacy_hal.h
index a3ac075..1ab74b7 100644
--- a/wifi/1.0/default/wifi_legacy_hal.h
+++ b/wifi/1.0/default/wifi_legacy_hal.h
@@ -256,6 +256,8 @@
   wifi_error nanDataIndicationResponse(
       transaction_id id, const NanDataPathIndicationResponse& msg);
   wifi_error nanDataEnd(transaction_id id, const NanDataPathEndRequest& msg);
+  // AP functions.
+  wifi_error setCountryCode(std::array<int8_t, 2> code);
 
  private:
   // Retrieve the interface handle to be used for the "wlan" interface.
diff --git a/wifi/1.0/default/wifi_sta_iface.cpp b/wifi/1.0/default/wifi_sta_iface.cpp
index a00c5bc..be2fe37 100644
--- a/wifi/1.0/default/wifi_sta_iface.cpp
+++ b/wifi/1.0/default/wifi_sta_iface.cpp
@@ -258,14 +258,6 @@
                          hidl_status_cb);
 }
 
-Return<void> WifiStaIface::stopDebugPacketFateMonitoring(
-    stopDebugPacketFateMonitoring_cb hidl_status_cb) {
-  return validateAndCall(this,
-                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
-                         &WifiStaIface::stopDebugPacketFateMonitoringInternal,
-                         hidl_status_cb);
-}
-
 Return<void> WifiStaIface::getDebugTxPacketFates(
     getDebugTxPacketFates_cb hidl_status_cb) {
   return validateAndCall(this,
@@ -567,11 +559,6 @@
   return createWifiStatusFromLegacyError(legacy_status);
 }
 
-WifiStatus WifiStaIface::stopDebugPacketFateMonitoringInternal() {
-  // There is no stop in legacy HAL implementation.
-  return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
-}
-
 std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>>
 WifiStaIface::getDebugTxPacketFatesInternal() {
   legacy_hal::wifi_error legacy_status;
diff --git a/wifi/1.0/default/wifi_sta_iface.h b/wifi/1.0/default/wifi_sta_iface.h
index 311c991..ca79c5b 100644
--- a/wifi/1.0/default/wifi_sta_iface.h
+++ b/wifi/1.0/default/wifi_sta_iface.h
@@ -97,8 +97,6 @@
       uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) override;
   Return<void> startDebugPacketFateMonitoring(
       startDebugPacketFateMonitoring_cb hidl_status_cb) override;
-  Return<void> stopDebugPacketFateMonitoring(
-      stopDebugPacketFateMonitoring_cb hidl_status_cb) override;
   Return<void> getDebugTxPacketFates(
       getDebugTxPacketFates_cb hidl_status_cb) override;
   Return<void> getDebugRxPacketFates(
@@ -143,7 +141,6 @@
       uint32_t period_in_ms);
   WifiStatus stopSendingKeepAlivePacketsInternal(uint32_t cmd_id);
   WifiStatus startDebugPacketFateMonitoringInternal();
-  WifiStatus stopDebugPacketFateMonitoringInternal();
   std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>>
   getDebugTxPacketFatesInternal();
   std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>>
diff --git a/wifi/1.0/default/wifi_status_util.cpp b/wifi/1.0/default/wifi_status_util.cpp
index 518032f..c2d0758 100644
--- a/wifi/1.0/default/wifi_status_util.cpp
+++ b/wifi/1.0/default/wifi_status_util.cpp
@@ -42,8 +42,9 @@
       return "TOO_MANY_REQUESTS";
     case legacy_hal::WIFI_ERROR_OUT_OF_MEMORY:
       return "OUT_OF_MEMORY";
+    case legacy_hal::WIFI_ERROR_BUSY:
+      return "BUSY";
     case legacy_hal::WIFI_ERROR_UNKNOWN:
-    default:
       return "UNKNOWN";
   }
 }
@@ -90,7 +91,6 @@
       return createWifiStatus(WifiStatusCode::SUCCESS, desc);
 
     case legacy_hal::WIFI_ERROR_UNKNOWN:
-    default:
       return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, "unknown");
   }
 }
diff --git a/wifi/1.0/types.hal b/wifi/1.0/types.hal
index edf306d..bb00114 100644
--- a/wifi/1.0/types.hal
+++ b/wifi/1.0/types.hal
@@ -549,14 +549,14 @@
  */
 enum StaRoamingState : uint8_t {
   /**
+   * Driver/Firmware must not perform any roaming.
+   */
+  DISABLED = 0,
+  /**
    * Driver/Firmware is allowed to perform roaming respecting
    * the |StaRoamingConfig| parameters set using |configureRoaming|.
    */
-  ENABLED = 0,
-  /**
-   * Driver/Firmware must not perform any roaming.
-   */
-  DISABLED = 1
+  ENABLED = 1
 };
 
 /**
@@ -2142,7 +2142,7 @@
 };
 
 /**
- * Struct describing packet fate report for each Rx frame.
+ * Struct describing packet fate report for each Tx frame.
  */
 struct WifiDebugTxPacketFateReport {
   WifiDebugTxPacketFate fate;
diff --git a/wifi/supplicant/1.0/ISupplicantIface.hal b/wifi/supplicant/1.0/ISupplicantIface.hal
index c0058a0..8bb8c97 100644
--- a/wifi/supplicant/1.0/ISupplicantIface.hal
+++ b/wifi/supplicant/1.0/ISupplicantIface.hal
@@ -138,6 +138,19 @@
   setWpsDeviceName(string name) generates (SupplicantStatus status);
 
   /**
+   * Set the device type for WPS operations.
+   *
+   * @parm type Type of device. Refer to section B.1 of Wifi P2P
+   *       Technical specification v1.2.
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_IFACE_INVALID|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|
+   */
+  setWpsDeviceType(uint8_t[8] type) generates (SupplicantStatus status);
+
+  /**
    * Set the manufacturer for WPS operations.
    * The manufacturer of the device (up to |WPS_MANUFACTURER_MAX_LEN| ASCII
    * characters).
diff --git a/wifi/supplicant/1.0/ISupplicantStaIface.hal b/wifi/supplicant/1.0/ISupplicantStaIface.hal
index c9d9ee6..68eb179 100644
--- a/wifi/supplicant/1.0/ISupplicantStaIface.hal
+++ b/wifi/supplicant/1.0/ISupplicantStaIface.hal
@@ -67,6 +67,10 @@
     SENSE = 2
   };
 
+  enum ExtRadioWorkDefaults : uint32_t {
+    TIMEOUT_IN_SECS = 10
+  };
+
   /**
    * Register for callbacks from this interface.
    *
@@ -405,4 +409,55 @@
    *         |SupplicantStatusCode.FAILURE_IFACE_INVALID|
    */
   setExternalSim(bool useExternalSim) generates (SupplicantStatus status);
+
+  /**
+   * External programs can request supplicant to not start offchannel
+   * operations during other tasks that may need exclusive control of the
+   * radio.
+   *
+   * This method can be used to reserve a slot for radio access. If freq is
+   * specified, other radio work items on the same channel can be completed in
+   * parallel. Otherwise, all other radio work items are blocked during
+   * execution. Timeout must be set to |ExtRadioWorkDefaults.TIMEOUT_IN_SECS|
+   * seconds by default to avoid blocking supplicant operations on the iface
+   * for excessive time. If a longer (or shorter) safety timeout is needed,
+   * that may be specified with the optional timeout parameter. This command
+   * returns an identifier for the radio work item.
+   *
+   * Once the radio work item has been started,
+   * |ISupplicant.onExtRadioWorkStart| callback is indicated that the external
+   * processing can start.
+   *
+   * @param name Name for the radio work being added.
+   * @param freqInMhz Frequency to specify. Set to 0 for all channels.
+   * @param timeoutInSec Timeout tospecify. Set to 0 for default timeout.
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|
+   * @return id Identifier for this radio work.
+   */
+  addExtRadioWork(string name, uint32_t freqInMhz, uint32_t timeoutInSec)
+      generates (SupplicantStatus status, uint32_t id);
+
+  /**
+   * Indicates to supplicant that the external radio work has completed.
+   * This allows other radio works to be performed. If this method is not
+   * invoked (e.g., due to the external program terminating), supplicant
+   * must time out the radio work item on the iface and send
+   * |ISupplicantCallback.onExtRadioWorkTimeout| event to indicate
+   * that this has happened.
+   *
+   * This method may also be used to cancel items that have been scheduled
+   * via |addExtRadioWork|, but have not yet been started (notified via
+   * |ISupplicantCallback.onExtRadioWorkStart|).
+   *
+   * @return id Identifier generated for the radio work addition
+   *         (using |addExtRadioWork|).
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|
+   */
+  removeExtRadioWork(uint32_t id) generates (SupplicantStatus status);
 };
diff --git a/wifi/supplicant/1.0/ISupplicantStaIfaceCallback.hal b/wifi/supplicant/1.0/ISupplicantStaIfaceCallback.hal
index 4b201d4..c3ec060 100644
--- a/wifi/supplicant/1.0/ISupplicantStaIfaceCallback.hal
+++ b/wifi/supplicant/1.0/ISupplicantStaIfaceCallback.hal
@@ -326,4 +326,18 @@
    * Used to indicate the overlap of a WPS PBC connection attempt.
    */
   oneway onWpsEventPbcOverlap();
+
+  /**
+   * Used to indicate that the external radio work can start now.
+   *
+   * @return id Identifier generated for the radio work request.
+   */
+  oneway onExtRadioWorkStart(uint32_t id);
+
+  /**
+   * Used to indicate that the external radio work request has timed out.
+   *
+   * @return id Identifier generated for the radio work request.
+   */
+  oneway onExtRadioWorkTimeout(uint32_t id);
 };
diff --git a/wifi/supplicant/1.0/ISupplicantStaNetwork.hal b/wifi/supplicant/1.0/ISupplicantStaNetwork.hal
index b347c1d..deaad5d 100644
--- a/wifi/supplicant/1.0/ISupplicantStaNetwork.hal
+++ b/wifi/supplicant/1.0/ISupplicantStaNetwork.hal
@@ -508,8 +508,30 @@
    */
   setEapDomainSuffixMatch(string match)
       generates (SupplicantStatus status);
+
   /**
-   * Get ID string set for this network.
+   * This field can be used to enable proactive key caching which is also
+   * known as opportunistic PMKSA caching for WPA2. This is disabled (0)
+   * by default unless default value is changed with the global okc=1
+   * parameter.
+   *
+   * Proactive key caching is used to make supplicant assume that the APs
+   * are using the same PMK and generate PMKSA cache entries without
+   * doing RSN pre-authentication. This requires support from the AP side
+   * and is normally used with wireless switches that co-locate the
+   * authenticator.
+   *
+   * @param enable true to set, false otherwise.
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|,
+   *         |SupplicantStatusCode.FAILURE_NETWORK_INVALID|
+   */
+  setProactiveKeyCaching(bool enable) generates (SupplicantStatus status);
+
+  /**
+   * Set ID string for this network.
    * Network identifier string for external scripts.
    *
    * @return idStr ID string value to set.
@@ -523,6 +545,20 @@
   setIdStr(string idStr) generates (SupplicantStatus status);
 
   /**
+   * Set PPS MO ID for this network.
+   * (Hotspot 2.0 PerProviderSubscription/UpdateIdentifier)
+   *
+   * @return id ID value to set.
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_ARGS_INVALID|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|,
+   *         |SupplicantStatusCode.FAILURE_NETWORK_INVALID|
+   */
+  setUpdateIdentifier(uint32_t id) generates (SupplicantStatus status);
+
+  /**
    * Getters for the various network params.
    */
   /**
@@ -912,11 +948,23 @@
    *         |SupplicantStatusCode.FAILURE_UNKNOWN|,
    *         |SupplicantStatusCode.FAILURE_NETWORK_INVALID|
    */
-  sendNetworkEapSimGsmAuthResponse(NetworkResponseEapSimGsmAuthParams params)
+  sendNetworkEapSimGsmAuthResponse(vec<NetworkResponseEapSimGsmAuthParams> params)
       generates (SupplicantStatus status);
 
   /**
    * Used to send a response to the
+   * |ISupplicantNetworkCallback.onNetworkEapSimGsmAuthRequest| request.
+   *
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|,
+   *         |SupplicantStatusCode.FAILURE_NETWORK_INVALID|
+   */
+  sendNetworkEapSimGsmAuthFailure() generates (SupplicantStatus status);
+
+  /**
+   * Used to send a response to the
    * |ISupplicantNetworkCallback.onNetworkEapSimUmtsAuthRequest| request.
    *
    * @param params Params to be used for EAP UMTS authentication.
@@ -931,6 +979,32 @@
 
   /**
    * Used to send a response to the
+   * |ISupplicantNetworkCallback.onNetworkEapSimUmtsAuthRequest| request.
+   *
+   * @param auts Params to be used for EAP UMTS authentication.
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|,
+   *         |SupplicantStatusCode.FAILURE_NETWORK_INVALID|
+   */
+  sendNetworkEapSimUmtsAutsResponse(uint8_t[14] auts)
+      generates (SupplicantStatus status);
+
+  /**
+   * Used to send a response to the
+   * |ISupplicantNetworkCallback.onNetworkEapSimUmtsAuthRequest| request.
+   *
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|,
+   *         |SupplicantStatusCode.FAILURE_NETWORK_INVALID|
+   */
+  sendNetworkEapSimUmtsAuthFailure() generates (SupplicantStatus status);
+
+  /**
+   * Used to send a response to the
    * |ISupplicantNetworkCallback.onNetworkEapIdentityRequest| request.
    *
    * @param identity Identity to be used for the network.