diff --git a/CleanSpec.mk b/CleanSpec.mk
index 212c8b1..c557635 100644
--- a/CleanSpec.mk
+++ b/CleanSpec.mk
@@ -52,3 +52,5 @@
 $(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/hw/android.hardware.bluetooth*)
 $(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib64/hw/android.hardware.bluetooth*)
 $(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/init/android.hardware.bluetooth*)
+$(call add-clean-step, rm -rf $(OUT)/soong/.intermediates/)
+$(call add-clean-step, rm -rf $(OUT_DIR)/soong/.intermediates/hardware/interfaces/)
diff --git a/audio/2.0/Android.bp b/audio/2.0/Android.bp
index 264105c..feee518 100644
--- a/audio/2.0/Android.bp
+++ b/audio/2.0/Android.bp
@@ -17,7 +17,7 @@
 genrule {
     name: "android.hardware.audio@2.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
     srcs: [
         ":android.hardware.audio@2.0_hal",
     ],
@@ -36,7 +36,7 @@
 genrule {
     name: "android.hardware.audio@2.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
     srcs: [
         ":android.hardware.audio@2.0_hal",
     ],
diff --git a/audio/2.0/default/Device.cpp b/audio/2.0/default/Device.cpp
index da79238..280d320 100644
--- a/audio/2.0/default/Device.cpp
+++ b/audio/2.0/default/Device.cpp
@@ -1,18 +1,18 @@
- /*
- * 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.
- */
+/*
+* 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.
+*/
 
 #define LOG_TAG "DeviceHAL"
 //#define LOG_NDEBUG 0
@@ -30,6 +30,7 @@
 #include "HidlUtils.h"
 #include "StreamIn.h"
 #include "StreamOut.h"
+#include "Util.h"
 
 namespace android {
 namespace hardware {
@@ -92,7 +93,8 @@
 
 Device::~Device() {
     int status = audio_hw_device_close(mDevice);
-    ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice, strerror(-status));
+    ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice,
+             strerror(-status));
     mDevice = nullptr;
 }
 
@@ -101,12 +103,18 @@
         ALOGW("Device %p %s: %s", mDevice, funcName, strerror(-status));
     }
     switch (status) {
-        case 0: return Result::OK;
-        case -EINVAL: return Result::INVALID_ARGUMENTS;
-        case -ENODATA: return Result::INVALID_STATE;
-        case -ENODEV: return Result::NOT_INITIALIZED;
-        case -ENOSYS: return Result::NOT_SUPPORTED;
-        default: return Result::INVALID_STATE;
+        case 0:
+            return Result::OK;
+        case -EINVAL:
+            return Result::INVALID_ARGUMENTS;
+        case -ENODATA:
+            return Result::INVALID_STATE;
+        case -ENODEV:
+            return Result::NOT_INITIALIZED;
+        case -ENOSYS:
+            return Result::NOT_SUPPORTED;
+        default:
+            return Result::INVALID_STATE;
     }
 }
 
@@ -129,59 +137,67 @@
 }
 
 // Methods from ::android::hardware::audio::V2_0::IDevice follow.
-Return<Result> Device::initCheck()  {
+Return<Result> Device::initCheck() {
     return analyzeStatus("init_check", mDevice->init_check(mDevice));
 }
 
-Return<Result> Device::setMasterVolume(float volume)  {
-    Result retval(Result::NOT_SUPPORTED);
-    if (mDevice->set_master_volume != NULL) {
-        retval = analyzeStatus("set_master_volume", mDevice->set_master_volume(mDevice, volume));
+Return<Result> Device::setMasterVolume(float volume) {
+    if (mDevice->set_master_volume == NULL) {
+        return Result::NOT_SUPPORTED;
     }
-    return retval;
+    if (!isGainNormalized(volume)) {
+        ALOGW("Can not set a master volume (%f) outside [0,1]", volume);
+        return Result::INVALID_ARGUMENTS;
+    }
+    return analyzeStatus("set_master_volume",
+                         mDevice->set_master_volume(mDevice, volume));
 }
 
-Return<void> Device::getMasterVolume(getMasterVolume_cb _hidl_cb)  {
+Return<void> Device::getMasterVolume(getMasterVolume_cb _hidl_cb) {
     Result retval(Result::NOT_SUPPORTED);
     float volume = 0;
     if (mDevice->get_master_volume != NULL) {
-        retval = analyzeStatus("get_master_volume", mDevice->get_master_volume(mDevice, &volume));
+        retval = analyzeStatus("get_master_volume",
+                               mDevice->get_master_volume(mDevice, &volume));
     }
     _hidl_cb(retval, volume);
     return Void();
 }
 
-Return<Result> Device::setMicMute(bool mute)  {
+Return<Result> Device::setMicMute(bool mute) {
     return analyzeStatus("set_mic_mute", mDevice->set_mic_mute(mDevice, mute));
 }
 
-Return<void> Device::getMicMute(getMicMute_cb _hidl_cb)  {
+Return<void> Device::getMicMute(getMicMute_cb _hidl_cb) {
     bool mute = false;
-    Result retval = analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));
+    Result retval =
+        analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));
     _hidl_cb(retval, mute);
     return Void();
 }
 
-Return<Result> Device::setMasterMute(bool mute)  {
+Return<Result> Device::setMasterMute(bool mute) {
     Result retval(Result::NOT_SUPPORTED);
     if (mDevice->set_master_mute != NULL) {
-        retval = analyzeStatus("set_master_mute", mDevice->set_master_mute(mDevice, mute));
+        retval = analyzeStatus("set_master_mute",
+                               mDevice->set_master_mute(mDevice, mute));
     }
     return retval;
 }
 
-Return<void> Device::getMasterMute(getMasterMute_cb _hidl_cb)  {
+Return<void> Device::getMasterMute(getMasterMute_cb _hidl_cb) {
     Result retval(Result::NOT_SUPPORTED);
     bool mute = false;
     if (mDevice->get_master_mute != NULL) {
-        retval = analyzeStatus("get_master_mute", mDevice->get_master_mute(mDevice, &mute));
+        retval = analyzeStatus("get_master_mute",
+                               mDevice->get_master_mute(mDevice, &mute));
     }
     _hidl_cb(retval, mute);
     return Void();
 }
 
-Return<void> Device::getInputBufferSize(
-        const AudioConfig& config, getInputBufferSize_cb _hidl_cb)  {
+Return<void> Device::getInputBufferSize(const AudioConfig& config,
+                                        getInputBufferSize_cb _hidl_cb) {
     audio_config_t halConfig;
     HidlUtils::audioConfigToHal(config, &halConfig);
     size_t halBufferSize = mDevice->get_input_buffer_size(mDevice, &halConfig);
@@ -195,29 +211,25 @@
     return Void();
 }
 
-Return<void> Device::openOutputStream(
-        int32_t ioHandle,
-        const DeviceAddress& device,
-        const AudioConfig& config,
-        AudioOutputFlag flags,
-        openOutputStream_cb _hidl_cb)  {
+Return<void> Device::openOutputStream(int32_t ioHandle,
+                                      const DeviceAddress& device,
+                                      const AudioConfig& config,
+                                      AudioOutputFlag flags,
+                                      openOutputStream_cb _hidl_cb) {
     audio_config_t halConfig;
     HidlUtils::audioConfigToHal(config, &halConfig);
-    audio_stream_out_t *halStream;
-    ALOGV("open_output_stream handle: %d devices: %x flags: %#x "
-            "srate: %d format %#x channels %x address %s",
-            ioHandle,
-            static_cast<audio_devices_t>(device.device), static_cast<audio_output_flags_t>(flags),
-            halConfig.sample_rate, halConfig.format, halConfig.channel_mask,
-            deviceAddressToHal(device).c_str());
+    audio_stream_out_t* halStream;
+    ALOGV(
+        "open_output_stream handle: %d devices: %x flags: %#x "
+        "srate: %d format %#x channels %x address %s",
+        ioHandle, static_cast<audio_devices_t>(device.device),
+        static_cast<audio_output_flags_t>(flags), halConfig.sample_rate,
+        halConfig.format, halConfig.channel_mask,
+        deviceAddressToHal(device).c_str());
     int status = mDevice->open_output_stream(
-            mDevice,
-            ioHandle,
-            static_cast<audio_devices_t>(device.device),
-            static_cast<audio_output_flags_t>(flags),
-            &halConfig,
-            &halStream,
-            deviceAddressToHal(device).c_str());
+        mDevice, ioHandle, static_cast<audio_devices_t>(device.device),
+        static_cast<audio_output_flags_t>(flags), &halConfig, &halStream,
+        deviceAddressToHal(device).c_str());
     ALOGV("open_output_stream status %d stream %p", status, halStream);
     sp<IStreamOut> streamOut;
     if (status == OK) {
@@ -225,35 +237,32 @@
     }
     AudioConfig suggestedConfig;
     HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);
-    _hidl_cb(analyzeStatus("open_output_stream", status), streamOut, suggestedConfig);
+    _hidl_cb(analyzeStatus("open_output_stream", status), streamOut,
+             suggestedConfig);
     return Void();
 }
 
-Return<void> Device::openInputStream(
-        int32_t ioHandle,
-        const DeviceAddress& device,
-        const AudioConfig& config,
-        AudioInputFlag flags,
-        AudioSource source,
-        openInputStream_cb _hidl_cb)  {
+Return<void> Device::openInputStream(int32_t ioHandle,
+                                     const DeviceAddress& device,
+                                     const AudioConfig& config,
+                                     AudioInputFlag flags, AudioSource source,
+                                     openInputStream_cb _hidl_cb) {
     audio_config_t halConfig;
     HidlUtils::audioConfigToHal(config, &halConfig);
-    audio_stream_in_t *halStream;
-    ALOGV("open_input_stream handle: %d devices: %x flags: %#x "
-            "srate: %d format %#x channels %x address %s source %d",
-            ioHandle,
-            static_cast<audio_devices_t>(device.device), static_cast<audio_input_flags_t>(flags),
-            halConfig.sample_rate, halConfig.format, halConfig.channel_mask,
-            deviceAddressToHal(device).c_str(), static_cast<audio_source_t>(source));
+    audio_stream_in_t* halStream;
+    ALOGV(
+        "open_input_stream handle: %d devices: %x flags: %#x "
+        "srate: %d format %#x channels %x address %s source %d",
+        ioHandle, static_cast<audio_devices_t>(device.device),
+        static_cast<audio_input_flags_t>(flags), halConfig.sample_rate,
+        halConfig.format, halConfig.channel_mask,
+        deviceAddressToHal(device).c_str(),
+        static_cast<audio_source_t>(source));
     int status = mDevice->open_input_stream(
-            mDevice,
-            ioHandle,
-            static_cast<audio_devices_t>(device.device),
-            &halConfig,
-            &halStream,
-            static_cast<audio_input_flags_t>(flags),
-            deviceAddressToHal(device).c_str(),
-            static_cast<audio_source_t>(source));
+        mDevice, ioHandle, static_cast<audio_devices_t>(device.device),
+        &halConfig, &halStream, static_cast<audio_input_flags_t>(flags),
+        deviceAddressToHal(device).c_str(),
+        static_cast<audio_source_t>(source));
     ALOGV("open_input_stream status %d stream %p", status, halStream);
     sp<IStreamIn> streamIn;
     if (status == OK) {
@@ -261,7 +270,8 @@
     }
     AudioConfig suggestedConfig;
     HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);
-    _hidl_cb(analyzeStatus("open_input_stream", status), streamIn, suggestedConfig);
+    _hidl_cb(analyzeStatus("open_input_stream", status), streamIn,
+             suggestedConfig);
     return Void();
 }
 
@@ -269,23 +279,21 @@
     return version() >= AUDIO_DEVICE_API_VERSION_3_0;
 }
 
-Return<void> Device::createAudioPatch(
-        const hidl_vec<AudioPortConfig>& sources,
-        const hidl_vec<AudioPortConfig>& sinks,
-        createAudioPatch_cb _hidl_cb)  {
+Return<void> Device::createAudioPatch(const hidl_vec<AudioPortConfig>& sources,
+                                      const hidl_vec<AudioPortConfig>& sinks,
+                                      createAudioPatch_cb _hidl_cb) {
     Result retval(Result::NOT_SUPPORTED);
     AudioPatchHandle patch = 0;
     if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
-        std::unique_ptr<audio_port_config[]> halSources(HidlUtils::audioPortConfigsToHal(sources));
-        std::unique_ptr<audio_port_config[]> halSinks(HidlUtils::audioPortConfigsToHal(sinks));
+        std::unique_ptr<audio_port_config[]> halSources(
+            HidlUtils::audioPortConfigsToHal(sources));
+        std::unique_ptr<audio_port_config[]> halSinks(
+            HidlUtils::audioPortConfigsToHal(sinks));
         audio_patch_handle_t halPatch = AUDIO_PATCH_HANDLE_NONE;
         retval = analyzeStatus(
-                "create_audio_patch",
-                mDevice->create_audio_patch(
-                        mDevice,
-                        sources.size(), &halSources[0],
-                        sinks.size(), &halSinks[0],
-                        &halPatch));
+            "create_audio_patch",
+            mDevice->create_audio_patch(mDevice, sources.size(), &halSources[0],
+                                        sinks.size(), &halSinks[0], &halPatch));
         if (retval == Result::OK) {
             patch = static_cast<AudioPatchHandle>(halPatch);
         }
@@ -294,19 +302,22 @@
     return Void();
 }
 
-Return<Result> Device::releaseAudioPatch(int32_t patch)  {
+Return<Result> Device::releaseAudioPatch(int32_t patch) {
     if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
         return analyzeStatus(
-                "release_audio_patch",
-                mDevice->release_audio_patch(mDevice, static_cast<audio_patch_handle_t>(patch)));
+            "release_audio_patch",
+            mDevice->release_audio_patch(
+                mDevice, static_cast<audio_patch_handle_t>(patch)));
     }
     return Result::NOT_SUPPORTED;
 }
 
-Return<void> Device::getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb)  {
+Return<void> Device::getAudioPort(const AudioPort& port,
+                                  getAudioPort_cb _hidl_cb) {
     audio_port halPort;
     HidlUtils::audioPortToHal(port, &halPort);
-    Result retval = analyzeStatus("get_audio_port", mDevice->get_audio_port(mDevice, &halPort));
+    Result retval = analyzeStatus("get_audio_port",
+                                  mDevice->get_audio_port(mDevice, &halPort));
     AudioPort resultPort = port;
     if (retval == Result::OK) {
         HidlUtils::audioPortFromHal(halPort, &resultPort);
@@ -315,36 +326,39 @@
     return Void();
 }
 
-Return<Result> Device::setAudioPortConfig(const AudioPortConfig& config)  {
+Return<Result> Device::setAudioPortConfig(const AudioPortConfig& config) {
     if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
         struct audio_port_config halPortConfig;
         HidlUtils::audioPortConfigToHal(config, &halPortConfig);
         return analyzeStatus(
-                "set_audio_port_config", mDevice->set_audio_port_config(mDevice, &halPortConfig));
+            "set_audio_port_config",
+            mDevice->set_audio_port_config(mDevice, &halPortConfig));
     }
     return Result::NOT_SUPPORTED;
 }
 
-Return<AudioHwSync> Device::getHwAvSync()  {
+Return<AudioHwSync> Device::getHwAvSync() {
     int halHwAvSync;
     Result retval = getParam(AudioParameter::keyHwAvSync, &halHwAvSync);
     return retval == Result::OK ? halHwAvSync : AUDIO_HW_SYNC_INVALID;
 }
 
-Return<Result> Device::setScreenState(bool turnedOn)  {
+Return<Result> Device::setScreenState(bool turnedOn) {
     return setParam(AudioParameter::keyScreenState, turnedOn);
 }
 
-Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  {
+Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys,
+                                   getParameters_cb _hidl_cb) {
     getParametersImpl(keys, _hidl_cb);
     return Void();
 }
 
-Return<Result> Device::setParameters(const hidl_vec<ParameterValue>& parameters)  {
+Return<Result> Device::setParameters(
+    const hidl_vec<ParameterValue>& parameters) {
     return setParametersImpl(parameters);
 }
 
-Return<void> Device::debugDump(const hidl_handle& fd)  {
+Return<void> Device::debugDump(const hidl_handle& fd) {
     if (fd.getNativeHandle() != nullptr && fd->numFds == 1) {
         analyzeStatus("dump", mDevice->dump(mDevice, fd->data[0]));
     }
diff --git a/audio/2.0/default/ParametersUtil.cpp b/audio/2.0/default/ParametersUtil.cpp
index 75a60b9..5cc60db 100644
--- a/audio/2.0/default/ParametersUtil.cpp
+++ b/audio/2.0/default/ParametersUtil.cpp
@@ -22,11 +22,31 @@
 namespace V2_0 {
 namespace implementation {
 
+// Static method and not private method to avoid leaking status_t dependency
+static Result getHalStatusToResult(status_t status) {
+    switch (status) {
+        case OK:
+            return Result::OK;
+        case BAD_VALUE:  // Nothing was returned, probably because the HAL does
+                         // not handle it
+            return Result::NOT_SUPPORTED;
+        case INVALID_OPERATION:  // Conversion from string to the requested type
+                                 // failed
+            return Result::INVALID_ARGUMENTS;
+        default:  // Should not happen
+            ALOGW("Unexpected status returned by getParam: %u", status);
+            return Result::INVALID_ARGUMENTS;
+    }
+}
+
 Result ParametersUtil::getParam(const char* name, bool* value) {
     String8 halValue;
     Result retval = getParam(name, &halValue);
     *value = false;
     if (retval == Result::OK) {
+        if (halValue.empty()) {
+            return Result::NOT_SUPPORTED;
+        }
         *value = !(halValue == AudioParameter::valueOff);
     }
     return retval;
@@ -37,8 +57,7 @@
     AudioParameter keys;
     keys.addKey(halName);
     std::unique_ptr<AudioParameter> params = getParams(keys);
-    status_t halStatus = params->getInt(halName, *value);
-    return halStatus == OK ? Result::OK : Result::INVALID_ARGUMENTS;
+    return getHalStatusToResult(params->getInt(halName, *value));
 }
 
 Result ParametersUtil::getParam(const char* name, String8* value) {
@@ -46,42 +65,41 @@
     AudioParameter keys;
     keys.addKey(halName);
     std::unique_ptr<AudioParameter> params = getParams(keys);
-    status_t halStatus = params->get(halName, *value);
-    return halStatus == OK ? Result::OK : Result::INVALID_ARGUMENTS;
+    return getHalStatusToResult(params->get(halName, *value));
 }
 
 void ParametersUtil::getParametersImpl(
-        const hidl_vec<hidl_string>& keys,
-        std::function<void(Result retval, const hidl_vec<ParameterValue>& parameters)> cb)  {
+    const hidl_vec<hidl_string>& keys,
+    std::function<void(Result retval,
+                       const hidl_vec<ParameterValue>& parameters)>
+        cb) {
     AudioParameter halKeys;
     for (size_t i = 0; i < keys.size(); ++i) {
         halKeys.addKey(String8(keys[i].c_str()));
     }
     std::unique_ptr<AudioParameter> halValues = getParams(halKeys);
-    Result retval(Result::INVALID_ARGUMENTS);
+    Result retval =
+        halValues->size() == keys.size() ? Result::OK : Result::NOT_SUPPORTED;
     hidl_vec<ParameterValue> result;
-    if (halValues->size() > 0) {
-        result.resize(halValues->size());
-        String8 halKey, halValue;
-        for (size_t i = 0; i < halValues->size(); ++i) {
-            status_t status = halValues->getAt(i, halKey, halValue);
-            if (status != OK) {
-                result.resize(0);
-                break;
-            }
-            result[i].key = halKey.string();
-            result[i].value = halValue.string();
+    result.resize(halValues->size());
+    String8 halKey, halValue;
+    for (size_t i = 0; i < halValues->size(); ++i) {
+        status_t status = halValues->getAt(i, halKey, halValue);
+        if (status != OK) {
+            result.resize(0);
+            retval = getHalStatusToResult(status);
+            break;
         }
-        if (result.size() != 0) {
-            retval = Result::OK;
-        }
+        result[i].key = halKey.string();
+        result[i].value = halValue.string();
     }
     cb(retval, result);
 }
 
-std::unique_ptr<AudioParameter> ParametersUtil::getParams(const AudioParameter& keys) {
+std::unique_ptr<AudioParameter> ParametersUtil::getParams(
+    const AudioParameter& keys) {
     String8 paramsAndValues;
-    char *halValues = halGetParameters(keys.keysToString().string());
+    char* halValues = halGetParameters(keys.keysToString().string());
     if (halValues != NULL) {
         paramsAndValues.setTo(halValues);
         free(halValues);
@@ -93,7 +111,8 @@
 
 Result ParametersUtil::setParam(const char* name, bool value) {
     AudioParameter param;
-    param.add(String8(name), String8(value ? AudioParameter::valueOn : AudioParameter::valueOff));
+    param.add(String8(name), String8(value ? AudioParameter::valueOn
+                                           : AudioParameter::valueOff));
     return setParams(param);
 }
 
@@ -109,10 +128,12 @@
     return setParams(param);
 }
 
-Result ParametersUtil::setParametersImpl(const hidl_vec<ParameterValue>& parameters)  {
+Result ParametersUtil::setParametersImpl(
+    const hidl_vec<ParameterValue>& parameters) {
     AudioParameter params;
     for (size_t i = 0; i < parameters.size(); ++i) {
-        params.add(String8(parameters[i].key.c_str()), String8(parameters[i].value.c_str()));
+        params.add(String8(parameters[i].key.c_str()),
+                   String8(parameters[i].value.c_str()));
     }
     return setParams(params);
 }
diff --git a/audio/2.0/default/PrimaryDevice.cpp b/audio/2.0/default/PrimaryDevice.cpp
index af0b249..4e8f30f 100644
--- a/audio/2.0/default/PrimaryDevice.cpp
+++ b/audio/2.0/default/PrimaryDevice.cpp
@@ -30,56 +30,52 @@
 PrimaryDevice::~PrimaryDevice() {}
 
 // Methods from ::android::hardware::audio::V2_0::IDevice follow.
-Return<Result> PrimaryDevice::initCheck()  {
+Return<Result> PrimaryDevice::initCheck() {
     return mDevice->initCheck();
 }
 
-Return<Result> PrimaryDevice::setMasterVolume(float volume)  {
+Return<Result> PrimaryDevice::setMasterVolume(float volume) {
     return mDevice->setMasterVolume(volume);
 }
 
-Return<void> PrimaryDevice::getMasterVolume(getMasterVolume_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getMasterVolume(getMasterVolume_cb _hidl_cb) {
     return mDevice->getMasterVolume(_hidl_cb);
 }
 
-Return<Result> PrimaryDevice::setMicMute(bool mute)  {
+Return<Result> PrimaryDevice::setMicMute(bool mute) {
     return mDevice->setMicMute(mute);
 }
 
-Return<void> PrimaryDevice::getMicMute(getMicMute_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getMicMute(getMicMute_cb _hidl_cb) {
     return mDevice->getMicMute(_hidl_cb);
 }
 
-Return<Result> PrimaryDevice::setMasterMute(bool mute)  {
+Return<Result> PrimaryDevice::setMasterMute(bool mute) {
     return mDevice->setMasterMute(mute);
 }
 
-Return<void> PrimaryDevice::getMasterMute(getMasterMute_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getMasterMute(getMasterMute_cb _hidl_cb) {
     return mDevice->getMasterMute(_hidl_cb);
 }
 
-Return<void> PrimaryDevice::getInputBufferSize(
-        const AudioConfig& config, getInputBufferSize_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getInputBufferSize(const AudioConfig& config,
+                                               getInputBufferSize_cb _hidl_cb) {
     return mDevice->getInputBufferSize(config, _hidl_cb);
 }
 
-Return<void> PrimaryDevice::openOutputStream(
-        int32_t ioHandle,
-        const DeviceAddress& device,
-        const AudioConfig& config,
-        AudioOutputFlag flags,
-        openOutputStream_cb _hidl_cb)  {
+Return<void> PrimaryDevice::openOutputStream(int32_t ioHandle,
+                                             const DeviceAddress& device,
+                                             const AudioConfig& config,
+                                             AudioOutputFlag flags,
+                                             openOutputStream_cb _hidl_cb) {
     return mDevice->openOutputStream(ioHandle, device, config, flags, _hidl_cb);
 }
 
 Return<void> PrimaryDevice::openInputStream(
-        int32_t ioHandle,
-        const DeviceAddress& device,
-        const AudioConfig& config,
-        AudioInputFlag flags,
-        AudioSource source,
-        openInputStream_cb _hidl_cb)  {
-    return mDevice->openInputStream(ioHandle, device, config, flags, source, _hidl_cb);
+    int32_t ioHandle, const DeviceAddress& device, const AudioConfig& config,
+    AudioInputFlag flags, AudioSource source, openInputStream_cb _hidl_cb) {
+    return mDevice->openInputStream(ioHandle, device, config, flags, source,
+                                    _hidl_cb);
 }
 
 Return<bool> PrimaryDevice::supportsAudioPatches() {
@@ -87,82 +83,97 @@
 }
 
 Return<void> PrimaryDevice::createAudioPatch(
-        const hidl_vec<AudioPortConfig>& sources,
-        const hidl_vec<AudioPortConfig>& sinks,
-        createAudioPatch_cb _hidl_cb)  {
+    const hidl_vec<AudioPortConfig>& sources,
+    const hidl_vec<AudioPortConfig>& sinks, createAudioPatch_cb _hidl_cb) {
     return mDevice->createAudioPatch(sources, sinks, _hidl_cb);
 }
 
-Return<Result> PrimaryDevice::releaseAudioPatch(int32_t patch)  {
+Return<Result> PrimaryDevice::releaseAudioPatch(int32_t patch) {
     return mDevice->releaseAudioPatch(patch);
 }
 
-Return<void> PrimaryDevice::getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getAudioPort(const AudioPort& port,
+                                         getAudioPort_cb _hidl_cb) {
     return mDevice->getAudioPort(port, _hidl_cb);
 }
 
-Return<Result> PrimaryDevice::setAudioPortConfig(const AudioPortConfig& config)  {
+Return<Result> PrimaryDevice::setAudioPortConfig(
+    const AudioPortConfig& config) {
     return mDevice->setAudioPortConfig(config);
 }
 
-Return<AudioHwSync> PrimaryDevice::getHwAvSync()  {
+Return<AudioHwSync> PrimaryDevice::getHwAvSync() {
     return mDevice->getHwAvSync();
 }
 
-Return<Result> PrimaryDevice::setScreenState(bool turnedOn)  {
+Return<Result> PrimaryDevice::setScreenState(bool turnedOn) {
     return mDevice->setScreenState(turnedOn);
 }
 
-Return<void> PrimaryDevice::getParameters(
-        const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getParameters(const hidl_vec<hidl_string>& keys,
+                                          getParameters_cb _hidl_cb) {
     return mDevice->getParameters(keys, _hidl_cb);
 }
 
-Return<Result> PrimaryDevice::setParameters(const hidl_vec<ParameterValue>& parameters)  {
+Return<Result> PrimaryDevice::setParameters(
+    const hidl_vec<ParameterValue>& parameters) {
     return mDevice->setParameters(parameters);
 }
 
-Return<void> PrimaryDevice::debugDump(const hidl_handle& fd)  {
+Return<void> PrimaryDevice::debugDump(const hidl_handle& fd) {
     return mDevice->debugDump(fd);
 }
 
-
 // Methods from ::android::hardware::audio::V2_0::IPrimaryDevice follow.
-Return<Result> PrimaryDevice::setVoiceVolume(float volume)  {
+Return<Result> PrimaryDevice::setVoiceVolume(float volume) {
     return mDevice->analyzeStatus(
-            "set_voice_volume",
-            mDevice->device()->set_voice_volume(mDevice->device(), volume));
+        "set_voice_volume",
+        mDevice->device()->set_voice_volume(mDevice->device(), volume));
 }
 
-Return<Result> PrimaryDevice::setMode(AudioMode mode)  {
+Return<Result> PrimaryDevice::setMode(AudioMode mode) {
+    // INVALID, CURRENT, CNT, MAX are reserved for internal use.
+    // TODO: remove the values from the HIDL interface
+    switch (mode) {
+        case AudioMode::NORMAL:
+        case AudioMode::RINGTONE:
+        case AudioMode::IN_CALL:
+        case AudioMode::IN_COMMUNICATION:
+            break;  // Valid values
+        default:
+            return Result::INVALID_ARGUMENTS;
+    };
+
     return mDevice->analyzeStatus(
-            "set_mode",
-            mDevice->device()->set_mode(mDevice->device(), static_cast<audio_mode_t>(mode)));
+        "set_mode", mDevice->device()->set_mode(
+                        mDevice->device(), static_cast<audio_mode_t>(mode)));
 }
 
-Return<void> PrimaryDevice::getBtScoNrecEnabled(getBtScoNrecEnabled_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getBtScoNrecEnabled(
+    getBtScoNrecEnabled_cb _hidl_cb) {
     bool enabled;
     Result retval = mDevice->getParam(AudioParameter::keyBtNrec, &enabled);
     _hidl_cb(retval, enabled);
     return Void();
 }
 
-Return<Result> PrimaryDevice::setBtScoNrecEnabled(bool enabled)  {
+Return<Result> PrimaryDevice::setBtScoNrecEnabled(bool enabled) {
     return mDevice->setParam(AudioParameter::keyBtNrec, enabled);
 }
 
-Return<void> PrimaryDevice::getBtScoWidebandEnabled(getBtScoWidebandEnabled_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getBtScoWidebandEnabled(
+    getBtScoWidebandEnabled_cb _hidl_cb) {
     bool enabled;
     Result retval = mDevice->getParam(AUDIO_PARAMETER_KEY_BT_SCO_WB, &enabled);
     _hidl_cb(retval, enabled);
     return Void();
 }
 
-Return<Result> PrimaryDevice::setBtScoWidebandEnabled(bool enabled)  {
+Return<Result> PrimaryDevice::setBtScoWidebandEnabled(bool enabled) {
     return mDevice->setParam(AUDIO_PARAMETER_KEY_BT_SCO_WB, enabled);
 }
 
-Return<void> PrimaryDevice::getTtyMode(getTtyMode_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getTtyMode(getTtyMode_cb _hidl_cb) {
     int halMode;
     Result retval = mDevice->getParam(AUDIO_PARAMETER_KEY_TTY_MODE, &halMode);
     TtyMode mode = retval == Result::OK ? TtyMode(halMode) : TtyMode::OFF;
@@ -170,18 +181,19 @@
     return Void();
 }
 
-Return<Result> PrimaryDevice::setTtyMode(IPrimaryDevice::TtyMode mode)  {
-    return mDevice->setParam(AUDIO_PARAMETER_KEY_TTY_MODE, static_cast<int>(mode));
+Return<Result> PrimaryDevice::setTtyMode(IPrimaryDevice::TtyMode mode) {
+    return mDevice->setParam(AUDIO_PARAMETER_KEY_TTY_MODE,
+                             static_cast<int>(mode));
 }
 
-Return<void> PrimaryDevice::getHacEnabled(getHacEnabled_cb _hidl_cb)  {
+Return<void> PrimaryDevice::getHacEnabled(getHacEnabled_cb _hidl_cb) {
     bool enabled;
     Result retval = mDevice->getParam(AUDIO_PARAMETER_KEY_HAC, &enabled);
     _hidl_cb(retval, enabled);
     return Void();
 }
 
-Return<Result> PrimaryDevice::setHacEnabled(bool enabled)  {
+Return<Result> PrimaryDevice::setHacEnabled(bool enabled) {
     return mDevice->setParam(AUDIO_PARAMETER_KEY_HAC, enabled);
 }
 
diff --git a/audio/2.0/default/StreamIn.cpp b/audio/2.0/default/StreamIn.cpp
index e5a1a55..abd0497 100644
--- a/audio/2.0/default/StreamIn.cpp
+++ b/audio/2.0/default/StreamIn.cpp
@@ -20,10 +20,11 @@
 
 #include <android/log.h>
 #include <hardware/audio.h>
-#include <memory>
 #include <utils/Trace.h>
+#include <memory>
 
 #include "StreamIn.h"
+#include "Util.h"
 
 using ::android::hardware::audio::V2_0::MessageQueueFlagBits;
 
@@ -38,30 +39,26 @@
 namespace {
 
 class ReadThread : public Thread {
-  public:
+   public:
     // ReadThread's lifespan never exceeds StreamIn's lifespan.
-    ReadThread(std::atomic<bool>* stop,
-            audio_stream_in_t* stream,
-            StreamIn::CommandMQ* commandMQ,
-            StreamIn::DataMQ* dataMQ,
-            StreamIn::StatusMQ* statusMQ,
-            EventFlag* efGroup)
-            : Thread(false /*canCallJava*/),
-              mStop(stop),
-              mStream(stream),
-              mCommandMQ(commandMQ),
-              mDataMQ(dataMQ),
-              mStatusMQ(statusMQ),
-              mEfGroup(efGroup),
-              mBuffer(nullptr) {
-    }
+    ReadThread(std::atomic<bool>* stop, audio_stream_in_t* stream,
+               StreamIn::CommandMQ* commandMQ, StreamIn::DataMQ* dataMQ,
+               StreamIn::StatusMQ* statusMQ, EventFlag* efGroup)
+        : Thread(false /*canCallJava*/),
+          mStop(stop),
+          mStream(stream),
+          mCommandMQ(commandMQ),
+          mDataMQ(dataMQ),
+          mStatusMQ(statusMQ),
+          mEfGroup(efGroup),
+          mBuffer(nullptr) {}
     bool init() {
-        mBuffer.reset(new(std::nothrow) uint8_t[mDataMQ->getQuantumCount()]);
+        mBuffer.reset(new (std::nothrow) uint8_t[mDataMQ->getQuantumCount()]);
         return mBuffer != nullptr;
     }
     virtual ~ReadThread() {}
 
-  private:
+   private:
     std::atomic<bool>* mStop;
     audio_stream_in_t* mStream;
     StreamIn::CommandMQ* mCommandMQ;
@@ -82,8 +79,10 @@
     size_t availableToWrite = mDataMQ->availableToWrite();
     size_t requestedToRead = mParameters.params.read;
     if (requestedToRead > availableToWrite) {
-        ALOGW("truncating read data from %d to %d due to insufficient data queue space",
-                (int32_t)requestedToRead, (int32_t)availableToWrite);
+        ALOGW(
+            "truncating read data from %d to %d due to insufficient data queue "
+            "space",
+            (int32_t)requestedToRead, (int32_t)availableToWrite);
         requestedToRead = availableToWrite;
     }
     ssize_t readResult = mStream->read(mStream, &mBuffer[0], requestedToRead);
@@ -101,16 +100,20 @@
 
 void ReadThread::doGetCapturePosition() {
     mStatus.retval = StreamIn::getCapturePositionImpl(
-            mStream, &mStatus.reply.capturePosition.frames, &mStatus.reply.capturePosition.time);
+        mStream, &mStatus.reply.capturePosition.frames,
+        &mStatus.reply.capturePosition.time);
 }
 
 bool ReadThread::threadLoop() {
-    // This implementation doesn't return control back to the Thread until it decides to stop,
+    // This implementation doesn't return control back to the Thread until it
+    // decides to stop,
     // as the Thread uses mutexes, and this can lead to priority inversion.
-    while(!std::atomic_load_explicit(mStop, std::memory_order_acquire)) {
+    while (!std::atomic_load_explicit(mStop, std::memory_order_acquire)) {
         uint32_t efState = 0;
-        mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL), &efState);
-        if (!(efState & static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL))) {
+        mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL),
+                       &efState);
+        if (!(efState &
+              static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL))) {
             continue;  // Nothing to do.
         }
         if (!mCommandMQ->read(&mParameters)) {
@@ -125,7 +128,8 @@
                 doGetCapturePosition();
                 break;
             default:
-                ALOGE("Unknown read thread command code %d", mParameters.command);
+                ALOGE("Unknown read thread command code %d",
+                      mParameters.command);
                 mStatus.retval = Result::NOT_SUPPORTED;
                 break;
         }
@@ -141,11 +145,13 @@
 }  // namespace
 
 StreamIn::StreamIn(const sp<Device>& device, audio_stream_in_t* stream)
-        : mIsClosed(false), mDevice(device), mStream(stream),
-          mStreamCommon(new Stream(&stream->common)),
-          mStreamMmap(new StreamMmap<audio_stream_in_t>(stream)),
-          mEfGroup(nullptr), mStopReadThread(false) {
-}
+    : mIsClosed(false),
+      mDevice(device),
+      mStream(stream),
+      mStreamCommon(new Stream(&stream->common)),
+      mStreamMmap(new StreamMmap<audio_stream_in_t>(stream)),
+      mEfGroup(nullptr),
+      mStopReadThread(false) {}
 
 StreamIn::~StreamIn() {
     ATRACE_CALL();
@@ -157,102 +163,108 @@
     }
     if (mEfGroup) {
         status_t status = EventFlag::deleteEventFlag(&mEfGroup);
-        ALOGE_IF(status, "read MQ event flag deletion error: %s", strerror(-status));
+        ALOGE_IF(status, "read MQ event flag deletion error: %s",
+                 strerror(-status));
     }
     mDevice->closeInputStream(mStream);
     mStream = nullptr;
 }
 
 // Methods from ::android::hardware::audio::V2_0::IStream follow.
-Return<uint64_t> StreamIn::getFrameSize()  {
+Return<uint64_t> StreamIn::getFrameSize() {
     return audio_stream_in_frame_size(mStream);
 }
 
-Return<uint64_t> StreamIn::getFrameCount()  {
+Return<uint64_t> StreamIn::getFrameCount() {
     return mStreamCommon->getFrameCount();
 }
 
-Return<uint64_t> StreamIn::getBufferSize()  {
+Return<uint64_t> StreamIn::getBufferSize() {
     return mStreamCommon->getBufferSize();
 }
 
-Return<uint32_t> StreamIn::getSampleRate()  {
+Return<uint32_t> StreamIn::getSampleRate() {
     return mStreamCommon->getSampleRate();
 }
 
-Return<void> StreamIn::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb)  {
+Return<void> StreamIn::getSupportedSampleRates(
+    getSupportedSampleRates_cb _hidl_cb) {
     return mStreamCommon->getSupportedSampleRates(_hidl_cb);
 }
 
-Return<Result> StreamIn::setSampleRate(uint32_t sampleRateHz)  {
+Return<Result> StreamIn::setSampleRate(uint32_t sampleRateHz) {
     return mStreamCommon->setSampleRate(sampleRateHz);
 }
 
-Return<AudioChannelMask> StreamIn::getChannelMask()  {
+Return<AudioChannelMask> StreamIn::getChannelMask() {
     return mStreamCommon->getChannelMask();
 }
 
-Return<void> StreamIn::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb)  {
+Return<void> StreamIn::getSupportedChannelMasks(
+    getSupportedChannelMasks_cb _hidl_cb) {
     return mStreamCommon->getSupportedChannelMasks(_hidl_cb);
 }
 
-Return<Result> StreamIn::setChannelMask(AudioChannelMask mask)  {
+Return<Result> StreamIn::setChannelMask(AudioChannelMask mask) {
     return mStreamCommon->setChannelMask(mask);
 }
 
-Return<AudioFormat> StreamIn::getFormat()  {
+Return<AudioFormat> StreamIn::getFormat() {
     return mStreamCommon->getFormat();
 }
 
-Return<void> StreamIn::getSupportedFormats(getSupportedFormats_cb _hidl_cb)  {
+Return<void> StreamIn::getSupportedFormats(getSupportedFormats_cb _hidl_cb) {
     return mStreamCommon->getSupportedFormats(_hidl_cb);
 }
 
-Return<Result> StreamIn::setFormat(AudioFormat format)  {
+Return<Result> StreamIn::setFormat(AudioFormat format) {
     return mStreamCommon->setFormat(format);
 }
 
-Return<void> StreamIn::getAudioProperties(getAudioProperties_cb _hidl_cb)  {
+Return<void> StreamIn::getAudioProperties(getAudioProperties_cb _hidl_cb) {
     return mStreamCommon->getAudioProperties(_hidl_cb);
 }
 
-Return<Result> StreamIn::addEffect(uint64_t effectId)  {
+Return<Result> StreamIn::addEffect(uint64_t effectId) {
     return mStreamCommon->addEffect(effectId);
 }
 
-Return<Result> StreamIn::removeEffect(uint64_t effectId)  {
+Return<Result> StreamIn::removeEffect(uint64_t effectId) {
     return mStreamCommon->removeEffect(effectId);
 }
 
-Return<Result> StreamIn::standby()  {
+Return<Result> StreamIn::standby() {
     return mStreamCommon->standby();
 }
 
-Return<AudioDevice> StreamIn::getDevice()  {
+Return<AudioDevice> StreamIn::getDevice() {
     return mStreamCommon->getDevice();
 }
 
-Return<Result> StreamIn::setDevice(const DeviceAddress& address)  {
+Return<Result> StreamIn::setDevice(const DeviceAddress& address) {
     return mStreamCommon->setDevice(address);
 }
 
-Return<Result> StreamIn::setConnectedState(const DeviceAddress& address, bool connected)  {
+Return<Result> StreamIn::setConnectedState(const DeviceAddress& address,
+                                           bool connected) {
     return mStreamCommon->setConnectedState(address, connected);
 }
 
-Return<Result> StreamIn::setHwAvSync(uint32_t hwAvSync)  {
+Return<Result> StreamIn::setHwAvSync(uint32_t hwAvSync) {
     return mStreamCommon->setHwAvSync(hwAvSync);
 }
 
-Return<void> StreamIn::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) {
+Return<void> StreamIn::getParameters(const hidl_vec<hidl_string>& keys,
+                                     getParameters_cb _hidl_cb) {
     return mStreamCommon->getParameters(keys, _hidl_cb);
 }
 
-Return<Result> StreamIn::setParameters(const hidl_vec<ParameterValue>& parameters)  {
+Return<Result> StreamIn::setParameters(
+    const hidl_vec<ParameterValue>& parameters) {
     return mStreamCommon->setParameters(parameters);
 }
 
-Return<void> StreamIn::debugDump(const hidl_handle& fd)  {
+Return<void> StreamIn::debugDump(const hidl_handle& fd) {
     return mStreamCommon->debugDump(fd);
 }
 
@@ -264,16 +276,17 @@
     return mStreamMmap->stop();
 }
 
-Return<void> StreamIn::createMmapBuffer(int32_t minSizeFrames, createMmapBuffer_cb _hidl_cb) {
+Return<void> StreamIn::createMmapBuffer(int32_t minSizeFrames,
+                                        createMmapBuffer_cb _hidl_cb) {
     return mStreamMmap->createMmapBuffer(
-            minSizeFrames, audio_stream_in_frame_size(mStream), _hidl_cb);
+        minSizeFrames, audio_stream_in_frame_size(mStream), _hidl_cb);
 }
 
 Return<void> StreamIn::getMmapPosition(getMmapPosition_cb _hidl_cb) {
     return mStreamMmap->getMmapPosition(_hidl_cb);
 }
 
-Return<Result> StreamIn::close()  {
+Return<Result> StreamIn::close() {
     if (mIsClosed) return Result::INVALID_STATE;
     mIsClosed = true;
     if (mReadThread.get()) {
@@ -286,9 +299,10 @@
 }
 
 // Methods from ::android::hardware::audio::V2_0::IStreamIn follow.
-Return<void> StreamIn::getAudioSource(getAudioSource_cb _hidl_cb)  {
+Return<void> StreamIn::getAudioSource(getAudioSource_cb _hidl_cb) {
     int halSource;
-    Result retval = mStreamCommon->getParam(AudioParameter::keyInputSource, &halSource);
+    Result retval =
+        mStreamCommon->getParam(AudioParameter::keyInputSource, &halSource);
     AudioSource source(AudioSource::DEFAULT);
     if (retval == Result::OK) {
         source = AudioSource(halSource);
@@ -297,68 +311,89 @@
     return Void();
 }
 
-Return<Result> StreamIn::setGain(float gain)  {
+Return<Result> StreamIn::setGain(float gain) {
+    if (!isGainNormalized(gain)) {
+        ALOGW("Can not set a stream input gain (%f) outside [0,1]", gain);
+        return Result::INVALID_ARGUMENTS;
+    }
     return Stream::analyzeStatus("set_gain", mStream->set_gain(mStream, gain));
 }
 
-Return<void> StreamIn::prepareForReading(
-        uint32_t frameSize, uint32_t framesCount, prepareForReading_cb _hidl_cb)  {
+Return<void> StreamIn::prepareForReading(uint32_t frameSize,
+                                         uint32_t framesCount,
+                                         prepareForReading_cb _hidl_cb) {
     status_t status;
-    ThreadInfo threadInfo = { 0, 0 };
+    ThreadInfo threadInfo = {0, 0};
+
+    // Wrap the _hidl_cb to return an error
+    auto sendError = [this, &threadInfo, &_hidl_cb](Result result) {
+        _hidl_cb(result, CommandMQ::Descriptor(), DataMQ::Descriptor(),
+                 StatusMQ::Descriptor(), threadInfo);
+
+    };
+
     // Create message queues.
     if (mDataMQ) {
         ALOGE("the client attempts to call prepareForReading twice");
-        _hidl_cb(Result::INVALID_STATE,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        sendError(Result::INVALID_STATE);
         return Void();
     }
     std::unique_ptr<CommandMQ> tempCommandMQ(new CommandMQ(1));
-    if (frameSize > std::numeric_limits<size_t>::max() / framesCount) {
-        ALOGE("Requested buffer is too big, %d*%d can not fit in size_t", frameSize, framesCount);
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+
+    // Check frameSize and framesCount
+    if (frameSize == 0 || framesCount == 0) {
+        ALOGE("Null frameSize (%u) or framesCount (%u)", frameSize,
+              framesCount);
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
-    std::unique_ptr<DataMQ> tempDataMQ(new DataMQ(frameSize * framesCount, true /* EventFlag */));
+    // A message queue asserts if it can not handle the requested buffer,
+    // thus the client has to guess the maximum size it can handle
+    // Choose an arbitrary margin for the overhead of a message queue
+    size_t metadataOverhead = 100000;
+    if (frameSize >
+        (std::numeric_limits<size_t>::max() - metadataOverhead) / framesCount) {
+        ALOGE("Buffer too big: %u*%u bytes can not fit in a message queue",
+              frameSize, framesCount);
+        sendError(Result::INVALID_ARGUMENTS);
+        return Void();
+    }
+    std::unique_ptr<DataMQ> tempDataMQ(
+        new DataMQ(frameSize * framesCount, true /* EventFlag */));
 
     std::unique_ptr<StatusMQ> tempStatusMQ(new StatusMQ(1));
-    if (!tempCommandMQ->isValid() || !tempDataMQ->isValid() || !tempStatusMQ->isValid()) {
+    if (!tempCommandMQ->isValid() || !tempDataMQ->isValid() ||
+        !tempStatusMQ->isValid()) {
         ALOGE_IF(!tempCommandMQ->isValid(), "command MQ is invalid");
         ALOGE_IF(!tempDataMQ->isValid(), "data MQ is invalid");
         ALOGE_IF(!tempStatusMQ->isValid(), "status MQ is invalid");
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
     EventFlag* tempRawEfGroup{};
-    status = EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(), &tempRawEfGroup);
-    std::unique_ptr<EventFlag, void(*)(EventFlag*)> tempElfGroup(tempRawEfGroup, [](auto *ef) {
-            EventFlag::deleteEventFlag(&ef); });
+    status = EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(),
+                                        &tempRawEfGroup);
+    std::unique_ptr<EventFlag, void (*)(EventFlag*)> tempElfGroup(
+        tempRawEfGroup, [](auto* ef) { EventFlag::deleteEventFlag(&ef); });
     if (status != OK || !tempElfGroup) {
         ALOGE("failed creating event flag for data MQ: %s", strerror(-status));
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
 
     // Create and launch the thread.
     auto tempReadThread = std::make_unique<ReadThread>(
-            &mStopReadThread,
-            mStream,
-            tempCommandMQ.get(),
-            tempDataMQ.get(),
-            tempStatusMQ.get(),
-            tempElfGroup.get());
+        &mStopReadThread, mStream, tempCommandMQ.get(), tempDataMQ.get(),
+        tempStatusMQ.get(), tempElfGroup.get());
     if (!tempReadThread->init()) {
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        ALOGW("failed to start reader thread: %s", strerror(-status));
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
     status = tempReadThread->run("reader", PRIORITY_URGENT_AUDIO);
     if (status != OK) {
         ALOGW("failed to start reader thread: %s", strerror(-status));
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
 
@@ -369,28 +404,27 @@
     mEfGroup = tempElfGroup.release();
     threadInfo.pid = getpid();
     threadInfo.tid = mReadThread->getTid();
-    _hidl_cb(Result::OK,
-            *mCommandMQ->getDesc(), *mDataMQ->getDesc(), *mStatusMQ->getDesc(),
-            threadInfo);
+    _hidl_cb(Result::OK, *mCommandMQ->getDesc(), *mDataMQ->getDesc(),
+             *mStatusMQ->getDesc(), threadInfo);
     return Void();
 }
 
-Return<uint32_t> StreamIn::getInputFramesLost()  {
+Return<uint32_t> StreamIn::getInputFramesLost() {
     return mStream->get_input_frames_lost(mStream);
 }
 
 // static
-Result StreamIn::getCapturePositionImpl(
-        audio_stream_in_t *stream, uint64_t *frames, uint64_t *time) {
+Result StreamIn::getCapturePositionImpl(audio_stream_in_t* stream,
+                                        uint64_t* frames, uint64_t* time) {
     Result retval(Result::NOT_SUPPORTED);
     if (stream->get_capture_position != NULL) return retval;
     int64_t halFrames, halTime;
     retval = Stream::analyzeStatus(
-            "get_capture_position",
-            stream->get_capture_position(stream, &halFrames, &halTime),
-            // HAL may have a stub function, always returning ENOSYS, don't
-            // spam the log in this case.
-            ENOSYS);
+        "get_capture_position",
+        stream->get_capture_position(stream, &halFrames, &halTime),
+        // HAL may have a stub function, always returning ENOSYS, don't
+        // spam the log in this case.
+        ENOSYS);
     if (retval == Result::OK) {
         *frames = halFrames;
         *time = halTime;
@@ -398,14 +432,14 @@
     return retval;
 };
 
-Return<void> StreamIn::getCapturePosition(getCapturePosition_cb _hidl_cb)  {
+Return<void> StreamIn::getCapturePosition(getCapturePosition_cb _hidl_cb) {
     uint64_t frames = 0, time = 0;
     Result retval = getCapturePositionImpl(mStream, &frames, &time);
     _hidl_cb(retval, frames, time);
     return Void();
 }
 
-} // namespace implementation
+}  // namespace implementation
 }  // namespace V2_0
 }  // namespace audio
 }  // namespace hardware
diff --git a/audio/2.0/default/StreamOut.cpp b/audio/2.0/default/StreamOut.cpp
index 3339b63..e48497f 100644
--- a/audio/2.0/default/StreamOut.cpp
+++ b/audio/2.0/default/StreamOut.cpp
@@ -25,6 +25,7 @@
 #include <utils/Trace.h>
 
 #include "StreamOut.h"
+#include "Util.h"
 
 namespace android {
 namespace hardware {
@@ -37,30 +38,26 @@
 namespace {
 
 class WriteThread : public Thread {
-  public:
+   public:
     // WriteThread's lifespan never exceeds StreamOut's lifespan.
-    WriteThread(std::atomic<bool>* stop,
-            audio_stream_out_t* stream,
-            StreamOut::CommandMQ* commandMQ,
-            StreamOut::DataMQ* dataMQ,
-            StreamOut::StatusMQ* statusMQ,
-            EventFlag* efGroup)
-            : Thread(false /*canCallJava*/),
-              mStop(stop),
-              mStream(stream),
-              mCommandMQ(commandMQ),
-              mDataMQ(dataMQ),
-              mStatusMQ(statusMQ),
-              mEfGroup(efGroup),
-              mBuffer(nullptr) {
-    }
+    WriteThread(std::atomic<bool>* stop, audio_stream_out_t* stream,
+                StreamOut::CommandMQ* commandMQ, StreamOut::DataMQ* dataMQ,
+                StreamOut::StatusMQ* statusMQ, EventFlag* efGroup)
+        : Thread(false /*canCallJava*/),
+          mStop(stop),
+          mStream(stream),
+          mCommandMQ(commandMQ),
+          mDataMQ(dataMQ),
+          mStatusMQ(statusMQ),
+          mEfGroup(efGroup),
+          mBuffer(nullptr) {}
     bool init() {
-        mBuffer.reset(new(std::nothrow) uint8_t[mDataMQ->getQuantumCount()]);
+        mBuffer.reset(new (std::nothrow) uint8_t[mDataMQ->getQuantumCount()]);
         return mBuffer != nullptr;
     }
     virtual ~WriteThread() {}
 
-  private:
+   private:
     std::atomic<bool>* mStop;
     audio_stream_out_t* mStream;
     StreamOut::CommandMQ* mCommandMQ;
@@ -93,9 +90,8 @@
 
 void WriteThread::doGetPresentationPosition() {
     mStatus.retval = StreamOut::getPresentationPositionImpl(
-            mStream,
-            &mStatus.reply.presentationPosition.frames,
-            &mStatus.reply.presentationPosition.timeStamp);
+        mStream, &mStatus.reply.presentationPosition.frames,
+        &mStatus.reply.presentationPosition.timeStamp);
 }
 
 void WriteThread::doGetLatency() {
@@ -104,12 +100,15 @@
 }
 
 bool WriteThread::threadLoop() {
-    // This implementation doesn't return control back to the Thread until it decides to stop,
+    // This implementation doesn't return control back to the Thread until it
+    // decides to stop,
     // as the Thread uses mutexes, and this can lead to priority inversion.
-    while(!std::atomic_load_explicit(mStop, std::memory_order_acquire)) {
+    while (!std::atomic_load_explicit(mStop, std::memory_order_acquire)) {
         uint32_t efState = 0;
-        mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY), &efState);
-        if (!(efState & static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY))) {
+        mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY),
+                       &efState);
+        if (!(efState &
+              static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY))) {
             continue;  // Nothing to do.
         }
         if (!mCommandMQ->read(&mStatus.replyTo)) {
@@ -142,11 +141,13 @@
 }  // namespace
 
 StreamOut::StreamOut(const sp<Device>& device, audio_stream_out_t* stream)
-        : mIsClosed(false), mDevice(device), mStream(stream),
-          mStreamCommon(new Stream(&stream->common)),
-          mStreamMmap(new StreamMmap<audio_stream_out_t>(stream)),
-          mEfGroup(nullptr), mStopWriteThread(false) {
-}
+    : mIsClosed(false),
+      mDevice(device),
+      mStream(stream),
+      mStreamCommon(new Stream(&stream->common)),
+      mStreamMmap(new StreamMmap<audio_stream_out_t>(stream)),
+      mEfGroup(nullptr),
+      mStopWriteThread(false) {}
 
 StreamOut::~StreamOut() {
     ATRACE_CALL();
@@ -158,7 +159,8 @@
     }
     if (mEfGroup) {
         status_t status = EventFlag::deleteEventFlag(&mEfGroup);
-        ALOGE_IF(status, "write MQ event flag deletion error: %s", strerror(-status));
+        ALOGE_IF(status, "write MQ event flag deletion error: %s",
+                 strerror(-status));
     }
     mCallback.clear();
     mDevice->closeOutputStream(mStream);
@@ -166,100 +168,104 @@
 }
 
 // Methods from ::android::hardware::audio::V2_0::IStream follow.
-Return<uint64_t> StreamOut::getFrameSize()  {
+Return<uint64_t> StreamOut::getFrameSize() {
     return audio_stream_out_frame_size(mStream);
 }
 
-Return<uint64_t> StreamOut::getFrameCount()  {
+Return<uint64_t> StreamOut::getFrameCount() {
     return mStreamCommon->getFrameCount();
 }
 
-Return<uint64_t> StreamOut::getBufferSize()  {
+Return<uint64_t> StreamOut::getBufferSize() {
     return mStreamCommon->getBufferSize();
 }
 
-Return<uint32_t> StreamOut::getSampleRate()  {
+Return<uint32_t> StreamOut::getSampleRate() {
     return mStreamCommon->getSampleRate();
 }
 
-Return<void> StreamOut::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb)  {
+Return<void> StreamOut::getSupportedSampleRates(
+    getSupportedSampleRates_cb _hidl_cb) {
     return mStreamCommon->getSupportedSampleRates(_hidl_cb);
 }
 
-Return<Result> StreamOut::setSampleRate(uint32_t sampleRateHz)  {
+Return<Result> StreamOut::setSampleRate(uint32_t sampleRateHz) {
     return mStreamCommon->setSampleRate(sampleRateHz);
 }
 
-Return<AudioChannelMask> StreamOut::getChannelMask()  {
+Return<AudioChannelMask> StreamOut::getChannelMask() {
     return mStreamCommon->getChannelMask();
 }
 
-Return<void> StreamOut::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb)  {
+Return<void> StreamOut::getSupportedChannelMasks(
+    getSupportedChannelMasks_cb _hidl_cb) {
     return mStreamCommon->getSupportedChannelMasks(_hidl_cb);
 }
 
-Return<Result> StreamOut::setChannelMask(AudioChannelMask mask)  {
+Return<Result> StreamOut::setChannelMask(AudioChannelMask mask) {
     return mStreamCommon->setChannelMask(mask);
 }
 
-Return<AudioFormat> StreamOut::getFormat()  {
+Return<AudioFormat> StreamOut::getFormat() {
     return mStreamCommon->getFormat();
 }
 
-Return<void> StreamOut::getSupportedFormats(getSupportedFormats_cb _hidl_cb)  {
+Return<void> StreamOut::getSupportedFormats(getSupportedFormats_cb _hidl_cb) {
     return mStreamCommon->getSupportedFormats(_hidl_cb);
 }
 
-Return<Result> StreamOut::setFormat(AudioFormat format)  {
+Return<Result> StreamOut::setFormat(AudioFormat format) {
     return mStreamCommon->setFormat(format);
 }
 
-Return<void> StreamOut::getAudioProperties(getAudioProperties_cb _hidl_cb)  {
+Return<void> StreamOut::getAudioProperties(getAudioProperties_cb _hidl_cb) {
     return mStreamCommon->getAudioProperties(_hidl_cb);
 }
 
-Return<Result> StreamOut::addEffect(uint64_t effectId)  {
+Return<Result> StreamOut::addEffect(uint64_t effectId) {
     return mStreamCommon->addEffect(effectId);
 }
 
-Return<Result> StreamOut::removeEffect(uint64_t effectId)  {
+Return<Result> StreamOut::removeEffect(uint64_t effectId) {
     return mStreamCommon->removeEffect(effectId);
 }
 
-Return<Result> StreamOut::standby()  {
+Return<Result> StreamOut::standby() {
     return mStreamCommon->standby();
 }
 
-Return<AudioDevice> StreamOut::getDevice()  {
+Return<AudioDevice> StreamOut::getDevice() {
     return mStreamCommon->getDevice();
 }
 
-Return<Result> StreamOut::setDevice(const DeviceAddress& address)  {
+Return<Result> StreamOut::setDevice(const DeviceAddress& address) {
     return mStreamCommon->setDevice(address);
 }
 
-Return<Result> StreamOut::setConnectedState(const DeviceAddress& address, bool connected)  {
+Return<Result> StreamOut::setConnectedState(const DeviceAddress& address,
+                                            bool connected) {
     return mStreamCommon->setConnectedState(address, connected);
 }
 
-Return<Result> StreamOut::setHwAvSync(uint32_t hwAvSync)  {
+Return<Result> StreamOut::setHwAvSync(uint32_t hwAvSync) {
     return mStreamCommon->setHwAvSync(hwAvSync);
 }
 
-Return<void> StreamOut::getParameters(
-        const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  {
+Return<void> StreamOut::getParameters(const hidl_vec<hidl_string>& keys,
+                                      getParameters_cb _hidl_cb) {
     return mStreamCommon->getParameters(keys, _hidl_cb);
 }
 
-Return<Result> StreamOut::setParameters(const hidl_vec<ParameterValue>& parameters)  {
+Return<Result> StreamOut::setParameters(
+    const hidl_vec<ParameterValue>& parameters) {
     return mStreamCommon->setParameters(parameters);
 }
 
-Return<void> StreamOut::debugDump(const hidl_handle& fd)  {
+Return<void> StreamOut::debugDump(const hidl_handle& fd) {
     return mStreamCommon->debugDump(fd);
 }
 
-Return<Result> StreamOut::close()  {
+Return<Result> StreamOut::close() {
     if (mIsClosed) return Result::INVALID_STATE;
     mIsClosed = true;
     if (mWriteThread.get()) {
@@ -272,78 +278,98 @@
 }
 
 // Methods from ::android::hardware::audio::V2_0::IStreamOut follow.
-Return<uint32_t> StreamOut::getLatency()  {
+Return<uint32_t> StreamOut::getLatency() {
     return mStream->get_latency(mStream);
 }
 
-Return<Result> StreamOut::setVolume(float left, float right)  {
-    Result retval(Result::NOT_SUPPORTED);
-    if (mStream->set_volume != NULL) {
-        retval = Stream::analyzeStatus(
-                "set_volume", mStream->set_volume(mStream, left, right));
+Return<Result> StreamOut::setVolume(float left, float right) {
+    if (mStream->set_volume == NULL) {
+        return Result::NOT_SUPPORTED;
     }
-    return retval;
+    if (!isGainNormalized(left)) {
+        ALOGW("Can not set a stream output volume {%f, %f} outside [0,1]", left,
+              right);
+        return Result::INVALID_ARGUMENTS;
+    }
+    return Stream::analyzeStatus("set_volume",
+                                 mStream->set_volume(mStream, left, right));
 }
 
-Return<void> StreamOut::prepareForWriting(
-        uint32_t frameSize, uint32_t framesCount, prepareForWriting_cb _hidl_cb)  {
+Return<void> StreamOut::prepareForWriting(uint32_t frameSize,
+                                          uint32_t framesCount,
+                                          prepareForWriting_cb _hidl_cb) {
     status_t status;
-    ThreadInfo threadInfo = { 0, 0 };
+    ThreadInfo threadInfo = {0, 0};
+
+    // Wrap the _hidl_cb to return an error
+    auto sendError = [this, &threadInfo, &_hidl_cb](Result result) {
+        _hidl_cb(result, CommandMQ::Descriptor(), DataMQ::Descriptor(),
+                 StatusMQ::Descriptor(), threadInfo);
+
+    };
+
     // Create message queues.
     if (mDataMQ) {
         ALOGE("the client attempts to call prepareForWriting twice");
-        _hidl_cb(Result::INVALID_STATE,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        sendError(Result::INVALID_STATE);
         return Void();
     }
     std::unique_ptr<CommandMQ> tempCommandMQ(new CommandMQ(1));
 
-    if (frameSize > std::numeric_limits<size_t>::max() / framesCount) {
-        ALOGE("Requested buffer is too big, %d*%d can not fit in size_t", frameSize, framesCount);
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+    // Check frameSize and framesCount
+    if (frameSize == 0 || framesCount == 0) {
+        ALOGE("Null frameSize (%u) or framesCount (%u)", frameSize,
+              framesCount);
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
-    std::unique_ptr<DataMQ> tempDataMQ(new DataMQ(frameSize * framesCount, true /* EventFlag */));
+    // A message queue asserts if it can not handle the requested buffer,
+    // thus the client has to guess the maximum size it can handle
+    size_t metadataOverhead =
+        100000;  // Arbitrary margin for the overhead of a message queue
+    if (frameSize >
+        (std::numeric_limits<size_t>::max() - metadataOverhead) / framesCount) {
+        ALOGE("Buffer too big: %u*%u bytes can not fit in a message queue",
+              frameSize, framesCount);
+        sendError(Result::INVALID_ARGUMENTS);
+        return Void();
+    }
+    std::unique_ptr<DataMQ> tempDataMQ(
+        new DataMQ(frameSize * framesCount, true /* EventFlag */));
 
     std::unique_ptr<StatusMQ> tempStatusMQ(new StatusMQ(1));
-    if (!tempCommandMQ->isValid() || !tempDataMQ->isValid() || !tempStatusMQ->isValid()) {
+    if (!tempCommandMQ->isValid() || !tempDataMQ->isValid() ||
+        !tempStatusMQ->isValid()) {
         ALOGE_IF(!tempCommandMQ->isValid(), "command MQ is invalid");
         ALOGE_IF(!tempDataMQ->isValid(), "data MQ is invalid");
         ALOGE_IF(!tempStatusMQ->isValid(), "status MQ is invalid");
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
     EventFlag* tempRawEfGroup{};
-    status = EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(), &tempRawEfGroup);
-    std::unique_ptr<EventFlag, void(*)(EventFlag*)> tempElfGroup(tempRawEfGroup,[](auto *ef) {
-            EventFlag::deleteEventFlag(&ef); });
+    status = EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(),
+                                        &tempRawEfGroup);
+    std::unique_ptr<EventFlag, void (*)(EventFlag*)> tempElfGroup(
+        tempRawEfGroup, [](auto* ef) { EventFlag::deleteEventFlag(&ef); });
     if (status != OK || !tempElfGroup) {
         ALOGE("failed creating event flag for data MQ: %s", strerror(-status));
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
 
     // Create and launch the thread.
     auto tempWriteThread = std::make_unique<WriteThread>(
-            &mStopWriteThread,
-            mStream,
-            tempCommandMQ.get(),
-            tempDataMQ.get(),
-            tempStatusMQ.get(),
-            tempElfGroup.get());
+        &mStopWriteThread, mStream, tempCommandMQ.get(), tempDataMQ.get(),
+        tempStatusMQ.get(), tempElfGroup.get());
     if (!tempWriteThread->init()) {
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                 CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        ALOGW("failed to start writer thread: %s", strerror(-status));
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
     status = tempWriteThread->run("writer", PRIORITY_URGENT_AUDIO);
     if (status != OK) {
         ALOGW("failed to start writer thread: %s", strerror(-status));
-        _hidl_cb(Result::INVALID_ARGUMENTS,
-                CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
+        sendError(Result::INVALID_ARGUMENTS);
         return Void();
     }
 
@@ -354,33 +380,34 @@
     mEfGroup = tempElfGroup.release();
     threadInfo.pid = getpid();
     threadInfo.tid = mWriteThread->getTid();
-    _hidl_cb(Result::OK,
-            *mCommandMQ->getDesc(), *mDataMQ->getDesc(), *mStatusMQ->getDesc(),
-            threadInfo);
+    _hidl_cb(Result::OK, *mCommandMQ->getDesc(), *mDataMQ->getDesc(),
+             *mStatusMQ->getDesc(), threadInfo);
     return Void();
 }
 
-Return<void> StreamOut::getRenderPosition(getRenderPosition_cb _hidl_cb)  {
+Return<void> StreamOut::getRenderPosition(getRenderPosition_cb _hidl_cb) {
     uint32_t halDspFrames;
     Result retval = Stream::analyzeStatus(
-            "get_render_position", mStream->get_render_position(mStream, &halDspFrames));
+        "get_render_position",
+        mStream->get_render_position(mStream, &halDspFrames));
     _hidl_cb(retval, halDspFrames);
     return Void();
 }
 
-Return<void> StreamOut::getNextWriteTimestamp(getNextWriteTimestamp_cb _hidl_cb)  {
+Return<void> StreamOut::getNextWriteTimestamp(
+    getNextWriteTimestamp_cb _hidl_cb) {
     Result retval(Result::NOT_SUPPORTED);
     int64_t timestampUs = 0;
     if (mStream->get_next_write_timestamp != NULL) {
         retval = Stream::analyzeStatus(
-                "get_next_write_timestamp",
-                mStream->get_next_write_timestamp(mStream, &timestampUs));
+            "get_next_write_timestamp",
+            mStream->get_next_write_timestamp(mStream, &timestampUs));
     }
     _hidl_cb(retval, timestampUs);
     return Void();
 }
 
-Return<Result> StreamOut::setCallback(const sp<IStreamOutCallback>& callback)  {
+Return<Result> StreamOut::setCallback(const sp<IStreamOutCallback>& callback) {
     if (mStream->set_callback == NULL) return Result::NOT_SUPPORTED;
     int result = mStream->set_callback(mStream, StreamOut::asyncCallback, this);
     if (result == 0) {
@@ -389,14 +416,15 @@
     return Stream::analyzeStatus("set_callback", result);
 }
 
-Return<Result> StreamOut::clearCallback()  {
+Return<Result> StreamOut::clearCallback() {
     if (mStream->set_callback == NULL) return Result::NOT_SUPPORTED;
     mCallback.clear();
     return Result::OK;
 }
 
 // static
-int StreamOut::asyncCallback(stream_callback_event_t event, void*, void *cookie) {
+int StreamOut::asyncCallback(stream_callback_event_t event, void*,
+                             void* cookie) {
     wp<StreamOut> weakSelf(reinterpret_cast<StreamOut*>(cookie));
     sp<StreamOut> self = weakSelf.promote();
     if (self == nullptr || self->mCallback == nullptr) return 0;
@@ -418,53 +446,57 @@
     return 0;
 }
 
-Return<void> StreamOut::supportsPauseAndResume(supportsPauseAndResume_cb _hidl_cb)  {
+Return<void> StreamOut::supportsPauseAndResume(
+    supportsPauseAndResume_cb _hidl_cb) {
     _hidl_cb(mStream->pause != NULL, mStream->resume != NULL);
     return Void();
 }
 
-Return<Result> StreamOut::pause()  {
-    return mStream->pause != NULL ?
-            Stream::analyzeStatus("pause", mStream->pause(mStream)) :
-            Result::NOT_SUPPORTED;
+Return<Result> StreamOut::pause() {
+    return mStream->pause != NULL
+               ? Stream::analyzeStatus("pause", mStream->pause(mStream))
+               : Result::NOT_SUPPORTED;
 }
 
-Return<Result> StreamOut::resume()  {
-    return mStream->resume != NULL ?
-            Stream::analyzeStatus("resume", mStream->resume(mStream)) :
-            Result::NOT_SUPPORTED;
+Return<Result> StreamOut::resume() {
+    return mStream->resume != NULL
+               ? Stream::analyzeStatus("resume", mStream->resume(mStream))
+               : Result::NOT_SUPPORTED;
 }
 
-Return<bool> StreamOut::supportsDrain()  {
+Return<bool> StreamOut::supportsDrain() {
     return mStream->drain != NULL;
 }
 
-Return<Result> StreamOut::drain(AudioDrain type)  {
-    return mStream->drain != NULL ?
-            Stream::analyzeStatus(
-                    "drain", mStream->drain(mStream, static_cast<audio_drain_type_t>(type))) :
-            Result::NOT_SUPPORTED;
+Return<Result> StreamOut::drain(AudioDrain type) {
+    return mStream->drain != NULL
+               ? Stream::analyzeStatus(
+                     "drain",
+                     mStream->drain(mStream,
+                                    static_cast<audio_drain_type_t>(type)))
+               : Result::NOT_SUPPORTED;
 }
 
-Return<Result> StreamOut::flush()  {
-    return mStream->flush != NULL ?
-            Stream::analyzeStatus("flush", mStream->flush(mStream)) :
-            Result::NOT_SUPPORTED;
+Return<Result> StreamOut::flush() {
+    return mStream->flush != NULL
+               ? Stream::analyzeStatus("flush", mStream->flush(mStream))
+               : Result::NOT_SUPPORTED;
 }
 
 // static
-Result StreamOut::getPresentationPositionImpl(
-        audio_stream_out_t *stream, uint64_t *frames, TimeSpec *timeStamp) {
+Result StreamOut::getPresentationPositionImpl(audio_stream_out_t* stream,
+                                              uint64_t* frames,
+                                              TimeSpec* timeStamp) {
     Result retval(Result::NOT_SUPPORTED);
     if (stream->get_presentation_position == NULL) return retval;
     struct timespec halTimeStamp;
     retval = Stream::analyzeStatus(
-            "get_presentation_position",
-            stream->get_presentation_position(stream, frames, &halTimeStamp),
-            // Don't logspam on EINVAL--it's normal for get_presentation_position
-            // to return it sometimes. EAGAIN may be returned by A2DP audio HAL
-            // implementation.
-            EINVAL, EAGAIN);
+        "get_presentation_position",
+        stream->get_presentation_position(stream, frames, &halTimeStamp),
+        // Don't logspam on EINVAL--it's normal for get_presentation_position
+        // to return it sometimes. EAGAIN may be returned by A2DP audio HAL
+        // implementation.
+        EINVAL, EAGAIN);
     if (retval == Result::OK) {
         timeStamp->tvSec = halTimeStamp.tv_sec;
         timeStamp->tvNSec = halTimeStamp.tv_nsec;
@@ -472,9 +504,10 @@
     return retval;
 }
 
-Return<void> StreamOut::getPresentationPosition(getPresentationPosition_cb _hidl_cb)  {
+Return<void> StreamOut::getPresentationPosition(
+    getPresentationPosition_cb _hidl_cb) {
     uint64_t frames = 0;
-    TimeSpec timeStamp = { 0, 0 };
+    TimeSpec timeStamp = {0, 0};
     Result retval = getPresentationPositionImpl(mStream, &frames, &timeStamp);
     _hidl_cb(retval, frames, timeStamp);
     return Void();
@@ -488,9 +521,10 @@
     return mStreamMmap->stop();
 }
 
-Return<void> StreamOut::createMmapBuffer(int32_t minSizeFrames, createMmapBuffer_cb _hidl_cb) {
+Return<void> StreamOut::createMmapBuffer(int32_t minSizeFrames,
+                                         createMmapBuffer_cb _hidl_cb) {
     return mStreamMmap->createMmapBuffer(
-            minSizeFrames, audio_stream_out_frame_size(mStream), _hidl_cb);
+        minSizeFrames, audio_stream_out_frame_size(mStream), _hidl_cb);
 }
 
 Return<void> StreamOut::getMmapPosition(getMmapPosition_cb _hidl_cb) {
diff --git a/audio/2.0/default/Util.h b/audio/2.0/default/Util.h
new file mode 100644
index 0000000..72eea50
--- /dev/null
+++ b/audio/2.0/default/Util.h
@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+#ifndef ANDROID_HARDWARE_AUDIO_V2_0_UTIL_H
+#define ANDROID_HARDWARE_AUDIO_V2_0_UTIL_H
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+/** @return true if gain is between 0 and 1 included. */
+constexpr bool isGainNormalized(float gain) {
+    return gain >= 0.0 && gain <= 1.0;
+}
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_AUDIO_V2_0_UTIL_H
diff --git a/audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp b/audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp
index 074903f..83a1db0 100644
--- a/audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp
+++ b/audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp
@@ -36,9 +36,9 @@
 #include <android/hardware/audio/2.0/types.h>
 #include <android/hardware/audio/common/2.0/types.h>
 
-#include "utility/ReturnIn.h"
 #include "utility/AssertOk.h"
 #include "utility/PrettyPrintAudioTypes.h"
+#include "utility/ReturnIn.h"
 
 using std::string;
 using std::to_string;
@@ -59,7 +59,8 @@
 using ::android::hardware::audio::V2_0::IStream;
 using ::android::hardware::audio::V2_0::IStreamIn;
 using ::android::hardware::audio::V2_0::TimeSpec;
-using ReadParameters = ::android::hardware::audio::V2_0::IStreamIn::ReadParameters;
+using ReadParameters =
+    ::android::hardware::audio::V2_0::IStreamIn::ReadParameters;
 using ReadStatus = ::android::hardware::audio::V2_0::IStreamIn::ReadStatus;
 using ::android::hardware::audio::V2_0::IStreamOut;
 using ::android::hardware::audio::V2_0::IStreamOutCallback;
@@ -82,35 +83,51 @@
 
 using utility::returnIn;
 
+const char* getTestName() {
+    return ::testing::UnitTest::GetInstance()->current_test_info()->name();
+}
+
 namespace doc {
 /** Document the current test case.
- * Eg: calling `doc::test("Dump the state of the hal")` in the "debugDump" test will output:
- *   <testcase name="debugDump" status="run" time="6" classname="AudioPrimaryHidlTest"
-            description="Dump the state of the hal." />
- * see https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuide.md#logging-additional-information
+ * Eg: calling `doc::test("Dump the state of the hal")` in the "debugDump" test
+ * will output:
+ *   <testcase name="debugDump" status="run" time="6"
+ *             classname="AudioPrimaryHidlTest"
+               description="Dump the state of the hal." />
+ * see
+ https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuide.md#logging-additional-information
  */
 void test(const std::string& testCaseDocumentation) {
     ::testing::Test::RecordProperty("description", testCaseDocumentation);
 }
 
-/** Document why a test was not fully run. Usually due to an optional feature not implemented. */
+/** Document why a test was not fully run. Usually due to an optional feature
+ * not implemented. */
 void partialTest(const std::string& reason) {
+    LOG(INFO) << "Test " << getTestName() << " partially run: " << reason;
     ::testing::Test::RecordProperty("partialyRunTest", reason);
 }
+
+/** Add a note to the test. */
+void note(const std::string& note) {
+    LOG(INFO) << "Test " << getTestName() << " noted: " << note;
+    ::testing::Test::RecordProperty("note", note);
+}
 }
 
 // Register callback for static object destruction
 // Avoid destroying static objects after main return.
-// Post main return destruction leads to incorrect gtest timing measurements as well as harder
+// Post main return destruction leads to incorrect gtest timing measurements as
+// well as harder
 // debuging if anything goes wrong during destruction.
 class Environment : public ::testing::Environment {
-public:
-    using TearDownFunc = std::function<void ()>;
-     void registerTearDown(TearDownFunc&& tearDown) {
-         tearDowns.push_back(std::move(tearDown));
+   public:
+    using TearDownFunc = std::function<void()>;
+    void registerTearDown(TearDownFunc&& tearDown) {
+        tearDowns.push_back(std::move(tearDown));
     }
 
-private:
+   private:
     void TearDown() override {
         // Call the tear downs in reverse order of insertion
         for (auto& tearDown : tearDowns) {
@@ -123,7 +140,7 @@
 static Environment* environment;
 
 class HidlTest : public ::testing::VtsHalHidlTargetTestBase {
-protected:
+   protected:
     // Convenient member to store results
     Result res;
 };
@@ -134,18 +151,19 @@
 
 // Test all audio devices
 class AudioHidlTest : public HidlTest {
-public:
+   public:
     void SetUp() override {
-        ASSERT_NO_FATAL_FAILURE(HidlTest::SetUp()); // setup base
+        ASSERT_NO_FATAL_FAILURE(HidlTest::SetUp());  // setup base
 
         if (devicesFactory == nullptr) {
-            environment->registerTearDown([]{ devicesFactory.clear(); });
-            devicesFactory = ::testing::VtsHalHidlTargetTestBase::getService<IDevicesFactory>();
+            environment->registerTearDown([] { devicesFactory.clear(); });
+            devicesFactory = ::testing::VtsHalHidlTargetTestBase::getService<
+                IDevicesFactory>();
         }
         ASSERT_TRUE(devicesFactory != nullptr);
     }
 
-protected:
+   protected:
     // Cache the devicesFactory retrieval to speed up each test by ~0.5s
     static sp<IDevicesFactory> devicesFactory;
 };
@@ -171,26 +189,27 @@
 
 // Test the primary device
 class AudioPrimaryHidlTest : public AudioHidlTest {
-public:
+   public:
     /** Primary HAL test are NOT thread safe. */
     void SetUp() override {
-        ASSERT_NO_FATAL_FAILURE(AudioHidlTest::SetUp()); // setup base
+        ASSERT_NO_FATAL_FAILURE(AudioHidlTest::SetUp());  // setup base
 
         if (device == nullptr) {
             IDevicesFactory::Result result;
             sp<IDevice> baseDevice;
-            ASSERT_OK(devicesFactory->openDevice(IDevicesFactory::Device::PRIMARY,
-                                                 returnIn(result, baseDevice)));
+            ASSERT_OK(
+                devicesFactory->openDevice(IDevicesFactory::Device::PRIMARY,
+                                           returnIn(result, baseDevice)));
             ASSERT_OK(result);
             ASSERT_TRUE(baseDevice != nullptr);
 
-            environment->registerTearDown([]{ device.clear(); });
+            environment->registerTearDown([] { device.clear(); });
             device = IPrimaryDevice::castFrom(baseDevice);
             ASSERT_TRUE(device != nullptr);
         }
     }
 
-protected:
+   protected:
     // Cache the device opening to speed up each test by ~0.5s
     static sp<IPrimaryDevice> device;
 };
@@ -211,15 +230,15 @@
 
 template <class Property>
 class AccessorPrimaryHidlTest : public AudioPrimaryHidlTest {
-protected:
-
+   protected:
     /** Test a property getter and setter. */
     template <class Getter, class Setter>
-    void testAccessors(const string& propertyName, const vector<Property>& valuesToTest,
-                       Setter setter, Getter getter,
+    void testAccessors(const string& propertyName,
+                       const vector<Property>& valuesToTest, Setter setter,
+                       Getter getter,
                        const vector<Property>& invalidValues = {}) {
-
-        Property initialValue; // Save initial value to restore it at the end of the test
+        Property initialValue;  // Save initial value to restore it at the end
+                                // of the test
         ASSERT_OK((device.get()->*getter)(returnIn(res, initialValue)));
         ASSERT_OK(res);
 
@@ -235,17 +254,21 @@
         }
 
         for (Property invalidValue : invalidValues) {
-            SCOPED_TRACE("Try to set " + propertyName + " with the invalid value " +
+            SCOPED_TRACE("Try to set " + propertyName +
+                         " with the invalid value " +
                          testing::PrintToString(invalidValue));
-            EXPECT_RESULT(Result::INVALID_ARGUMENTS, (device.get()->*setter)(invalidValue));
+            EXPECT_RESULT(Result::INVALID_ARGUMENTS,
+                          (device.get()->*setter)(invalidValue));
         }
 
-        ASSERT_OK((device.get()->*setter)(initialValue)); // restore initial value
+        ASSERT_OK(
+            (device.get()->*setter)(initialValue));  // restore initial value
     }
 
     /** Test the getter and setter of an optional feature. */
     template <class Getter, class Setter>
-    void testOptionalAccessors(const string& propertyName, const vector<Property>& valuesToTest,
+    void testOptionalAccessors(const string& propertyName,
+                               const vector<Property>& valuesToTest,
                                Setter setter, Getter getter,
                                const vector<Property>& invalidValues = {}) {
         doc::test("Test the optional " + propertyName + " getters and setter");
@@ -257,10 +280,11 @@
                 doc::partialTest(propertyName + " getter is not supported");
                 return;
             }
-            ASSERT_OK(res); // If it is supported it must succeed
+            ASSERT_OK(res);  // If it is supported it must succeed
         }
         // The feature is supported, test it
-        testAccessors(propertyName, valuesToTest, setter, getter, invalidValues);
+        testAccessors(propertyName, valuesToTest, setter, getter,
+                      invalidValues);
     }
 };
 
@@ -268,12 +292,15 @@
 
 TEST_F(BoolAccessorPrimaryHidlTest, MicMuteTest) {
     doc::test("Check that the mic can be muted and unmuted");
-    testAccessors("mic mute", {true, false, true}, &IDevice::setMicMute, &IDevice::getMicMute);
+    testAccessors("mic mute", {true, false, true}, &IDevice::setMicMute,
+                  &IDevice::getMicMute);
     // TODO: check that the mic is really muted (all sample are 0)
 }
 
 TEST_F(BoolAccessorPrimaryHidlTest, MasterMuteTest) {
-    doc::test("If master mute is supported, try to mute and unmute the master output");
+    doc::test(
+        "If master mute is supported, try to mute and unmute the master "
+        "output");
     testOptionalAccessors("master mute", {true, false, true},
                           &IDevice::setMasterMute, &IDevice::getMasterMute);
     // TODO: check that the master volume is really muted
@@ -282,7 +309,7 @@
 using FloatAccessorPrimaryHidlTest = AccessorPrimaryHidlTest<float>;
 TEST_F(FloatAccessorPrimaryHidlTest, MasterVolumeTest) {
     doc::test("Test the master volume if supported");
-    testOptionalAccessors("master volume",  {0, 0.5, 1},
+    testOptionalAccessors("master volume", {0, 0.5, 1},
                           &IDevice::setMasterVolume, &IDevice::getMasterVolume,
                           {-0.1, 1.1, NAN, INFINITY, -INFINITY,
                            1 + std::numeric_limits<float>::epsilon()});
@@ -294,10 +321,10 @@
 //////////////////////////////////////////////////////////////////////////////
 
 class AudioPatchPrimaryHidlTest : public AudioPrimaryHidlTest {
-protected:
+   protected:
     bool areAudioPatchesSupported() {
         auto result = device->supportsAudioPatches();
-        EXPECT_TRUE(result.isOk());
+        EXPECT_IS_OK(result);
         return result;
     }
 };
@@ -311,27 +338,30 @@
     // TODO: test audio patches
 }
 
-
 //////////////////////////////////////////////////////////////////////////////
 //////////////// Required and recommended audio format support ///////////////
-// From: https://source.android.com/compatibility/android-cdd.html#5_4_audio_recording
-// From: https://source.android.com/compatibility/android-cdd.html#5_5_audio_playback
+// From:
+// https://source.android.com/compatibility/android-cdd.html#5_4_audio_recording
+// From:
+// https://source.android.com/compatibility/android-cdd.html#5_5_audio_playback
 /////////// TODO: move to the beginning of the file for easier update ////////
 //////////////////////////////////////////////////////////////////////////////
 
 class AudioConfigPrimaryTest : public AudioPatchPrimaryHidlTest {
-public:
+   public:
     // Cache result ?
     static const vector<AudioConfig> getRequiredSupportPlaybackAudioConfig() {
-        return combineAudioConfig({AudioChannelMask::OUT_STEREO, AudioChannelMask::OUT_MONO},
-                                  {8000, 11025, 16000, 22050, 32000, 44100},
-                                  {AudioFormat::PCM_16_BIT});
+        return combineAudioConfig(
+            {AudioChannelMask::OUT_STEREO, AudioChannelMask::OUT_MONO},
+            {8000, 11025, 16000, 22050, 32000, 44100},
+            {AudioFormat::PCM_16_BIT});
     }
 
-    static const vector<AudioConfig> getRecommendedSupportPlaybackAudioConfig() {
-        return combineAudioConfig({AudioChannelMask::OUT_STEREO, AudioChannelMask::OUT_MONO},
-                                  {24000, 48000},
-                                  {AudioFormat::PCM_16_BIT});
+    static const vector<AudioConfig>
+    getRecommendedSupportPlaybackAudioConfig() {
+        return combineAudioConfig(
+            {AudioChannelMask::OUT_STEREO, AudioChannelMask::OUT_MONO},
+            {24000, 48000}, {AudioFormat::PCM_16_BIT});
     }
 
     static const vector<AudioConfig> getSupportedPlaybackAudioConfig() {
@@ -346,8 +376,7 @@
                                   {AudioFormat::PCM_16_BIT});
     }
     static const vector<AudioConfig> getRecommendedSupportCaptureAudioConfig() {
-        return combineAudioConfig({AudioChannelMask::IN_STEREO},
-                                  {22050, 48000},
+        return combineAudioConfig({AudioChannelMask::IN_STEREO}, {22050, 48000},
                                   {AudioFormat::PCM_16_BIT});
     }
     static const vector<AudioConfig> getSupportedCaptureAudioConfig() {
@@ -355,13 +384,13 @@
         // as declared in the policy configuration
         return {};
     }
-private:
+
+   private:
     static const vector<AudioConfig> combineAudioConfig(
-            vector<AudioChannelMask> channelMasks,
-            vector<uint32_t> sampleRates,
-            vector<AudioFormat> formats) {
+        vector<AudioChannelMask> channelMasks, vector<uint32_t> sampleRates,
+        vector<AudioFormat> formats) {
         vector<AudioConfig> configs;
-        for (auto channelMask: channelMasks) {
+        for (auto channelMask : channelMasks) {
             for (auto sampleRate : sampleRates) {
                 for (auto format : formats) {
                     AudioConfig config{};
@@ -383,28 +412,34 @@
  * As the only parameter changing are channel mask and sample rate,
  * only print those ones in the test name.
  */
-static string generateTestName(const testing::TestParamInfo<AudioConfig>& info) {
+static string generateTestName(
+    const testing::TestParamInfo<AudioConfig>& info) {
     const AudioConfig& config = info.param;
-    return to_string(info.index) + "__" + to_string(config.sampleRateHz)+ "_" +
-            // "MONO" is more clear than "FRONT_LEFT"
-            ((config.channelMask == AudioChannelMask::OUT_MONO ||
-              config.channelMask == AudioChannelMask::IN_MONO) ?
-                    "MONO" : toString(config.channelMask));
+    return to_string(info.index) + "__" + to_string(config.sampleRateHz) + "_" +
+           // "MONO" is more clear than "FRONT_LEFT"
+           ((config.channelMask == AudioChannelMask::OUT_MONO ||
+             config.channelMask == AudioChannelMask::IN_MONO)
+                ? "MONO"
+                : toString(config.channelMask));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 ///////////////////////////// getInputBufferSize /////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-// FIXME: execute input test only if platform declares android.hardware.microphone
+// FIXME: execute input test only if platform declares
+// android.hardware.microphone
 //        how to get this value ? is it a property ???
 
-class AudioCaptureConfigPrimaryTest : public AudioConfigPrimaryTest,
-                                      public ::testing::WithParamInterface<AudioConfig> {
-protected:
-    void inputBufferSizeTest(const AudioConfig& audioConfig, bool supportRequired) {
+class AudioCaptureConfigPrimaryTest
+    : public AudioConfigPrimaryTest,
+      public ::testing::WithParamInterface<AudioConfig> {
+   protected:
+    void inputBufferSizeTest(const AudioConfig& audioConfig,
+                             bool supportRequired) {
         uint64_t bufferSize;
-        ASSERT_OK(device->getInputBufferSize(audioConfig, returnIn(res, bufferSize)));
+        ASSERT_OK(
+            device->getInputBufferSize(audioConfig, returnIn(res, bufferSize)));
 
         switch (res) {
             case Result::INVALID_ARGUMENTS:
@@ -416,36 +451,46 @@
                 EXPECT_GT(bufferSize, uint64_t(0));
                 break;
             default:
-                FAIL() << "Invalid return status: " << ::testing::PrintToString(res);
+                FAIL() << "Invalid return status: "
+                       << ::testing::PrintToString(res);
         }
     }
 };
 
-// Test that the required capture config and those declared in the policy are indeed supported
+// Test that the required capture config and those declared in the policy are
+// indeed supported
 class RequiredInputBufferSizeTest : public AudioCaptureConfigPrimaryTest {};
 TEST_P(RequiredInputBufferSizeTest, RequiredInputBufferSizeTest) {
-    doc::test("Input buffer size must be retrievable for a format with required support.");
+    doc::test(
+        "Input buffer size must be retrievable for a format with required "
+        "support.");
     inputBufferSizeTest(GetParam(), true);
 }
 INSTANTIATE_TEST_CASE_P(
-        RequiredInputBufferSize, RequiredInputBufferSizeTest,
-        ::testing::ValuesIn(AudioConfigPrimaryTest::getRequiredSupportCaptureAudioConfig()),
-         &generateTestName);
+    RequiredInputBufferSize, RequiredInputBufferSizeTest,
+    ::testing::ValuesIn(
+        AudioConfigPrimaryTest::getRequiredSupportCaptureAudioConfig()),
+    &generateTestName);
 INSTANTIATE_TEST_CASE_P(
-        SupportedInputBufferSize, RequiredInputBufferSizeTest,
-        ::testing::ValuesIn(AudioConfigPrimaryTest::getSupportedCaptureAudioConfig()),
-         &generateTestName);
+    SupportedInputBufferSize, RequiredInputBufferSizeTest,
+    ::testing::ValuesIn(
+        AudioConfigPrimaryTest::getSupportedCaptureAudioConfig()),
+    &generateTestName);
 
-// Test that the recommended capture config are supported or lead to a INVALID_ARGUMENTS return
+// Test that the recommended capture config are supported or lead to a
+// INVALID_ARGUMENTS return
 class OptionalInputBufferSizeTest : public AudioCaptureConfigPrimaryTest {};
 TEST_P(OptionalInputBufferSizeTest, OptionalInputBufferSizeTest) {
-    doc::test("Input buffer size should be retrievable for a format with recommended support.");
+    doc::test(
+        "Input buffer size should be retrievable for a format with recommended "
+        "support.");
     inputBufferSizeTest(GetParam(), false);
 }
 INSTANTIATE_TEST_CASE_P(
-        RecommendedCaptureAudioConfigSupport, OptionalInputBufferSizeTest,
-        ::testing::ValuesIn(AudioConfigPrimaryTest::getRecommendedSupportCaptureAudioConfig()),
-         &generateTestName);
+    RecommendedCaptureAudioConfigSupport, OptionalInputBufferSizeTest,
+    ::testing::ValuesIn(
+        AudioConfigPrimaryTest::getRecommendedSupportCaptureAudioConfig()),
+    &generateTestName);
 
 //////////////////////////////////////////////////////////////////////////////
 /////////////////////////////// setScreenState ///////////////////////////////
@@ -455,9 +500,10 @@
     doc::test("Check that the hal can receive the screen state");
     for (bool turnedOn : {false, true, true, false, false}) {
         auto ret = device->setScreenState(turnedOn);
-        ASSERT_TRUE(ret.isOk());
+        ASSERT_IS_OK(ret);
         Result result = ret;
-        ASSERT_TRUE(result == Result::OK || result == Result::NOT_SUPPORTED) << toString(result);
+        auto okOrNotSupported = {Result::OK, Result::NOT_SUPPORTED};
+        ASSERT_RESULT(okOrNotSupported, result);
     }
 }
 
@@ -481,34 +527,41 @@
 
 template <class DebugDump>
 static void testDebugDump(DebugDump debugDump) {
+    // Dump in a temporary file
+    // Note that SELinux must be deactivate for this test to work
     FILE* file = tmpfile();
     ASSERT_NE(nullptr, file) << errno;
 
+    // Wrap the temporary file file descriptor in a native handle
     auto* nativeHandle = native_handle_create(1, 0);
     ASSERT_NE(nullptr, nativeHandle);
     nativeHandle->data[0] = fileno(file);
 
+    // Wrap this native handle in a hidl handle
     hidl_handle handle;
     handle.setTo(nativeHandle, true /*take ownership*/);
 
-    // TODO: debugDump does not return a Result.
-    // This mean that the hal can not report that it not implementing the function.
     ASSERT_OK(debugDump(handle));
 
-    rewind(file); // can not fail
-
     // Check that at least one bit was written by the hal
+    // TODO: debugDump does not return a Result.
+    // This mean that the hal can not report that it not implementing the
+    // function.
+    rewind(file);  // can not fail
     char buff;
-    ASSERT_EQ(size_t{1}, fread(&buff, sizeof(buff), 1, file));
+    if (fread(&buff, sizeof(buff), 1, file) != 1) {
+        doc::note("debugDump does not seem implemented");
+    }
     EXPECT_EQ(0, fclose(file)) << errno;
 }
 
-TEST_F(AudioPrimaryHidlTest, debugDump) {
+TEST_F(AudioPrimaryHidlTest, DebugDump) {
     doc::test("Check that the hal can dump its state without error");
-    testDebugDump([this](const auto& handle){ return device->debugDump(handle); });
+    testDebugDump(
+        [this](const auto& handle) { return device->debugDump(handle); });
 }
 
-TEST_F(AudioPrimaryHidlTest, debugDumpInvalidArguments) {
+TEST_F(AudioPrimaryHidlTest, DebugDumpInvalidArguments) {
     doc::test("Check that the hal dump doesn't crash on invalid arguments");
     ASSERT_OK(device->debugDump(hidl_handle()));
 }
@@ -520,14 +573,16 @@
 template <class Stream>
 class OpenStreamTest : public AudioConfigPrimaryTest,
                        public ::testing::WithParamInterface<AudioConfig> {
-protected:
+   protected:
     template <class Open>
     void testOpen(Open openStream, const AudioConfig& config) {
         // FIXME: Open a stream without an IOHandle
         //        This is not required to be accepted by hal implementations
-        AudioIoHandle ioHandle = (AudioIoHandle)AudioHandleConsts::AUDIO_IO_HANDLE_NONE;
+        AudioIoHandle ioHandle =
+            (AudioIoHandle)AudioHandleConsts::AUDIO_IO_HANDLE_NONE;
         AudioConfig suggestedConfig{};
-        ASSERT_OK(openStream(ioHandle, config, returnIn(res, stream, suggestedConfig)));
+        ASSERT_OK(openStream(ioHandle, config,
+                             returnIn(res, stream, suggestedConfig)));
 
         // TODO: only allow failure for RecommendedPlaybackAudioConfig
         switch (res) {
@@ -538,16 +593,19 @@
             case Result::INVALID_ARGUMENTS:
                 ASSERT_TRUE(stream == nullptr);
                 AudioConfig suggestedConfigRetry;
-                // Could not open stream with config, try again with the suggested one
-                ASSERT_OK(openStream(ioHandle, suggestedConfig,
-                                     returnIn(res, stream, suggestedConfigRetry)));
+                // Could not open stream with config, try again with the
+                // suggested one
+                ASSERT_OK(
+                    openStream(ioHandle, suggestedConfig,
+                               returnIn(res, stream, suggestedConfigRetry)));
                 // This time it must succeed
                 ASSERT_OK(res);
-                ASSERT_TRUE(stream == nullptr);
+                ASSERT_TRUE(stream != nullptr);
                 audioConfig = suggestedConfig;
                 break;
             default:
-                FAIL() << "Invalid return status: " << ::testing::PrintToString(res);
+                FAIL() << "Invalid return status: "
+                       << ::testing::PrintToString(res);
         }
         open = true;
     }
@@ -556,15 +614,15 @@
         open = false;
         return stream->close();
     }
-private:
+
+   private:
     void TearDown() override {
         if (open) {
             ASSERT_OK(stream->close());
         }
     }
 
-protected:
-
+   protected:
     AudioConfig audioConfig;
     DeviceAddress address = {};
     sp<Stream> stream;
@@ -575,66 +633,84 @@
 
 class OutputStreamTest : public OpenStreamTest<IStreamOut> {
     virtual void SetUp() override {
-        ASSERT_NO_FATAL_FAILURE(OpenStreamTest::SetUp()); // setup base
+        ASSERT_NO_FATAL_FAILURE(OpenStreamTest::SetUp());  // setup base
         address.device = AudioDevice::OUT_DEFAULT;
         const AudioConfig& config = GetParam();
-        AudioOutputFlag flags = AudioOutputFlag::NONE; // TODO: test all flag combination
-        testOpen([&](AudioIoHandle handle, AudioConfig config, auto cb)
-                 { return device->openOutputStream(handle, address, config, flags, cb); },
-                 config);
+        AudioOutputFlag flags =
+            AudioOutputFlag::NONE;  // TODO: test all flag combination
+        testOpen(
+            [&](AudioIoHandle handle, AudioConfig config, auto cb) {
+                return device->openOutputStream(handle, address, config, flags,
+                                                cb);
+            },
+            config);
     }
 };
 TEST_P(OutputStreamTest, OpenOutputStreamTest) {
-    doc::test("Check that output streams can be open with the required and recommended config");
+    doc::test(
+        "Check that output streams can be open with the required and "
+        "recommended config");
     // Open done in SetUp
 }
 INSTANTIATE_TEST_CASE_P(
-        RequiredOutputStreamConfigSupport, OutputStreamTest,
-        ::testing::ValuesIn(AudioConfigPrimaryTest::getRequiredSupportPlaybackAudioConfig()),
-         &generateTestName);
+    RequiredOutputStreamConfigSupport, OutputStreamTest,
+    ::testing::ValuesIn(
+        AudioConfigPrimaryTest::getRequiredSupportPlaybackAudioConfig()),
+    &generateTestName);
 INSTANTIATE_TEST_CASE_P(
-        SupportedOutputStreamConfig, OutputStreamTest,
-        ::testing::ValuesIn(AudioConfigPrimaryTest::getSupportedPlaybackAudioConfig()),
-         &generateTestName);
+    SupportedOutputStreamConfig, OutputStreamTest,
+    ::testing::ValuesIn(
+        AudioConfigPrimaryTest::getSupportedPlaybackAudioConfig()),
+    &generateTestName);
 
 INSTANTIATE_TEST_CASE_P(
-        RecommendedOutputStreamConfigSupport, OutputStreamTest,
-        ::testing::ValuesIn(AudioConfigPrimaryTest::getRecommendedSupportPlaybackAudioConfig()),
-         &generateTestName);
+    RecommendedOutputStreamConfigSupport, OutputStreamTest,
+    ::testing::ValuesIn(
+        AudioConfigPrimaryTest::getRecommendedSupportPlaybackAudioConfig()),
+    &generateTestName);
 
 ////////////////////////////// openInputStream //////////////////////////////
 
 class InputStreamTest : public OpenStreamTest<IStreamIn> {
-
     virtual void SetUp() override {
-        ASSERT_NO_FATAL_FAILURE(OpenStreamTest::SetUp()); // setup base
+        ASSERT_NO_FATAL_FAILURE(OpenStreamTest::SetUp());  // setup base
         address.device = AudioDevice::IN_DEFAULT;
         const AudioConfig& config = GetParam();
-        AudioInputFlag flags = AudioInputFlag::NONE; // TODO: test all flag combination
-        AudioSource source = AudioSource::DEFAULT; // TODO: test all flag combination
-        testOpen([&](AudioIoHandle handle, AudioConfig config, auto cb)
-                 { return device->openInputStream(handle, address, config, flags, source, cb); },
-                 config);
+        AudioInputFlag flags =
+            AudioInputFlag::NONE;  // TODO: test all flag combination
+        AudioSource source =
+            AudioSource::DEFAULT;  // TODO: test all flag combination
+        testOpen(
+            [&](AudioIoHandle handle, AudioConfig config, auto cb) {
+                return device->openInputStream(handle, address, config, flags,
+                                               source, cb);
+            },
+            config);
     }
 };
 
 TEST_P(InputStreamTest, OpenInputStreamTest) {
-    doc::test("Check that input streams can be open with the required and recommended config");
+    doc::test(
+        "Check that input streams can be open with the required and "
+        "recommended config");
     // Open done in setup
 }
 INSTANTIATE_TEST_CASE_P(
-        RequiredInputStreamConfigSupport, InputStreamTest,
-        ::testing::ValuesIn(AudioConfigPrimaryTest::getRequiredSupportCaptureAudioConfig()),
-         &generateTestName);
+    RequiredInputStreamConfigSupport, InputStreamTest,
+    ::testing::ValuesIn(
+        AudioConfigPrimaryTest::getRequiredSupportCaptureAudioConfig()),
+    &generateTestName);
 INSTANTIATE_TEST_CASE_P(
-        SupportedInputStreamConfig, InputStreamTest,
-        ::testing::ValuesIn(AudioConfigPrimaryTest::getSupportedCaptureAudioConfig()),
-         &generateTestName);
+    SupportedInputStreamConfig, InputStreamTest,
+    ::testing::ValuesIn(
+        AudioConfigPrimaryTest::getSupportedCaptureAudioConfig()),
+    &generateTestName);
 
 INSTANTIATE_TEST_CASE_P(
-        RecommendedInputStreamConfigSupport, InputStreamTest,
-        ::testing::ValuesIn(AudioConfigPrimaryTest::getRecommendedSupportCaptureAudioConfig()),
-         &generateTestName);
+    RecommendedInputStreamConfigSupport, InputStreamTest,
+    ::testing::ValuesIn(
+        AudioConfigPrimaryTest::getRecommendedSupportCaptureAudioConfig()),
+    &generateTestName);
 
 //////////////////////////////////////////////////////////////////////////////
 ////////////////////////////// IStream getters ///////////////////////////////
@@ -645,7 +721,7 @@
 template <class R>
 static R extract(Return<R> ret) {
     if (!ret.isOk()) {
-        ADD_FAILURE();
+        EXPECT_IS_OK(ret);
         return R{};
     }
     return ret;
@@ -654,49 +730,63 @@
 /* Could not find a way to write a test for two parametrized class fixure
  * thus use this macro do duplicate tests for Input and Output stream */
 #define TEST_IO_STREAM(test_name, documentation, code) \
-    TEST_P(InputStreamTest, test_name) { \
-        doc::test(documentation); \
-        code; \
-    } \
-    TEST_P(OutputStreamTest, test_name) { \
-        doc::test(documentation); \
-        code; \
+    TEST_P(InputStreamTest, test_name) {               \
+        doc::test(documentation);                      \
+        code;                                          \
+    }                                                  \
+    TEST_P(OutputStreamTest, test_name) {              \
+        doc::test(documentation);                      \
+        code;                                          \
     }
 
-TEST_IO_STREAM(GetFrameCount, "Check that the stream frame count == the one it was opened with",
-               ASSERT_EQ(audioConfig.frameCount, extract(stream->getFrameCount())))
+TEST_IO_STREAM(
+    GetFrameCount,
+    "Check that the stream frame count == the one it was opened with",
+    ASSERT_EQ(audioConfig.frameCount, extract(stream->getFrameCount())))
 
-TEST_IO_STREAM(GetSampleRate, "Check that the stream sample rate == the one it was opened with",
-               ASSERT_EQ(audioConfig.sampleRateHz, extract(stream->getSampleRate())))
+TEST_IO_STREAM(
+    GetSampleRate,
+    "Check that the stream sample rate == the one it was opened with",
+    ASSERT_EQ(audioConfig.sampleRateHz, extract(stream->getSampleRate())))
 
-TEST_IO_STREAM(GetChannelMask, "Check that the stream channel mask == the one it was opened with",
-               ASSERT_EQ(audioConfig.channelMask, extract(stream->getChannelMask())))
+TEST_IO_STREAM(
+    GetChannelMask,
+    "Check that the stream channel mask == the one it was opened with",
+    ASSERT_EQ(audioConfig.channelMask, extract(stream->getChannelMask())))
 
-TEST_IO_STREAM(GetFormat, "Check that the stream format == the one it was opened with",
+TEST_IO_STREAM(GetFormat,
+               "Check that the stream format == the one it was opened with",
                ASSERT_EQ(audioConfig.format, extract(stream->getFormat())))
 
 // TODO: for now only check that the framesize is not incoherent
-TEST_IO_STREAM(GetFrameSize, "Check that the stream frame size == the one it was opened with",
+TEST_IO_STREAM(GetFrameSize,
+               "Check that the stream frame size == the one it was opened with",
                ASSERT_GT(extract(stream->getFrameSize()), 0U))
 
-TEST_IO_STREAM(GetBufferSize, "Check that the stream buffer size== the one it was opened with",
-               ASSERT_GE(extract(stream->getBufferSize()), \
-                                     extract(stream->getFrameSize())));
+TEST_IO_STREAM(GetBufferSize,
+               "Check that the stream buffer size== the one it was opened with",
+               ASSERT_GE(extract(stream->getBufferSize()),
+                         extract(stream->getFrameSize())));
 
 template <class Property, class CapabilityGetter, class Getter, class Setter>
-static void testCapabilityGetter(const string& name, IStream* stream, Property currentValue,
-                                 CapabilityGetter capablityGetter, Getter getter, Setter setter) {
+static void testCapabilityGetter(const string& name, IStream* stream,
+                                 Property currentValue,
+                                 CapabilityGetter capablityGetter,
+                                 Getter getter, Setter setter) {
     hidl_vec<Property> capabilities;
     ASSERT_OK((stream->*capablityGetter)(returnIn(capabilities)));
     if (capabilities.size() == 0) {
-        // The default hal should probably return a NOT_SUPPORTED if the hal does not expose
-        // capability retrieval. For now it returns an empty list if not implemented
+        // The default hal should probably return a NOT_SUPPORTED if the hal
+        // does not expose
+        // capability retrieval. For now it returns an empty list if not
+        // implemented
         doc::partialTest(name + " is not supported");
         return;
     };
-    // TODO: This code has never been tested on a hal that supports getSupportedSampleRates
+    // TODO: This code has never been tested on a hal that supports
+    // getSupportedSampleRates
     EXPECT_NE(std::find(capabilities.begin(), capabilities.end(), currentValue),
-             capabilities.end())
+              capabilities.end())
         << "current " << name << " is not in the list of the supported ones "
         << toString(capabilities);
 
@@ -707,69 +797,88 @@
     }
 }
 
-TEST_IO_STREAM(SupportedSampleRate, "Check that the stream sample rate is declared as supported",
-               testCapabilityGetter("getSupportedSampleRate", stream.get(), \
-                                    extract(stream->getSampleRate()), \
-                                    &IStream::getSupportedSampleRates, \
-                                    &IStream::getSampleRate, &IStream::setSampleRate))
+TEST_IO_STREAM(SupportedSampleRate,
+               "Check that the stream sample rate is declared as supported",
+               testCapabilityGetter("getSupportedSampleRate", stream.get(),
+                                    extract(stream->getSampleRate()),
+                                    &IStream::getSupportedSampleRates,
+                                    &IStream::getSampleRate,
+                                    &IStream::setSampleRate))
 
-TEST_IO_STREAM(SupportedChannelMask, "Check that the stream channel mask is declared as supported",
-               testCapabilityGetter("getSupportedChannelMask", stream.get(), \
-                                    extract(stream->getChannelMask()), \
-                                    &IStream::getSupportedChannelMasks, \
-                                    &IStream::getChannelMask, &IStream::setChannelMask))
+TEST_IO_STREAM(SupportedChannelMask,
+               "Check that the stream channel mask is declared as supported",
+               testCapabilityGetter("getSupportedChannelMask", stream.get(),
+                                    extract(stream->getChannelMask()),
+                                    &IStream::getSupportedChannelMasks,
+                                    &IStream::getChannelMask,
+                                    &IStream::setChannelMask))
 
-TEST_IO_STREAM(SupportedFormat, "Check that the stream format is declared as supported",
-               testCapabilityGetter("getSupportedFormat", stream.get(), \
-                                    extract(stream->getFormat()), \
-                                    &IStream::getSupportedFormats, \
+TEST_IO_STREAM(SupportedFormat,
+               "Check that the stream format is declared as supported",
+               testCapabilityGetter("getSupportedFormat", stream.get(),
+                                    extract(stream->getFormat()),
+                                    &IStream::getSupportedFormats,
                                     &IStream::getFormat, &IStream::setFormat))
 
 static void testGetDevice(IStream* stream, AudioDevice expectedDevice) {
+    // Unfortunately the interface does not allow the implementation to return
+    // NOT_SUPPORTED
+    // Thus allow NONE as signaling that the call is not supported.
     auto ret = stream->getDevice();
-    ASSERT_TRUE(ret.isOk());
+    ASSERT_IS_OK(ret);
     AudioDevice device = ret;
-    ASSERT_EQ(expectedDevice, device);
+    ASSERT_TRUE(device == expectedDevice || device == AudioDevice::NONE)
+        << "Expected: " << ::testing::PrintToString(expectedDevice)
+        << "\n  Actual: " << ::testing::PrintToString(device);
 }
 
-TEST_IO_STREAM(GetDevice, "Check that the stream device == the one it was opened with",
-               areAudioPatchesSupported() ? doc::partialTest("Audio patches are supported") : \
-                                            testGetDevice(stream.get(), address.device))
+TEST_IO_STREAM(GetDevice,
+               "Check that the stream device == the one it was opened with",
+               areAudioPatchesSupported()
+                   ? doc::partialTest("Audio patches are supported")
+                   : testGetDevice(stream.get(), address.device))
 
 static void testSetDevice(IStream* stream, const DeviceAddress& address) {
     DeviceAddress otherAddress = address;
-    otherAddress.device = (address.device & AudioDevice::BIT_IN) == 0 ?
-            AudioDevice::OUT_SPEAKER : AudioDevice::IN_BUILTIN_MIC;
+    otherAddress.device = (address.device & AudioDevice::BIT_IN) == 0
+                              ? AudioDevice::OUT_SPEAKER
+                              : AudioDevice::IN_BUILTIN_MIC;
     EXPECT_OK(stream->setDevice(otherAddress));
 
-    ASSERT_OK(stream->setDevice(address)); // Go back to the original value
+    ASSERT_OK(stream->setDevice(address));  // Go back to the original value
 }
 
-TEST_IO_STREAM(SetDevice, "Check that the stream can be rerouted to SPEAKER or BUILTIN_MIC",
-               areAudioPatchesSupported() ? doc::partialTest("Audio patches are supported") : \
-                                            testSetDevice(stream.get(), address))
+TEST_IO_STREAM(
+    SetDevice,
+    "Check that the stream can be rerouted to SPEAKER or BUILTIN_MIC",
+    areAudioPatchesSupported() ? doc::partialTest("Audio patches are supported")
+                               : testSetDevice(stream.get(), address))
 
-static void testGetAudioProperties(IStream* stream, AudioConfig expectedConfig) {
+static void testGetAudioProperties(IStream* stream,
+                                   AudioConfig expectedConfig) {
     uint32_t sampleRateHz;
     AudioChannelMask mask;
     AudioFormat format;
 
     stream->getAudioProperties(returnIn(sampleRateHz, mask, format));
 
-    // FIXME: the qcom hal it does not currently negotiate the sampleRate & channel mask
+    // FIXME: the qcom hal it does not currently negotiate the sampleRate &
+    // channel mask
     EXPECT_EQ(expectedConfig.sampleRateHz, sampleRateHz);
     EXPECT_EQ(expectedConfig.channelMask, mask);
     EXPECT_EQ(expectedConfig.format, format);
 }
 
-TEST_IO_STREAM(GetAudioProperties,
-               "Check that the stream audio properties == the ones it was opened with",
-               testGetAudioProperties(stream.get(), audioConfig))
+TEST_IO_STREAM(
+    GetAudioProperties,
+    "Check that the stream audio properties == the ones it was opened with",
+    testGetAudioProperties(stream.get(), audioConfig))
 
 static void testConnectedState(IStream* stream) {
     DeviceAddress address = {};
     using AD = AudioDevice;
-    for (auto device : {AD::OUT_HDMI, AD::OUT_WIRED_HEADPHONE, AD::IN_USB_HEADSET}) {
+    for (auto device :
+         {AD::OUT_HDMI, AD::OUT_WIRED_HEADPHONE, AD::IN_USB_HEADSET}) {
         address.device = device;
 
         ASSERT_OK(stream->setConnectedState(address, true));
@@ -777,52 +886,63 @@
     }
 }
 TEST_IO_STREAM(SetConnectedState,
-               "Check that the stream can be notified of device connection and deconnection",
+               "Check that the stream can be notified of device connection and "
+               "deconnection",
                testConnectedState(stream.get()))
 
-
-static auto invalidArgsOrNotSupported = {Result::INVALID_ARGUMENTS, Result::NOT_SUPPORTED};
+static auto invalidArgsOrNotSupportedOrOK = {Result::INVALID_ARGUMENTS,
+                                             Result::NOT_SUPPORTED, Result::OK};
 TEST_IO_STREAM(SetHwAvSync, "Try to set hardware sync to an invalid value",
-               ASSERT_RESULT(invalidArgsOrNotSupported, stream->setHwAvSync(666)))
+               ASSERT_RESULT(invalidArgsOrNotSupportedOrOK,
+                             stream->setHwAvSync(666)))
 
 TEST_IO_STREAM(GetHwAvSync, "Get hardware sync can not fail",
-               ASSERT_TRUE(device->getHwAvSync().isOk()))
+               ASSERT_IS_OK(device->getHwAvSync()));
 
-static void checkGetParameter(IStream* stream, hidl_vec<hidl_string> keys,
-                              vector<Result> expectedResults) {
+static void checkGetNoParameter(IStream* stream, hidl_vec<hidl_string> keys,
+                                vector<Result> expectedResults) {
     hidl_vec<ParameterValue> parameters;
     Result res;
     ASSERT_OK(stream->getParameters(keys, returnIn(res, parameters)));
     ASSERT_RESULT(expectedResults, res);
     if (res == Result::OK) {
-        ASSERT_EQ(0U, parameters.size());
+        for (auto& parameter : parameters) {
+            ASSERT_EQ(0U, parameter.value.size()) << toString(parameter);
+        }
     }
 }
 
-/* Get/Set parameter is intended to be an opaque channel between vendors app and their HALs.
+/* Get/Set parameter is intended to be an opaque channel between vendors app and
+ * their HALs.
  * Thus can not be meaningfully tested.
- * TODO: Doc missing. Should asking for an empty set of params raise an error ?
  */
 TEST_IO_STREAM(getEmptySetParameter, "Retrieve the values of an empty set",
-               checkGetParameter(stream.get(), {} /* keys */,
-                                 {Result::OK, Result::INVALID_ARGUMENTS}))
+               checkGetNoParameter(stream.get(), {} /* keys */, {Result::OK}))
 
+TEST_IO_STREAM(getNonExistingParameter,
+               "Retrieve the values of an non existing parameter",
+               checkGetNoParameter(stream.get(),
+                                   {"Non existing key"} /* keys */,
+                                   {Result::NOT_SUPPORTED}))
 
-TEST_IO_STREAM(getNonExistingParameter, "Retrieve the values of an non existing parameter",
-               checkGetParameter(stream.get(), {"Non existing key"} /* keys */,
-                                 {Result::INVALID_ARGUMENTS}))
+TEST_IO_STREAM(setEmptySetParameter,
+               "Set the values of an empty set of parameters",
+               ASSERT_RESULT(Result::OK, stream->setParameters({})))
 
-static vector<Result> okOrInvalidArguments = {Result::OK, Result::INVALID_ARGUMENTS};
-TEST_IO_STREAM(setEmptySetParameter, "Set the values of an empty set of parameters",
-               ASSERT_RESULT(okOrInvalidArguments, stream->setParameters({})))
-
-TEST_IO_STREAM(setNonExistingParameter, "Set the values of an non existing parameter",
-               ASSERT_RESULT(Result::INVALID_ARGUMENTS,
-                             stream->setParameters({{"non existing key", "0"}})))
+TEST_IO_STREAM(
+    setNonExistingParameter, "Set the values of an non existing parameter",
+    // Unfortunately, the set_parameter legacy interface did not return any
+    // error code when a key is not supported.
+    // To allow implementation to just wrapped the legacy one, consider OK as a
+    // valid result for setting a non existing parameter.
+    ASSERT_RESULT(invalidArgsOrNotSupportedOrOK,
+                  stream->setParameters({{"non existing key", "0"}})))
 
 TEST_IO_STREAM(DebugDump,
                "Check that a stream can dump its state without error",
-               testDebugDump([this](const auto& handle){ return stream->debugDump(handle); }))
+               testDebugDump([this](const auto& handle) {
+                   return stream->debugDump(handle);
+               }))
 
 TEST_IO_STREAM(DebugDumpInvalidArguments,
                "Check that the stream dump doesn't crash on invalid arguments",
@@ -834,39 +954,49 @@
 
 TEST_IO_STREAM(AddNonExistingEffect, "Adding a non existing effect should fail",
                ASSERT_RESULT(Result::INVALID_ARGUMENTS, stream->addEffect(666)))
-TEST_IO_STREAM(RemoveNonExistingEffect, "Removing a non existing effect should fail",
-               ASSERT_RESULT(Result::INVALID_ARGUMENTS, stream->removeEffect(666)))
+TEST_IO_STREAM(RemoveNonExistingEffect,
+               "Removing a non existing effect should fail",
+               ASSERT_RESULT(Result::INVALID_ARGUMENTS,
+                             stream->removeEffect(666)))
 
-//TODO: positive tests
+// TODO: positive tests
 
 //////////////////////////////////////////////////////////////////////////////
 /////////////////////////////// Control ////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 TEST_IO_STREAM(standby, "Make sure the stream can be put in stanby",
-               ASSERT_OK(stream->standby())) // can not fail
+               ASSERT_OK(stream->standby()))  // can not fail
 
-static vector<Result> invalidStateOrNotSupported = {Result::INVALID_STATE, Result::NOT_SUPPORTED};
+static vector<Result> invalidStateOrNotSupported = {Result::INVALID_STATE,
+                                                    Result::NOT_SUPPORTED};
 
-TEST_IO_STREAM(startNoMmap, "Starting a mmaped stream before mapping it should fail",
+TEST_IO_STREAM(startNoMmap,
+               "Starting a mmaped stream before mapping it should fail",
                ASSERT_RESULT(invalidStateOrNotSupported, stream->start()))
 
-TEST_IO_STREAM(stopNoMmap, "Stopping a mmaped stream before mapping it should fail",
+TEST_IO_STREAM(stopNoMmap,
+               "Stopping a mmaped stream before mapping it should fail",
                ASSERT_RESULT(invalidStateOrNotSupported, stream->stop()))
 
-TEST_IO_STREAM(getMmapPositionNoMmap, "Get a stream Mmap position before mapping it should fail",
+TEST_IO_STREAM(getMmapPositionNoMmap,
+               "Get a stream Mmap position before mapping it should fail",
                ASSERT_RESULT(invalidStateOrNotSupported, stream->stop()))
 
-TEST_IO_STREAM(close, "Make sure a stream can be closed", ASSERT_OK(closeStream()))
+TEST_IO_STREAM(close, "Make sure a stream can be closed",
+               ASSERT_OK(closeStream()))
 TEST_IO_STREAM(closeTwice, "Make sure a stream can not be closed twice",
-               ASSERT_OK(closeStream()); \
+               ASSERT_OK(closeStream());
                ASSERT_RESULT(Result::INVALID_STATE, closeStream()))
 
+static auto invalidArgsOrNotSupported = {Result::INVALID_ARGUMENTS,
+                                         Result::NOT_SUPPORTED};
 static void testCreateTooBigMmapBuffer(IStream* stream) {
     MmapBufferInfo info;
     Result res;
     // Assume that int max is a value too big to be allocated
-    // This is true currently with a 32bit media server, but might not when it will run in 64 bit
+    // This is true currently with a 32bit media server, but might not when it
+    // will run in 64 bit
     auto minSizeFrames = std::numeric_limits<int32_t>::max();
     ASSERT_OK(stream->createMmapBuffer(minSizeFrames, returnIn(res, info)));
     ASSERT_RESULT(invalidArgsOrNotSupported, res);
@@ -875,7 +1005,6 @@
 TEST_IO_STREAM(CreateTooBigMmapBuffer, "Create mmap buffer too big should fail",
                testCreateTooBigMmapBuffer(stream.get()))
 
-
 static void testGetMmapPositionOfNonMmapedStream(IStream* stream) {
     Result res;
     MmapPosition position;
@@ -883,71 +1012,107 @@
     ASSERT_RESULT(invalidArgsOrNotSupported, res);
 }
 
-TEST_IO_STREAM(GetMmapPositionOfNonMmapedStream,
-               "Retrieving the mmap position of a non mmaped stream should fail",
-               testGetMmapPositionOfNonMmapedStream(stream.get()))
+TEST_IO_STREAM(
+    GetMmapPositionOfNonMmapedStream,
+    "Retrieving the mmap position of a non mmaped stream should fail",
+    testGetMmapPositionOfNonMmapedStream(stream.get()))
 
 //////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////// StreamIn ///////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 TEST_P(InputStreamTest, GetAudioSource) {
-    doc::test("Retrieving the audio source of an input stream should always succeed");
+    doc::test(
+        "Retrieving the audio source of an input stream should always succeed");
     AudioSource source;
     ASSERT_OK(stream->getAudioSource(returnIn(res, source)));
+    if (res == Result::NOT_SUPPORTED) {
+        doc::partialTest("getAudioSource is not supported");
+        return;
+    }
     ASSERT_OK(res);
     ASSERT_EQ(AudioSource::DEFAULT, source);
 }
 
-static void testUnitaryGain(std::function<Return<Result> (float)> setGain) {
-    for (float value : {0.0, 0.01, 0.5, 0.09, 1.0}) {
+static void testUnitaryGain(std::function<Return<Result>(float)> setGain) {
+    for (float value :
+         (float[]){-INFINITY, -1.0, 1.0 + std::numeric_limits<float>::epsilon(),
+                   2.0, INFINITY, NAN}) {
+        SCOPED_TRACE("value=" + to_string(value));
+        // FIXME: NAN should never be accepted
+        // FIXME: Missing api doc. What should the impl do if the volume is
+        // outside [0,1] ?
+        ASSERT_RESULT(Result::INVALID_ARGUMENTS, setGain(value));
+    }
+    // Do not consider -0.0 as an invalid value as it is == with 0.0
+    for (float value : {-0.0, 0.0, 0.01, 0.5, 0.09, 1.0 /* Restore volume*/}) {
         SCOPED_TRACE("value=" + to_string(value));
         ASSERT_OK(setGain(value));
     }
-    for (float value : (float[]){-INFINITY,-1.0, -0.0,
-                                 1.0 + std::numeric_limits<float>::epsilon(), 2.0, INFINITY,
-                                 NAN}) {
-        SCOPED_TRACE("value=" + to_string(value));
-        // FIXME: NAN should never be accepted
-        // FIXME: Missing api doc. What should the impl do if the volume is outside [0,1] ?
-        ASSERT_RESULT(Result::INVALID_ARGUMENTS, setGain(value));
+}
+
+static void testOptionalUnitaryGain(
+    std::function<Return<Result>(float)> setGain, string debugName) {
+    auto result = setGain(1);
+    ASSERT_IS_OK(result);
+    if (result == Result::NOT_SUPPORTED) {
+        doc::partialTest(debugName + " is not supported");
+        return;
     }
+    testUnitaryGain(setGain);
 }
 
 TEST_P(InputStreamTest, SetGain) {
     doc::test("The gain of an input stream should only be set between [0,1]");
-    testUnitaryGain([this](float volume) { return stream->setGain(volume); });
+    testOptionalUnitaryGain(
+        [this](float volume) { return stream->setGain(volume); },
+        "InputStream::setGain");
 }
 
-static void testPrepareForReading(IStreamIn* stream, uint32_t frameSize, uint32_t framesCount) {
+static void testPrepareForReading(IStreamIn* stream, uint32_t frameSize,
+                                  uint32_t framesCount) {
     Result res;
     // Ignore output parameters as the call should fail
-    ASSERT_OK(stream->prepareForReading(frameSize, framesCount,
-                                        [&res](auto r, auto&, auto&, auto&, auto&) { res = r; }));
+    ASSERT_OK(stream->prepareForReading(
+        frameSize, framesCount,
+        [&res](auto r, auto&, auto&, auto&, auto&) { res = r; }));
     EXPECT_RESULT(invalidArgsOrNotSupported, res);
 }
 
+TEST_P(InputStreamTest, PrepareForReadingWithZeroBuffer) {
+    doc::test(
+        "Preparing a stream for reading with a 0 sized buffer should fail");
+    testPrepareForReading(stream.get(), 0, 0);
+}
+
 TEST_P(InputStreamTest, PrepareForReadingWithHugeBuffer) {
-    doc::test("Preparing a stream for reading with a 2^32 sized buffer should fail");
-    testPrepareForReading(stream.get(), 1, std::numeric_limits<uint32_t>::max());
+    doc::test(
+        "Preparing a stream for reading with a 2^32 sized buffer should fail");
+    testPrepareForReading(stream.get(), 1,
+                          std::numeric_limits<uint32_t>::max());
 }
 
 TEST_P(InputStreamTest, PrepareForReadingCheckOverflow) {
-    doc::test("Preparing a stream for reading with a overflowing sized buffer should fail");
+    doc::test(
+        "Preparing a stream for reading with a overflowing sized buffer should "
+        "fail");
     auto uintMax = std::numeric_limits<uint32_t>::max();
     testPrepareForReading(stream.get(), uintMax, uintMax);
 }
 
 TEST_P(InputStreamTest, GetInputFramesLost) {
-    doc::test("The number of frames lost on a never started stream should be 0");
+    doc::test(
+        "The number of frames lost on a never started stream should be 0");
     auto ret = stream->getInputFramesLost();
-    ASSERT_TRUE(ret.isOk());
+    ASSERT_IS_OK(ret);
     uint32_t framesLost{ret};
     ASSERT_EQ(0U, framesLost);
 }
 
 TEST_P(InputStreamTest, getCapturePosition) {
-    doc::test("The capture position of a non prepared stream should not be retrievable");
+    doc::test(
+        "The capture position of a non prepared stream should not be "
+        "retrievable");
     uint64_t frames;
     uint64_t time;
     ASSERT_OK(stream->getCapturePosition(returnIn(res, frames, time)));
@@ -961,36 +1126,44 @@
 TEST_P(OutputStreamTest, getLatency) {
     doc::test("Make sure latency is over 0");
     auto result = stream->getLatency();
-    ASSERT_TRUE(result.isOk());
+    ASSERT_IS_OK(result);
     ASSERT_GT(result, 0U);
 }
 
 TEST_P(OutputStreamTest, setVolume) {
     doc::test("Try to set the output volume");
-    auto result = stream->setVolume(1, 1);
-    ASSERT_TRUE(result.isOk());
-    if (result == Result::NOT_SUPPORTED) {
-        doc::partialTest("setVolume is not supported");
-        return;
-    }
-    testUnitaryGain([this](float volume) { return stream->setVolume(volume, volume); });
+    testOptionalUnitaryGain(
+        [this](float volume) { return stream->setVolume(volume, volume); },
+        "setVolume");
 }
 
-static void testPrepareForWriting(IStreamOut* stream, uint32_t frameSize, uint32_t framesCount) {
+static void testPrepareForWriting(IStreamOut* stream, uint32_t frameSize,
+                                  uint32_t framesCount) {
     Result res;
     // Ignore output parameters as the call should fail
-    ASSERT_OK(stream->prepareForWriting(frameSize, framesCount,
-                                        [&res](auto r, auto&, auto&, auto&, auto&) { res = r; }));
+    ASSERT_OK(stream->prepareForWriting(
+        frameSize, framesCount,
+        [&res](auto r, auto&, auto&, auto&, auto&) { res = r; }));
     EXPECT_RESULT(invalidArgsOrNotSupported, res);
 }
 
+TEST_P(OutputStreamTest, PrepareForWriteWithZeroBuffer) {
+    doc::test(
+        "Preparing a stream for writing with a 0 sized buffer should fail");
+    testPrepareForWriting(stream.get(), 0, 0);
+}
+
 TEST_P(OutputStreamTest, PrepareForWriteWithHugeBuffer) {
-    doc::test("Preparing a stream for writing with a 2^32 sized buffer should fail");
-    testPrepareForWriting(stream.get(), 1, std::numeric_limits<uint32_t>::max());
+    doc::test(
+        "Preparing a stream for writing with a 2^32 sized buffer should fail");
+    testPrepareForWriting(stream.get(), 1,
+                          std::numeric_limits<uint32_t>::max());
 }
 
 TEST_P(OutputStreamTest, PrepareForWritingCheckOverflow) {
-    doc::test("Preparing a stream for writing with a overflowing sized buffer should fail");
+    doc::test(
+        "Preparing a stream for writing with a overflowing sized buffer should "
+        "fail");
     auto uintMax = std::numeric_limits<uint32_t>::max();
     testPrepareForWriting(stream.get(), uintMax, uintMax);
 }
@@ -999,7 +1172,7 @@
     Capability(IStreamOut* stream) {
         EXPECT_OK(stream->supportsPauseAndResume(returnIn(pause, resume)));
         auto ret = stream->supportsDrain();
-        EXPECT_TRUE(ret.isOk());
+        EXPECT_IS_OK(ret);
         if (ret.isOk()) {
             drain = ret;
         }
@@ -1010,31 +1183,44 @@
 };
 
 TEST_P(OutputStreamTest, SupportsPauseAndResumeAndDrain) {
-    doc::test("Implementation must expose pause, resume and drain capabilities");
+    doc::test(
+        "Implementation must expose pause, resume and drain capabilities");
     Capability(stream.get());
 }
 
+template <class Value>
+static void checkInvalidStateOr0(Result res, Value value) {
+    switch (res) {
+        case Result::INVALID_STATE:
+            break;
+        case Result::OK:
+            ASSERT_EQ(0U, value);
+            break;
+        default:
+            FAIL() << "Unexpected result " << toString(res);
+    }
+}
+
 TEST_P(OutputStreamTest, GetRenderPosition) {
-    doc::test("The render position should be 0 on a not started");
+    doc::test("A new stream render position should be 0 or INVALID_STATE");
     uint32_t dspFrames;
     ASSERT_OK(stream->getRenderPosition(returnIn(res, dspFrames)));
     if (res == Result::NOT_SUPPORTED) {
         doc::partialTest("getRenderPosition is not supported");
         return;
     }
-    ASSERT_OK(res);
-    ASSERT_EQ(0U, dspFrames);
+    checkInvalidStateOr0(res, dspFrames);
 }
 
 TEST_P(OutputStreamTest, GetNextWriteTimestamp) {
-    doc::test("The render position of a stream just created should be 0");
+    doc::test("A new stream next write timestamp should be 0 or INVALID_STATE");
     uint64_t timestampUs;
     ASSERT_OK(stream->getNextWriteTimestamp(returnIn(res, timestampUs)));
     if (res == Result::NOT_SUPPORTED) {
         doc::partialTest("getNextWriteTimestamp is not supported");
         return;
     }
-    ASSERT_EQ(Result::INVALID_STATE, res);
+    checkInvalidStateOr0(res, timestampUs);
 }
 
 /** Stub implementation of out stream callback. */
@@ -1044,16 +1230,19 @@
     Return<void> onError() override { return {}; }
 };
 
-static bool isAsyncModeSupported(IStreamOut *stream) {
+static bool isAsyncModeSupported(IStreamOut* stream) {
     auto res = stream->setCallback(new MockOutCallbacks);
-    stream->clearCallback(); // try to restore the no callback state, ignore any error
-    auto okOrNotSupported = { Result::OK, Result::NOT_SUPPORTED };
+    stream->clearCallback();  // try to restore the no callback state, ignore
+                              // any error
+    auto okOrNotSupported = {Result::OK, Result::NOT_SUPPORTED};
     EXPECT_RESULT(okOrNotSupported, res);
     return res.isOk() ? res == Result::OK : false;
 }
 
 TEST_P(OutputStreamTest, SetCallback) {
-    doc::test("If supported, registering callback for async operation should never fail");
+    doc::test(
+        "If supported, registering callback for async operation should never "
+        "fail");
     if (!isAsyncModeSupported(stream.get())) {
         doc::partialTest("The stream does not support async operations");
         return;
@@ -1063,7 +1252,9 @@
 }
 
 TEST_P(OutputStreamTest, clearCallback) {
-    doc::test("If supported, clearing a callback to go back to sync operation should not fail");
+    doc::test(
+        "If supported, clearing a callback to go back to sync operation should "
+        "not fail");
     if (!isAsyncModeSupported(stream.get())) {
         doc::partialTest("The stream does not support async operations");
         return;
@@ -1074,7 +1265,9 @@
 }
 
 TEST_P(OutputStreamTest, Resume) {
-    doc::test("If supported, a stream should fail to resume if not previously paused");
+    doc::test(
+        "If supported, a stream should fail to resume if not previously "
+        "paused");
     if (!Capability(stream.get()).resume) {
         doc::partialTest("The output stream does not support resume");
         return;
@@ -1083,7 +1276,9 @@
 }
 
 TEST_P(OutputStreamTest, Pause) {
-    doc::test("If supported, a stream should fail to pause if not previously started");
+    doc::test(
+        "If supported, a stream should fail to pause if not previously "
+        "started");
     if (!Capability(stream.get()).pause) {
         doc::partialTest("The output stream does not support pause");
         return;
@@ -1091,7 +1286,7 @@
     ASSERT_RESULT(Result::INVALID_STATE, stream->resume());
 }
 
-static void testDrain(IStreamOut *stream, AudioDrain type) {
+static void testDrain(IStreamOut* stream, AudioDrain type) {
     if (!Capability(stream).drain) {
         doc::partialTest("The output stream does not support drain");
         return;
@@ -1112,7 +1307,7 @@
 TEST_P(OutputStreamTest, FlushStop) {
     doc::test("If supported, a stream should always succeed to flush");
     auto ret = stream->flush();
-    ASSERT_TRUE(ret.isOk());
+    ASSERT_IS_OK(ret);
     if (ret == Result::NOT_SUPPORTED) {
         doc::partialTest("Flush is not supported");
         return;
@@ -1121,7 +1316,9 @@
 }
 
 TEST_P(OutputStreamTest, GetPresentationPositionStop) {
-    doc::test("If supported, a stream should always succeed to retrieve the presentation position");
+    doc::test(
+        "If supported, a stream should always succeed to retrieve the "
+        "presentation position");
     uint64_t frames;
     TimeSpec mesureTS;
     ASSERT_OK(stream->getPresentationPosition(returnIn(res, frames, mesureTS)));
@@ -1131,66 +1328,81 @@
     }
     ASSERT_EQ(0U, frames);
 
+    if (mesureTS.tvNSec == 0 && mesureTS.tvSec == 0) {
+        // As the stream has never written a frame yet,
+        // the timestamp does not really have a meaning, allow to return 0
+        return;
+    }
+
+    // Make sure the return measure is not more than 1s old.
     struct timespec currentTS;
     ASSERT_EQ(0, clock_gettime(CLOCK_MONOTONIC, &currentTS)) << errno;
 
-    auto toMicroSec = [](uint64_t sec, auto nsec) { return sec * 1e+6 + nsec / 1e+3; };
+    auto toMicroSec = [](uint64_t sec, auto nsec) {
+        return sec * 1e+6 + nsec / 1e+3;
+    };
     auto currentTime = toMicroSec(currentTS.tv_sec, currentTS.tv_nsec);
     auto mesureTime = toMicroSec(mesureTS.tvSec, mesureTS.tvNSec);
-    ASSERT_PRED2([](auto c, auto m){ return  c - m < 1e+6; }, currentTime, mesureTime);
+    ASSERT_PRED2([](auto c, auto m) { return c - m < 1e+6; }, currentTime,
+                 mesureTime);
 }
 
-
 //////////////////////////////////////////////////////////////////////////////
 /////////////////////////////// PrimaryDevice ////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-
 TEST_F(AudioPrimaryHidlTest, setVoiceVolume) {
     doc::test("Make sure setVoiceVolume only succeed if volume is in [0,1]");
-    testUnitaryGain([this](float volume) { return device->setVoiceVolume(volume); });
+    testUnitaryGain(
+        [this](float volume) { return device->setVoiceVolume(volume); });
 }
 
 TEST_F(AudioPrimaryHidlTest, setMode) {
-    doc::test("Make sure setMode always succeeds if mode is valid");
-    for (AudioMode mode : {AudioMode::IN_CALL, AudioMode::IN_COMMUNICATION,
-                           AudioMode::RINGTONE, AudioMode::CURRENT,
-                           AudioMode::NORMAL /* Make sure to leave the test in normal mode */ }) {
+    doc::test(
+        "Make sure setMode always succeeds if mode is valid "
+        "and fails otherwise");
+    // Test Invalid values
+    for (AudioMode mode :
+         {AudioMode::INVALID, AudioMode::CURRENT, AudioMode::CNT}) {
+        SCOPED_TRACE("mode=" + toString(mode));
+        ASSERT_RESULT(Result::INVALID_ARGUMENTS, device->setMode(mode));
+    }
+    // Test valid values
+    for (AudioMode mode :
+         {AudioMode::IN_CALL, AudioMode::IN_COMMUNICATION, AudioMode::RINGTONE,
+          AudioMode::NORMAL /* Make sure to leave the test in normal mode */}) {
         SCOPED_TRACE("mode=" + toString(mode));
         ASSERT_OK(device->setMode(mode));
     }
-
-    // FIXME: Missing api doc. What should the impl do if the mode is invalid ?
-    ASSERT_RESULT(Result::INVALID_ARGUMENTS, device->setMode(AudioMode::INVALID));
 }
 
-
 TEST_F(BoolAccessorPrimaryHidlTest, BtScoNrecEnabled) {
     doc::test("Query and set the BT SCO NR&EC state");
     testOptionalAccessors("BtScoNrecEnabled", {true, false, true},
-                         &IPrimaryDevice::setBtScoNrecEnabled,
-                         &IPrimaryDevice::getBtScoNrecEnabled);
+                          &IPrimaryDevice::setBtScoNrecEnabled,
+                          &IPrimaryDevice::getBtScoNrecEnabled);
 }
 
 TEST_F(BoolAccessorPrimaryHidlTest, setGetBtScoWidebandEnabled) {
     doc::test("Query and set the SCO whideband state");
     testOptionalAccessors("BtScoWideband", {true, false, true},
-                         &IPrimaryDevice::setBtScoWidebandEnabled,
-                         &IPrimaryDevice::getBtScoWidebandEnabled);
+                          &IPrimaryDevice::setBtScoWidebandEnabled,
+                          &IPrimaryDevice::getBtScoWidebandEnabled);
 }
 
 using TtyModeAccessorPrimaryHidlTest = AccessorPrimaryHidlTest<TtyMode>;
 TEST_F(TtyModeAccessorPrimaryHidlTest, setGetTtyMode) {
     doc::test("Query and set the TTY mode state");
-    testOptionalAccessors("TTY mode", {TtyMode::OFF, TtyMode::HCO, TtyMode::VCO, TtyMode::FULL},
-                          &IPrimaryDevice::setTtyMode, &IPrimaryDevice::getTtyMode);
+    testOptionalAccessors(
+        "TTY mode", {TtyMode::OFF, TtyMode::HCO, TtyMode::VCO, TtyMode::FULL},
+        &IPrimaryDevice::setTtyMode, &IPrimaryDevice::getTtyMode);
 }
 
 TEST_F(BoolAccessorPrimaryHidlTest, setGetHac) {
     doc::test("Query and set the HAC state");
-    testAccessors("HAC", {true, false, true},
-                         &IPrimaryDevice::setHacEnabled,
-                         &IPrimaryDevice::getHacEnabled);
+    testOptionalAccessors("HAC", {true, false, true},
+                          &IPrimaryDevice::setHacEnabled,
+                          &IPrimaryDevice::getHacEnabled);
 }
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/audio/2.0/vts/functional/utility/AssertOk.h b/audio/2.0/vts/functional/utility/AssertOk.h
index 10b088c..4c8440e 100644
--- a/audio/2.0/vts/functional/utility/AssertOk.h
+++ b/audio/2.0/vts/functional/utility/AssertOk.h
@@ -14,58 +14,105 @@
  * limitations under the License.
  */
 
-#include <vector>
 #include <algorithm>
+#include <vector>
 
 #include <hidl/Status.h>
 
 namespace detail {
 
-// This is a detail namespace, thus it is OK to import a class as nobody else is allowed to use it
+// This is a detail namespace, thus it is OK to import a class as nobody else is
+// allowed to use it
 using ::android::hardware::Return;
 using ::android::hardware::audio::V2_0::Result;
 
-inline void assertResult(Result expected, Result result) {
-    ASSERT_EQ(expected, result);
+template <class T>
+inline ::testing::AssertionResult assertIsOk(const char* expr,
+                                             const Return<T>& ret) {
+    return ::testing::AssertionResult(ret.isOk())
+           << "Expected: " << expr
+           << "\n to be an OK Return but it is not: " << ret.description();
 }
 
-inline void assertResult(Result expected, const Return<Result> &ret) {
-    ASSERT_TRUE(ret.isOk());
-    Result result = ret;
-    assertResult(expected, result);
+// Call continuation if the provided result isOk
+template <class T, class Continuation>
+inline ::testing::AssertionResult continueIfIsOk(const char* expr,
+                                                 const Return<T>& ret,
+                                                 Continuation continuation) {
+    auto isOkStatus = assertIsOk(expr, ret);
+    return !isOkStatus ? isOkStatus : continuation();
 }
 
-inline void assertResult(const std::vector<Result> &expected, Result result) {
+// Expect two equal Results
+inline ::testing::AssertionResult assertResult(const char* e_expr,
+                                               const char* r_expr,
+                                               Result expected, Result result) {
+    return ::testing::AssertionResult(expected == result)
+           << "Value of: " << r_expr
+           << "\n  Actual: " << ::testing::PrintToString(result)
+           << "\nExpected: " << e_expr
+           << "\nWhich is: " << ::testing::PrintToString(expected);
+}
+
+// Expect two equal Results one being wrapped in an OK Return
+inline ::testing::AssertionResult assertResult(const char* e_expr,
+                                               const char* r_expr,
+                                               Result expected,
+                                               const Return<Result>& ret) {
+    return continueIfIsOk(r_expr, ret, [&] {
+        return assertResult(e_expr, r_expr, expected, Result{ret});
+    });
+}
+
+// Expect a Result to be part of a list of Results
+inline ::testing::AssertionResult assertResult(
+    const char* e_expr, const char* r_expr, const std::vector<Result>& expected,
+    Result result) {
     if (std::find(expected.begin(), expected.end(), result) != expected.end()) {
-        return; // result is in expected
+        return ::testing::AssertionSuccess();  // result is in expected
     }
-    FAIL() << "Expected result " << ::testing::PrintToString(result)
-           << " to be one of " << ::testing::PrintToString(expected);
+    return ::testing::AssertionFailure()
+           << "Value of: " << r_expr
+           << "\n  Actual: " << ::testing::PrintToString(result)
+           << "\nExpected one of: " << e_expr
+           << "\n       Which is: " << ::testing::PrintToString(expected);
 }
 
-inline void assertResult(const std::vector<Result> &expected, const Return<Result> &ret) {
-    ASSERT_TRUE(ret.isOk());
-    Result result = ret;
-    assertResult(expected, result);
+// Expect a Result wrapped in an OK Return to be part of a list of Results
+inline ::testing::AssertionResult assertResult(
+    const char* e_expr, const char* r_expr, const std::vector<Result>& expected,
+    const Return<Result>& ret) {
+    return continueIfIsOk(r_expr, ret, [&] {
+        return assertResult(e_expr, r_expr, expected, Result{ret});
+    });
 }
 
-inline void assertOk(const Return<void> &ret) {
-    ASSERT_TRUE(ret.isOk());
+inline ::testing::AssertionResult assertOk(const char* expr,
+                                           const Return<void>& ret) {
+    return assertIsOk(expr, ret);
 }
 
-inline void assertOk(Result result) {
-    assertResult(Result::OK, result);
+inline ::testing::AssertionResult assertOk(const char* expr, Result result) {
+    return ::testing::AssertionResult(result == Result::OK)
+           << "Expected success: " << expr
+           << "\nActual: " << ::testing::PrintToString(result);
 }
 
-inline void assertOk(const Return<Result> &ret) {
-    assertResult(Result::OK, ret);
+inline ::testing::AssertionResult assertOk(const char* expr,
+                                           const Return<Result>& ret) {
+    return continueIfIsOk(expr, ret,
+                          [&] { return assertOk(expr, Result{ret}); });
+}
 }
 
-}
+#define ASSERT_IS_OK(ret) ASSERT_PRED_FORMAT1(detail::assertIsOk, ret)
+#define EXPECT_IS_OK(ret) EXPECT_PRED_FORMAT1(detail::assertIsOk, ret)
 
 // Test anything provided is and contains only OK
-#define ASSERT_OK(ret) ASSERT_NO_FATAL_FAILURE(detail::assertOk(ret))
-#define EXPECT_OK(ret) EXPECT_NO_FATAL_FAILURE(detail::assertOk(ret))
+#define ASSERT_OK(ret) ASSERT_PRED_FORMAT1(detail::assertOk, ret)
+#define EXPECT_OK(ret) EXPECT_PRED_FORMAT1(detail::assertOk, ret)
 
-#define ASSERT_RESULT(expected, ret) ASSERT_NO_FATAL_FAILURE(detail::assertResult(expected, ret))
-#define EXPECT_RESULT(expected, ret) EXPECT_NO_FATAL_FAILURE(detail::assertResult(expected, ret))
+#define ASSERT_RESULT(expected, ret) \
+    ASSERT_PRED_FORMAT2(detail::assertResult, expected, ret)
+#define EXPECT_RESULT(expected, ret) \
+    EXPECT_PRED_FORMAT2(detail::assertResult, expected, ret)
diff --git a/audio/common/2.0/Android.bp b/audio/common/2.0/Android.bp
index fa80d20..f198c15 100644
--- a/audio/common/2.0/Android.bp
+++ b/audio/common/2.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.audio.common@2.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio.common@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio.common@2.0",
     srcs: [
         ":android.hardware.audio.common@2.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.audio.common@2.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio.common@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio.common@2.0",
     srcs: [
         ":android.hardware.audio.common@2.0_hal",
     ],
diff --git a/audio/effect/2.0/Android.bp b/audio/effect/2.0/Android.bp
index 6f8e83c..2ca7e7e 100644
--- a/audio/effect/2.0/Android.bp
+++ b/audio/effect/2.0/Android.bp
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.audio.effect@2.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio.effect@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio.effect@2.0",
     srcs: [
         ":android.hardware.audio.effect@2.0_hal",
     ],
@@ -50,7 +50,7 @@
 genrule {
     name: "android.hardware.audio.effect@2.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio.effect@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio.effect@2.0",
     srcs: [
         ":android.hardware.audio.effect@2.0_hal",
     ],
diff --git a/automotive/evs/1.0/Android.bp b/automotive/evs/1.0/Android.bp
index ea9eb65..2348c97 100644
--- a/automotive/evs/1.0/Android.bp
+++ b/automotive/evs/1.0/Android.bp
@@ -14,7 +14,7 @@
 genrule {
     name: "android.hardware.automotive.evs@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.evs@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.evs@1.0",
     srcs: [
         ":android.hardware.automotive.evs@1.0_hal",
     ],
@@ -30,7 +30,7 @@
 genrule {
     name: "android.hardware.automotive.evs@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.evs@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.evs@1.0",
     srcs: [
         ":android.hardware.automotive.evs@1.0_hal",
     ],
diff --git a/automotive/vehicle/2.0/Android.bp b/automotive/vehicle/2.0/Android.bp
index 6ad4b03..5e56ab8 100644
--- a/automotive/vehicle/2.0/Android.bp
+++ b/automotive/vehicle/2.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.automotive.vehicle@2.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.vehicle@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.vehicle@2.0",
     srcs: [
         ":android.hardware.automotive.vehicle@2.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.automotive.vehicle@2.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.vehicle@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.vehicle@2.0",
     srcs: [
         ":android.hardware.automotive.vehicle@2.0_hal",
     ],
diff --git a/automotive/vehicle/2.1/Android.bp b/automotive/vehicle/2.1/Android.bp
index d863840..5e4e36b 100644
--- a/automotive/vehicle/2.1/Android.bp
+++ b/automotive/vehicle/2.1/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.automotive.vehicle@2.1_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.vehicle@2.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.vehicle@2.1",
     srcs: [
         ":android.hardware.automotive.vehicle@2.1_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.automotive.vehicle@2.1_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.vehicle@2.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.automotive.vehicle@2.1",
     srcs: [
         ":android.hardware.automotive.vehicle@2.1_hal",
     ],
diff --git a/biometrics/fingerprint/2.1/Android.bp b/biometrics/fingerprint/2.1/Android.bp
index 8145eaa..3f0a4d3 100644
--- a/biometrics/fingerprint/2.1/Android.bp
+++ b/biometrics/fingerprint/2.1/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.biometrics.fingerprint@2.1_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1",
     srcs: [
         ":android.hardware.biometrics.fingerprint@2.1_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.biometrics.fingerprint@2.1_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1",
     srcs: [
         ":android.hardware.biometrics.fingerprint@2.1_hal",
     ],
diff --git a/bluetooth/1.0/Android.bp b/bluetooth/1.0/Android.bp
index 2c965ed..4cc3b50 100644
--- a/bluetooth/1.0/Android.bp
+++ b/bluetooth/1.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.bluetooth@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.bluetooth@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.bluetooth@1.0",
     srcs: [
         ":android.hardware.bluetooth@1.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.bluetooth@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.bluetooth@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.bluetooth@1.0",
     srcs: [
         ":android.hardware.bluetooth@1.0_hal",
     ],
diff --git a/bluetooth/1.0/default/service.cpp b/bluetooth/1.0/default/service.cpp
index fa5106f..a588c37 100644
--- a/bluetooth/1.0/default/service.cpp
+++ b/bluetooth/1.0/default/service.cpp
@@ -20,10 +20,13 @@
 
 #include <hidl/LegacySupport.h>
 
+// Add an extra thread for calls to the scheduler service.
+static const size_t kMaxThreads = 2;
+
 // Generated HIDL files
 using android::hardware::bluetooth::V1_0::IBluetoothHci;
 using android::hardware::defaultPassthroughServiceImplementation;
 
 int main() {
-  return defaultPassthroughServiceImplementation<IBluetoothHci>();
+    return defaultPassthroughServiceImplementation<IBluetoothHci>(kMaxThreads);
 }
diff --git a/boot/1.0/Android.bp b/boot/1.0/Android.bp
index 807ae02..d75d6ac 100644
--- a/boot/1.0/Android.bp
+++ b/boot/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.boot@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.boot@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.boot@1.0",
     srcs: [
         ":android.hardware.boot@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.boot@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.boot@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.boot@1.0",
     srcs: [
         ":android.hardware.boot@1.0_hal",
     ],
diff --git a/broadcastradio/1.0/Android.bp b/broadcastradio/1.0/Android.bp
index 61e9a2c..4929167 100644
--- a/broadcastradio/1.0/Android.bp
+++ b/broadcastradio/1.0/Android.bp
@@ -14,7 +14,7 @@
 genrule {
     name: "android.hardware.broadcastradio@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.broadcastradio@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.broadcastradio@1.0",
     srcs: [
         ":android.hardware.broadcastradio@1.0_hal",
     ],
@@ -30,7 +30,7 @@
 genrule {
     name: "android.hardware.broadcastradio@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.broadcastradio@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.broadcastradio@1.0",
     srcs: [
         ":android.hardware.broadcastradio@1.0_hal",
     ],
diff --git a/broadcastradio/1.1/Android.bp b/broadcastradio/1.1/Android.bp
index f9819b7..c01c605 100644
--- a/broadcastradio/1.1/Android.bp
+++ b/broadcastradio/1.1/Android.bp
@@ -14,7 +14,7 @@
 genrule {
     name: "android.hardware.broadcastradio@1.1_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.broadcastradio@1.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.broadcastradio@1.1",
     srcs: [
         ":android.hardware.broadcastradio@1.1_hal",
     ],
@@ -30,7 +30,7 @@
 genrule {
     name: "android.hardware.broadcastradio@1.1_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.broadcastradio@1.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.broadcastradio@1.1",
     srcs: [
         ":android.hardware.broadcastradio@1.1_hal",
     ],
diff --git a/camera/common/1.0/Android.bp b/camera/common/1.0/Android.bp
index 76f1cf3..8c6aa43 100644
--- a/camera/common/1.0/Android.bp
+++ b/camera/common/1.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.camera.common@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.common@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.common@1.0",
     srcs: [
         ":android.hardware.camera.common@1.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.camera.common@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.common@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.common@1.0",
     srcs: [
         ":android.hardware.camera.common@1.0_hal",
     ],
diff --git a/camera/common/1.0/default/CameraMetadata.cpp b/camera/common/1.0/default/CameraMetadata.cpp
index 0e7ef6e..4c54931 100644
--- a/camera/common/1.0/default/CameraMetadata.cpp
+++ b/camera/common/1.0/default/CameraMetadata.cpp
@@ -508,8 +508,6 @@
         }
     }
 
-    // TODO: Make above get_camera_metadata_section_from_name ?
-
     if (section == NULL) {
         return NAME_NOT_FOUND;
     } else {
diff --git a/camera/common/1.0/default/include/HandleImporter.h b/camera/common/1.0/default/include/HandleImporter.h
index c68cfc0..e47397c 100644
--- a/camera/common/1.0/default/include/HandleImporter.h
+++ b/camera/common/1.0/default/include/HandleImporter.h
@@ -17,9 +17,9 @@
 #ifndef CAMERA_COMMON_1_0_HANDLEIMPORTED_H
 #define CAMERA_COMMON_1_0_HANDLEIMPORTED_H
 
-#include <system/window.h>
 #include <utils/Mutex.h>
 #include <android/hardware/graphics/mapper/2.0/IMapper.h>
+#include <cutils/native_handle.h>
 
 using android::hardware::graphics::mapper::V2_0::IMapper;
 
diff --git a/camera/device/1.0/Android.bp b/camera/device/1.0/Android.bp
index f16c776..0a888e6 100644
--- a/camera/device/1.0/Android.bp
+++ b/camera/device/1.0/Android.bp
@@ -13,7 +13,7 @@
 genrule {
     name: "android.hardware.camera.device@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.device@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.device@1.0",
     srcs: [
         ":android.hardware.camera.device@1.0_hal",
     ],
@@ -28,7 +28,7 @@
 genrule {
     name: "android.hardware.camera.device@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.device@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.device@1.0",
     srcs: [
         ":android.hardware.camera.device@1.0_hal",
     ],
diff --git a/camera/device/1.0/ICameraDeviceCallback.hal b/camera/device/1.0/ICameraDeviceCallback.hal
index 1dfcd80..4e2e719 100644
--- a/camera/device/1.0/ICameraDeviceCallback.hal
+++ b/camera/device/1.0/ICameraDeviceCallback.hal
@@ -33,8 +33,6 @@
      * Define a memory buffer from the provided handle and size, and return a
      * unique identifier for the HAL to use to reference it with.
      *
-     * TODO(b/33269977): Ensure this aligns with design and performance goals.
-     *
      * @param descriptor A native handle that must have exactly one file
      *     descriptor in it; the file descriptor must be memory mappable to
      *     bufferSize * bufferCount bytes.
diff --git a/camera/device/1.0/default/CameraDevice.cpp b/camera/device/1.0/default/CameraDevice.cpp
index 4f26c54..6f4e70f 100644
--- a/camera/device/1.0/default/CameraDevice.cpp
+++ b/camera/device/1.0/default/CameraDevice.cpp
@@ -183,7 +183,6 @@
 }
 
 int CameraDevice::sLockBuffer(struct preview_stream_ops*, buffer_handle_t*) {
-    // TODO: make sure lock_buffer is indeed a no-op (and will always be)
     return 0;
 }
 
@@ -585,8 +584,6 @@
             cameraInfo.facing = (CameraFacing) info.facing;
             // Device 1.0 does not support external camera facing.
             // The closest approximation would be front camera.
-            // TODO: figure out should we override here or let
-            //       camera service handle it.
             if (cameraInfo.facing == CameraFacing::EXTERNAL) {
                 cameraInfo.facing = CameraFacing::FRONT;
             }
diff --git a/camera/device/3.2/Android.bp b/camera/device/3.2/Android.bp
index 30f0431..1162e6c 100644
--- a/camera/device/3.2/Android.bp
+++ b/camera/device/3.2/Android.bp
@@ -13,7 +13,7 @@
 genrule {
     name: "android.hardware.camera.device@3.2_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.device@3.2",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.device@3.2",
     srcs: [
         ":android.hardware.camera.device@3.2_hal",
     ],
@@ -28,7 +28,7 @@
 genrule {
     name: "android.hardware.camera.device@3.2_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.device@3.2",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.device@3.2",
     srcs: [
         ":android.hardware.camera.device@3.2_hal",
     ],
diff --git a/camera/metadata/3.2/Android.bp b/camera/metadata/3.2/Android.bp
index 0534b9c..c3cd28e 100644
--- a/camera/metadata/3.2/Android.bp
+++ b/camera/metadata/3.2/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.camera.metadata@3.2_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.metadata@3.2",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.metadata@3.2",
     srcs: [
         ":android.hardware.camera.metadata@3.2_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.camera.metadata@3.2_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.metadata@3.2",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.metadata@3.2",
     srcs: [
         ":android.hardware.camera.metadata@3.2_hal",
     ],
diff --git a/camera/metadata/3.2/types.hal b/camera/metadata/3.2/types.hal
index 2b4b287..17d1d5e 100644
--- a/camera/metadata/3.2/types.hal
+++ b/camera/metadata/3.2/types.hal
@@ -16,14 +16,6 @@
 
 package android.hardware.camera.metadata@3.2;
 
-/** TODO(b/33012412):
- *   - The following information should be code-generated from:
- *     system/media/camera/docs/metadata_properties.xml
- *   - Some enum below should be signed:
- *       - metadata section/key should be unsigned
- *       - matadata value enum should be signed
- */
-
 /**
  * Top level hierarchy definitions for camera metadata. *_INFO sections are for
  * the static metadata that can be retrived without opening the camera device.
diff --git a/camera/provider/2.4/Android.bp b/camera/provider/2.4/Android.bp
index 900a97c..c34ab32 100644
--- a/camera/provider/2.4/Android.bp
+++ b/camera/provider/2.4/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.camera.provider@2.4_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.provider@2.4",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.provider@2.4",
     srcs: [
         ":android.hardware.camera.provider@2.4_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.camera.provider@2.4_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.provider@2.4",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.camera.provider@2.4",
     srcs: [
         ":android.hardware.camera.provider@2.4_hal",
     ],
diff --git a/camera/provider/2.4/default/CameraProvider.cpp b/camera/provider/2.4/default/CameraProvider.cpp
index 791b93c..19f7bdd 100644
--- a/camera/provider/2.4/default/CameraProvider.cpp
+++ b/camera/provider/2.4/default/CameraProvider.cpp
@@ -461,10 +461,6 @@
         return Void();
     }
 
-    // TODO: we also need to keep a wp list of all generated devices to notify
-    //       devices of device present status change, but then each device might
-    //       need a sp<provider> to keep provider alive until all device closed?
-    //       Problem: do we have external camera products to test this?
     sp<android::hardware::camera::device::V3_2::implementation::CameraDevice> device =
             new android::hardware::camera::device::V3_2::implementation::CameraDevice(
                     mModule, cameraId, mCameraDeviceNames);
diff --git a/camera/provider/2.4/default/android.hardware.camera.provider@2.4-service.rc b/camera/provider/2.4/default/android.hardware.camera.provider@2.4-service.rc
index 192870b..2bf309b 100644
--- a/camera/provider/2.4/default/android.hardware.camera.provider@2.4-service.rc
+++ b/camera/provider/2.4/default/android.hardware.camera.provider@2.4-service.rc
@@ -3,4 +3,5 @@
     user cameraserver
     group audio camera input drmrpc
     ioprio rt 4
-    writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/tasks
\ No newline at end of file
+    capabilities SYS_NICE
+    writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/tasks
diff --git a/configstore/1.0/Android.bp b/configstore/1.0/Android.bp
index 4993dc3..db7ec97 100644
--- a/configstore/1.0/Android.bp
+++ b/configstore/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.configstore@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.configstore@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.configstore@1.0",
     srcs: [
         ":android.hardware.configstore@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.configstore@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.configstore@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.configstore@1.0",
     srcs: [
         ":android.hardware.configstore@1.0_hal",
     ],
diff --git a/configstore/utils/include/configstore/Utils.h b/configstore/utils/include/configstore/Utils.h
index a54ce85..c9c830b 100644
--- a/configstore/utils/include/configstore/Utils.h
+++ b/configstore/utils/include/configstore/Utils.h
@@ -17,7 +17,7 @@
 #ifndef ANDROID_HARDWARE_CONFIGSTORE_UTILS_H
 #define ANDROID_HARDWARE_CONFIGSTORE_UTILS_H
 
-#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
+#include <android/hardware/configstore/1.0/types.h>
 #include <hidl/Status.h>
 
 #include <sstream>
@@ -34,7 +34,14 @@
 }  // namespace details
 
 namespace configstore {
-using namespace android::hardware::configstore::V1_0;
+// import types from V1_0
+using ::android::hardware::configstore::V1_0::OptionalBool;
+using ::android::hardware::configstore::V1_0::OptionalInt32;
+using ::android::hardware::configstore::V1_0::OptionalUInt32;
+using ::android::hardware::configstore::V1_0::OptionalInt64;
+using ::android::hardware::configstore::V1_0::OptionalUInt64;
+using ::android::hardware::configstore::V1_0::OptionalString;
+
 // arguments V: type for the value (i.e., OptionalXXX)
 //           I: interface class name
 //           func: member function pointer
diff --git a/contexthub/1.0/Android.bp b/contexthub/1.0/Android.bp
index 80ce80b..736ec7e 100644
--- a/contexthub/1.0/Android.bp
+++ b/contexthub/1.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.contexthub@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.contexthub@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.contexthub@1.0",
     srcs: [
         ":android.hardware.contexthub@1.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.contexthub@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.contexthub@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.contexthub@1.0",
     srcs: [
         ":android.hardware.contexthub@1.0_hal",
     ],
diff --git a/current.txt b/current.txt
index 82a1626..f22918c 100644
--- a/current.txt
+++ b/current.txt
@@ -50,14 +50,14 @@
 bd42c8d7838cfed1998b49c39745dec116d2d6edc2c11a4c0399b8f3a1d1655a android.hardware.broadcastradio@1.0::types
 81164323115d6588e259e8319fddf7487adfa1f49ce60f7e80ba74e0783392a4 android.hardware.camera.common@1.0::types
 c1705e9d62438a1d955269965af915ae28e692bd480a3b1ce67056fef992d62f android.hardware.camera.device@1.0::ICameraDevice
-2b6f81bba23b652736184d19f76a2358e9bb5f5295133406d155f0d37c7bac40 android.hardware.camera.device@1.0::ICameraDeviceCallback
+78e9b44cf8660bdc1e98dca07451804153824efcd28db208a62f5ad728f44076 android.hardware.camera.device@1.0::ICameraDeviceCallback
 28f0386ba86ddf41e53a8117b48a0328d7a4d2574213e89f4a1062398a244566 android.hardware.camera.device@1.0::ICameraDevicePreviewCallback
 4db48439ce9dde97f1cfb3d7408f6c737f621ac0f7494aeea35ed599bc2352a3 android.hardware.camera.device@1.0::types
 b32f9aeaf1c442195eb06ffc7600968c919d005b2718874f09c57287fae55918 android.hardware.camera.device@3.2::ICameraDevice
 63bfc3da0f2d2301f7a0508c7c2b9ffc521d4d545ee03718da70e9d6273b3b21 android.hardware.camera.device@3.2::ICameraDeviceCallback
 0fa3e1e64819283b8737fc4e5ab759f0cb4ac1a996e8a51cc4aa8025a457208e android.hardware.camera.device@3.2::ICameraDeviceSession
 030be3d2b159cbde7920485807140f6b6064ef4a5de4a40a6c4bc8d2c72f7cd3 android.hardware.camera.device@3.2::types
-a2dc9063c950f73d72a83797412d5ed25e905225d4650baf2c674c4263160295 android.hardware.camera.metadata@3.2::types
+5ba7947cee515d7a2359bfcbfb9678c1c3a768c288471919ac095b96ae6f3d40 android.hardware.camera.metadata@3.2::types
 f7e299d85033ac52d1095a35784fcfeaff43603f58c751e4153c85bbade3b330 android.hardware.camera.provider@2.4::ICameraProvider
 a501ca1aecd09f1b9fd70a9af84205430dbd49a808e8fa395d363b9902e6f58c android.hardware.camera.provider@2.4::ICameraProviderCallback
 7f5fe8f4f8a24037153c504d8b4d3313c2ce33d81c8c69fe5194ddd2d4080e72 android.hardware.configstore@1.0::ISurfaceFlingerConfigs
@@ -130,7 +130,7 @@
 efc83df3f962b93c7c0290d691d7d300dabe12683e2cde3591fb3c0beedce20f android.hardware.power@1.0::types
 9b5aa499ec3b4226f15f48f5ed08896e2fc0676f978c9e199c1da21daaf002a6 android.hardware.radio@1.0::IRadio
 5c8efbb9c451a59737ed2c6c20230aae4745839ca01d8088d6dcc9020e52d2c5 android.hardware.radio@1.0::IRadioIndication
-f72a0b0bd94e87f17900952dc0c43b1b8f661270805e00fc2f2dda358d5e3461 android.hardware.radio@1.0::IRadioResponse
+2b963c12b5b6961a6fcec6e6cbe3ed6cc8c4a7e95916c4947d8196d56aa57ec2 android.hardware.radio@1.0::IRadioResponse
 de3ab9f73b1073cd677b19d886fb927e9381b30161a704712d2b30f875873f5c android.hardware.radio@1.0::ISap
 d183e406ef0897df2117a9dde384e8e6ea4fa6ab1c7f6f28e65b87011218c9ea android.hardware.radio@1.0::ISapCallback
 96986fbd22f0e6ca752e1fcdc0a64bda213995a81f5f36bc4faf3532d9306b97 android.hardware.radio@1.0::types
diff --git a/drm/1.0/Android.bp b/drm/1.0/Android.bp
index 4f49f2a..8e7da0c 100644
--- a/drm/1.0/Android.bp
+++ b/drm/1.0/Android.bp
@@ -15,7 +15,7 @@
 genrule {
     name: "android.hardware.drm@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.drm@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.drm@1.0",
     srcs: [
         ":android.hardware.drm@1.0_hal",
     ],
@@ -32,7 +32,7 @@
 genrule {
     name: "android.hardware.drm@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.drm@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.drm@1.0",
     srcs: [
         ":android.hardware.drm@1.0_hal",
     ],
diff --git a/dumpstate/1.0/Android.bp b/dumpstate/1.0/Android.bp
index cfdf560..3139bf5 100644
--- a/dumpstate/1.0/Android.bp
+++ b/dumpstate/1.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.dumpstate@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.dumpstate@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.dumpstate@1.0",
     srcs: [
         ":android.hardware.dumpstate@1.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.dumpstate@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.dumpstate@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.dumpstate@1.0",
     srcs: [
         ":android.hardware.dumpstate@1.0_hal",
     ],
diff --git a/gatekeeper/1.0/Android.bp b/gatekeeper/1.0/Android.bp
index 7dfa487..6c84f3d 100644
--- a/gatekeeper/1.0/Android.bp
+++ b/gatekeeper/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.gatekeeper@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.gatekeeper@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.gatekeeper@1.0",
     srcs: [
         ":android.hardware.gatekeeper@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.gatekeeper@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.gatekeeper@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.gatekeeper@1.0",
     srcs: [
         ":android.hardware.gatekeeper@1.0_hal",
     ],
diff --git a/gnss/1.0/Android.bp b/gnss/1.0/Android.bp
index 3f729b5..9aa401a 100644
--- a/gnss/1.0/Android.bp
+++ b/gnss/1.0/Android.bp
@@ -30,7 +30,7 @@
 genrule {
     name: "android.hardware.gnss@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.gnss@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.gnss@1.0",
     srcs: [
         ":android.hardware.gnss@1.0_hal",
     ],
@@ -62,7 +62,7 @@
 genrule {
     name: "android.hardware.gnss@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.gnss@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.gnss@1.0",
     srcs: [
         ":android.hardware.gnss@1.0_hal",
     ],
diff --git a/graphics/allocator/2.0/Android.bp b/graphics/allocator/2.0/Android.bp
index b4d656c..debcfb7 100644
--- a/graphics/allocator/2.0/Android.bp
+++ b/graphics/allocator/2.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.graphics.allocator@2.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.allocator@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.allocator@2.0",
     srcs: [
         ":android.hardware.graphics.allocator@2.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.graphics.allocator@2.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.allocator@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.allocator@2.0",
     srcs: [
         ":android.hardware.graphics.allocator@2.0_hal",
     ],
diff --git a/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc b/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc
index 9a08f66..70f2ef8 100644
--- a/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc
+++ b/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc
@@ -2,4 +2,5 @@
     class hal animation
     user system
     group graphics drmrpc
+    capabilities SYS_NICE
     onrestart restart surfaceflinger
diff --git a/graphics/bufferqueue/1.0/Android.bp b/graphics/bufferqueue/1.0/Android.bp
index 1244816..4ae0e34 100644
--- a/graphics/bufferqueue/1.0/Android.bp
+++ b/graphics/bufferqueue/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.graphics.bufferqueue@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.bufferqueue@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.bufferqueue@1.0",
     srcs: [
         ":android.hardware.graphics.bufferqueue@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.graphics.bufferqueue@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.bufferqueue@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.bufferqueue@1.0",
     srcs: [
         ":android.hardware.graphics.bufferqueue@1.0_hal",
     ],
diff --git a/graphics/common/1.0/Android.bp b/graphics/common/1.0/Android.bp
index 69c8844..69e1aa0 100644
--- a/graphics/common/1.0/Android.bp
+++ b/graphics/common/1.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.graphics.common@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.common@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.common@1.0",
     srcs: [
         ":android.hardware.graphics.common@1.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.graphics.common@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.common@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.common@1.0",
     srcs: [
         ":android.hardware.graphics.common@1.0_hal",
     ],
diff --git a/graphics/composer/2.1/Android.bp b/graphics/composer/2.1/Android.bp
index 21e6618..b21f535 100644
--- a/graphics/composer/2.1/Android.bp
+++ b/graphics/composer/2.1/Android.bp
@@ -13,7 +13,7 @@
 genrule {
     name: "android.hardware.graphics.composer@2.1_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.composer@2.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.composer@2.1",
     srcs: [
         ":android.hardware.graphics.composer@2.1_hal",
     ],
@@ -28,7 +28,7 @@
 genrule {
     name: "android.hardware.graphics.composer@2.1_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.composer@2.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.composer@2.1",
     srcs: [
         ":android.hardware.graphics.composer@2.1_hal",
     ],
diff --git a/graphics/mapper/2.0/Android.bp b/graphics/mapper/2.0/Android.bp
index 67c238c..41b106e 100644
--- a/graphics/mapper/2.0/Android.bp
+++ b/graphics/mapper/2.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.graphics.mapper@2.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.mapper@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.mapper@2.0",
     srcs: [
         ":android.hardware.graphics.mapper@2.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.graphics.mapper@2.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.mapper@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.graphics.mapper@2.0",
     srcs: [
         ":android.hardware.graphics.mapper@2.0_hal",
     ],
diff --git a/graphics/mapper/2.0/default/GrallocMapper.h b/graphics/mapper/2.0/default/GrallocMapper.h
index aa1aeaa..e876fe4 100644
--- a/graphics/mapper/2.0/default/GrallocMapper.h
+++ b/graphics/mapper/2.0/default/GrallocMapper.h
@@ -18,7 +18,7 @@
 #define ANDROID_HARDWARE_GRAPHICS_MAPPER_V2_0_GRALLOC_MAPPER_H
 
 #include <android/hardware/graphics/mapper/2.0/IMapper.h>
-#include <system/window.h>
+#include <cutils/native_handle.h>
 
 #include <mutex>
 #include <unordered_set>
diff --git a/health/1.0/Android.bp b/health/1.0/Android.bp
index 3ef216e..6d71315 100644
--- a/health/1.0/Android.bp
+++ b/health/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.health@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.health@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.health@1.0",
     srcs: [
         ":android.hardware.health@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.health@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.health@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.health@1.0",
     srcs: [
         ":android.hardware.health@1.0_hal",
     ],
diff --git a/ir/1.0/Android.bp b/ir/1.0/Android.bp
index 2612bd2..2c53047 100644
--- a/ir/1.0/Android.bp
+++ b/ir/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.ir@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.ir@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.ir@1.0",
     srcs: [
         ":android.hardware.ir@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.ir@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.ir@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.ir@1.0",
     srcs: [
         ":android.hardware.ir@1.0_hal",
     ],
diff --git a/keymaster/3.0/Android.bp b/keymaster/3.0/Android.bp
index a407797..922259c 100644
--- a/keymaster/3.0/Android.bp
+++ b/keymaster/3.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.keymaster@3.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.keymaster@3.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.keymaster@3.0",
     srcs: [
         ":android.hardware.keymaster@3.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.keymaster@3.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.keymaster@3.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.keymaster@3.0",
     srcs: [
         ":android.hardware.keymaster@3.0_hal",
     ],
diff --git a/light/2.0/Android.bp b/light/2.0/Android.bp
index d70848f..d9e999a 100644
--- a/light/2.0/Android.bp
+++ b/light/2.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.light@2.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.light@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.light@2.0",
     srcs: [
         ":android.hardware.light@2.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.light@2.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.light@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.light@2.0",
     srcs: [
         ":android.hardware.light@2.0_hal",
     ],
diff --git a/media/1.0/Android.bp b/media/1.0/Android.bp
index 04a3683..816b605 100644
--- a/media/1.0/Android.bp
+++ b/media/1.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.media@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.media@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.media@1.0",
     srcs: [
         ":android.hardware.media@1.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.media@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.media@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.media@1.0",
     srcs: [
         ":android.hardware.media@1.0_hal",
     ],
diff --git a/media/omx/1.0/Android.bp b/media/omx/1.0/Android.bp
index 65b2489..18a99a2 100644
--- a/media/omx/1.0/Android.bp
+++ b/media/omx/1.0/Android.bp
@@ -16,7 +16,7 @@
 genrule {
     name: "android.hardware.media.omx@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.media.omx@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.media.omx@1.0",
     srcs: [
         ":android.hardware.media.omx@1.0_hal",
     ],
@@ -34,7 +34,7 @@
 genrule {
     name: "android.hardware.media.omx@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.media.omx@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.media.omx@1.0",
     srcs: [
         ":android.hardware.media.omx@1.0_hal",
     ],
diff --git a/memtrack/1.0/Android.bp b/memtrack/1.0/Android.bp
index bc08710..25d4153 100644
--- a/memtrack/1.0/Android.bp
+++ b/memtrack/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.memtrack@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.memtrack@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.memtrack@1.0",
     srcs: [
         ":android.hardware.memtrack@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.memtrack@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.memtrack@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.memtrack@1.0",
     srcs: [
         ":android.hardware.memtrack@1.0_hal",
     ],
diff --git a/nfc/1.0/Android.bp b/nfc/1.0/Android.bp
index d62e0a3..8faf2a1 100644
--- a/nfc/1.0/Android.bp
+++ b/nfc/1.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.nfc@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.nfc@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.nfc@1.0",
     srcs: [
         ":android.hardware.nfc@1.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.nfc@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.nfc@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.nfc@1.0",
     srcs: [
         ":android.hardware.nfc@1.0_hal",
     ],
diff --git a/power/1.0/Android.bp b/power/1.0/Android.bp
index 57ab2cf..9412a88 100644
--- a/power/1.0/Android.bp
+++ b/power/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.power@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.power@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.power@1.0",
     srcs: [
         ":android.hardware.power@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.power@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.power@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.power@1.0",
     srcs: [
         ":android.hardware.power@1.0_hal",
     ],
diff --git a/power/1.1/Android.bp b/power/1.1/Android.bp
new file mode 100644
index 0000000..ab129ff
--- /dev/null
+++ b/power/1.1/Android.bp
@@ -0,0 +1,56 @@
+// This file is autogenerated by hidl-gen. Do not edit manually.
+
+genrule {
+    name: "android.hardware.power@1.1_genc++",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.power@1.1",
+    srcs: [
+        "types.hal",
+        "IPower.hal",
+    ],
+    out: [
+        "android/hardware/power/1.1/types.cpp",
+        "android/hardware/power/1.1/PowerAll.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.power@1.1_genc++_headers",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.power@1.1",
+    srcs: [
+        "types.hal",
+        "IPower.hal",
+    ],
+    out: [
+        "android/hardware/power/1.1/types.h",
+        "android/hardware/power/1.1/IPower.h",
+        "android/hardware/power/1.1/IHwPower.h",
+        "android/hardware/power/1.1/BnHwPower.h",
+        "android/hardware/power/1.1/BpHwPower.h",
+        "android/hardware/power/1.1/BsPower.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.power@1.1",
+    generated_sources: ["android.hardware.power@1.1_genc++"],
+    generated_headers: ["android.hardware.power@1.1_genc++_headers"],
+    export_generated_headers: ["android.hardware.power@1.1_genc++_headers"],
+    shared_libs: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+        "libcutils",
+        "android.hardware.power@1.0",
+    ],
+    export_shared_lib_headers: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "android.hardware.power@1.0",
+    ],
+}
diff --git a/power/1.1/Android.mk b/power/1.1/Android.mk
new file mode 100644
index 0000000..77c5525
--- /dev/null
+++ b/power/1.1/Android.mk
@@ -0,0 +1,158 @@
+# This file is autogenerated by hidl-gen. Do not edit manually.
+
+LOCAL_PATH := $(call my-dir)
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.power-V1.1-java
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(local-generated-sources-dir)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+
+LOCAL_JAVA_LIBRARIES := \
+    android.hardware.power-V1.0-java \
+    android.hidl.base-V1.0-java \
+
+
+#
+# Build types.hal (PowerStateSubsystem)
+#
+GEN := $(intermediates)/android/hardware/power/V1_1/PowerStateSubsystem.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.power@1.1::types.PowerStateSubsystem
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (PowerStateSubsystemSleepState)
+#
+GEN := $(intermediates)/android/hardware/power/V1_1/PowerStateSubsystemSleepState.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.power@1.1::types.PowerStateSubsystemSleepState
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build IPower.hal
+#
+GEN := $(intermediates)/android/hardware/power/V1_1/IPower.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IPower.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) \
+        -Ljava \
+        -randroid.hardware:hardware/interfaces \
+        -randroid.hidl:system/libhidl/transport \
+        android.hardware.power@1.1::IPower
+
+$(GEN): $(LOCAL_PATH)/IPower.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+include $(BUILD_JAVA_LIBRARY)
+
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.power-V1.1-java-static
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(local-generated-sources-dir)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+
+LOCAL_STATIC_JAVA_LIBRARIES := \
+    android.hardware.power-V1.0-java-static \
+    android.hidl.base-V1.0-java-static \
+
+
+#
+# Build types.hal (PowerStateSubsystem)
+#
+GEN := $(intermediates)/android/hardware/power/V1_1/PowerStateSubsystem.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.power@1.1::types.PowerStateSubsystem
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (PowerStateSubsystemSleepState)
+#
+GEN := $(intermediates)/android/hardware/power/V1_1/PowerStateSubsystemSleepState.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.power@1.1::types.PowerStateSubsystemSleepState
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build IPower.hal
+#
+GEN := $(intermediates)/android/hardware/power/V1_1/IPower.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IPower.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) \
+        -Ljava \
+        -randroid.hardware:hardware/interfaces \
+        -randroid.hidl:system/libhidl/transport \
+        android.hardware.power@1.1::IPower
+
+$(GEN): $(LOCAL_PATH)/IPower.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+include $(BUILD_STATIC_JAVA_LIBRARY)
+
+
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/power/1.1/IPower.hal b/power/1.1/IPower.hal
new file mode 100644
index 0000000..0c0f211
--- /dev/null
+++ b/power/1.1/IPower.hal
@@ -0,0 +1,36 @@
+/*
+ * 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.power@1.1;
+
+import android.hardware.power@1.0;
+
+/**
+ * Interface to collect subsystem level sleep information
+ */
+interface IPower extends android.hardware.power@1.0::IPower {
+
+    /**
+     * Subsystem-level sleep state stats:
+     * Report cumulative info on the statistics on subsystem-level sleep states
+     * since boot.
+     *
+     * @return subsystems supported on this device and their sleep states
+     * @return retval SUCCESS on success or FILESYSTEM_ERROR on filesystem
+     * nodes access error.
+     */
+    getSubsystemLowPowerStats()
+            generates (vec<PowerStateSubsystem> subsystems, Status retval);
+};
diff --git a/power/1.1/default/Android.bp b/power/1.1/default/Android.bp
new file mode 100644
index 0000000..0b3598b
--- /dev/null
+++ b/power/1.1/default/Android.bp
@@ -0,0 +1,33 @@
+// 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.
+
+cc_binary {
+    proprietary: true,
+    defaults: ["hidl_defaults"],
+    relative_install_path: "hw",
+    name: "android.hardware.power@1.1-service",
+    init_rc: ["android.hardware.power@1.1-service.rc"],
+    srcs: ["service.cpp" , "Power.cpp"],
+
+    shared_libs: [
+        "liblog",
+        "libdl",
+        "libutils",
+        "libhardware",
+        "libhidlbase",
+        "libhidltransport",
+        "android.hardware.power@1.0",
+        "android.hardware.power@1.1",
+    ],
+}
diff --git a/power/1.1/default/Power.cpp b/power/1.1/default/Power.cpp
new file mode 100644
index 0000000..bf7c1fc
--- /dev/null
+++ b/power/1.1/default/Power.cpp
@@ -0,0 +1,172 @@
+/*
+ * 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.
+ */
+
+#define LOG_TAG "android.hardware.power@1.1-impl"
+
+#include <log/log.h>
+
+#include <hardware/hardware.h>
+#include <hardware/power.h>
+
+#include "Power.h"
+
+namespace android {
+namespace hardware {
+namespace power {
+namespace V1_1 {
+namespace implementation {
+
+using ::android::hardware::power::V1_0::Feature;
+using ::android::hardware::power::V1_0::PowerHint;
+using ::android::hardware::power::V1_0::PowerStatePlatformSleepState;
+using ::android::hardware::power::V1_0::Status;
+using ::android::hardware::power::V1_1::PowerStateSubsystem;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+
+Power::Power(power_module_t *module) : mModule(module) {
+    if (mModule)
+        mModule->init(mModule);
+}
+
+Power::~Power() {
+    delete(mModule);
+}
+
+// Methods from ::android::hardware::power::V1_0::IPower follow.
+Return<void> Power::setInteractive(bool interactive)  {
+    if (mModule->setInteractive)
+        mModule->setInteractive(mModule, interactive ? 1 : 0);
+    return Void();
+}
+
+Return<void> Power::powerHint(PowerHint hint, int32_t data)  {
+    int32_t param = data;
+    if (mModule->powerHint) {
+        if (data)
+            mModule->powerHint(mModule, static_cast<power_hint_t>(hint), &param);
+        else
+            mModule->powerHint(mModule, static_cast<power_hint_t>(hint), NULL);
+    }
+    return Void();
+}
+
+Return<void> Power::setFeature(Feature feature, bool activate)  {
+    if (mModule->setFeature)
+        mModule->setFeature(mModule, static_cast<feature_t>(feature),
+                activate ? 1 : 0);
+    return Void();
+}
+
+Return<void> Power::getPlatformLowPowerStats(getPlatformLowPowerStats_cb _hidl_cb)  {
+    hidl_vec<PowerStatePlatformSleepState> states;
+    ssize_t number_platform_modes;
+    size_t *voters = nullptr;
+    power_state_platform_sleep_state_t *legacy_states = nullptr;
+    int ret;
+
+    if (mModule->get_number_of_platform_modes == nullptr ||
+            mModule->get_voter_list == nullptr ||
+            mModule->get_platform_low_power_stats == nullptr)
+    {
+        _hidl_cb(states, Status::SUCCESS);
+        return Void();
+    }
+
+    number_platform_modes = mModule->get_number_of_platform_modes(mModule);
+    if (number_platform_modes)
+    {
+       if ((ssize_t) (SIZE_MAX / sizeof(size_t)) <= number_platform_modes)  // overflow
+           goto done;
+       voters = new (std::nothrow) size_t [number_platform_modes];
+       if (voters == nullptr)
+           goto done;
+
+       ret = mModule->get_voter_list(mModule, voters);
+       if (ret != 0)
+           goto done;
+
+       if ((ssize_t) (SIZE_MAX / sizeof(power_state_platform_sleep_state_t))
+           <= number_platform_modes)  // overflow
+           goto done;
+       legacy_states = new (std::nothrow)
+           power_state_platform_sleep_state_t [number_platform_modes];
+       if (legacy_states == nullptr)
+           goto done;
+
+       for (int i = 0; i < number_platform_modes; i++)
+       {
+          legacy_states[i].voters = nullptr;
+          legacy_states[i].voters = new power_state_voter_t [voters[i]];
+          if (legacy_states[i].voters == nullptr)
+              goto done;
+       }
+
+       ret = mModule->get_platform_low_power_stats(mModule, legacy_states);
+       if (ret != 0)
+           goto done;
+
+       states.resize(number_platform_modes);
+       for (int i = 0; i < number_platform_modes; i++)
+       {
+          power_state_platform_sleep_state_t& legacy_state = legacy_states[i];
+          PowerStatePlatformSleepState& state = states[i];
+          state.name = legacy_state.name;
+          state.residencyInMsecSinceBoot = legacy_state.residency_in_msec_since_boot;
+          state.totalTransitions = legacy_state.total_transitions;
+          state.supportedOnlyInSuspend = legacy_state.supported_only_in_suspend;
+          state.voters.resize(voters[i]);
+          for(size_t j = 0; j < voters[i]; j++)
+          {
+              state.voters[j].name = legacy_state.voters[j].name;
+              state.voters[j].totalTimeInMsecVotedForSinceBoot = legacy_state.voters[j].total_time_in_msec_voted_for_since_boot;
+              state.voters[j].totalNumberOfTimesVotedSinceBoot = legacy_state.voters[j].total_number_of_times_voted_since_boot;
+          }
+       }
+    }
+done:
+    if (legacy_states)
+    {
+        for (int i = 0; i < number_platform_modes; i++)
+        {
+            if(legacy_states[i].voters)
+                delete(legacy_states[i].voters);
+        }
+    }
+    delete[] legacy_states;
+    delete[] voters;
+    _hidl_cb(states, Status::SUCCESS);
+    return Void();
+}
+
+// Methods from ::android::hardware::power::V1_1::IPower follow.
+Return<void> Power::getSubsystemLowPowerStats(getSubsystemLowPowerStats_cb _hidl_cb) {
+    hidl_vec<PowerStateSubsystem> subsystems;
+    ssize_t number_subsystems = 0;
+
+    //This API will report zero subsystems to support older devices
+    //For devices that support this API, they will have their own implementation
+    subsystems.resize(number_subsystems);
+    _hidl_cb(subsystems, Status::SUCCESS);
+    return Void();
+}
+
+} // namespace implementation
+}  // namespace V1_1
+}  // namespace power
+}  // namespace hardware
+}  // namespace android
diff --git a/power/1.1/default/Power.h b/power/1.1/default/Power.h
new file mode 100644
index 0000000..ea9e8c3
--- /dev/null
+++ b/power/1.1/default/Power.h
@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+#ifndef ANDROID_HARDWARE_POWER_V1_1_POWER_H
+#define ANDROID_HARDWARE_POWER_V1_1_POWER_H
+
+#include <android/hardware/power/1.1/IPower.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+#include <hardware/power.h>
+
+namespace android {
+namespace hardware {
+namespace power {
+namespace V1_1 {
+namespace implementation {
+
+using ::android::hardware::power::V1_0::Feature;
+using ::android::hardware::power::V1_0::PowerHint;
+using ::android::hardware::power::V1_1::IPower;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+
+struct Power : public IPower {
+    Power(power_module_t* module);
+    ~Power();
+
+    // Methods from ::android::hardware::power::V1_0::IPower follow
+    Return<void> setInteractive(bool interactive) override;
+    Return<void> powerHint(PowerHint hint, int32_t data) override;
+    Return<void> setFeature(Feature feature, bool activate) override;
+    Return<void> getPlatformLowPowerStats(getPlatformLowPowerStats_cb _hidl_cb) override;
+
+    // Methods from ::android::hardware::power::V1_1::IPower follow.
+    Return<void> getSubsystemLowPowerStats(getSubsystemLowPowerStats_cb _hidl_cb) override;
+
+    // Methods from ::android::hidl::base::V1_0::IBase follow.
+
+  private:
+    power_module_t* mModule;
+};
+
+}  // namespace implementation
+}  // namespace V1_1
+}  // namespace power
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_POWER_V1_1_POWER_H
diff --git a/power/1.1/default/android.hardware.power@1.1-service.rc b/power/1.1/default/android.hardware.power@1.1-service.rc
new file mode 100644
index 0000000..f2512f1
--- /dev/null
+++ b/power/1.1/default/android.hardware.power@1.1-service.rc
@@ -0,0 +1,4 @@
+service power-hal-1-1 /vendor/bin/hw/android.hardware.power@1.1-service
+    class hal
+    user system
+    group system
diff --git a/power/1.1/default/service.cpp b/power/1.1/default/service.cpp
new file mode 100644
index 0000000..571db2f
--- /dev/null
+++ b/power/1.1/default/service.cpp
@@ -0,0 +1,89 @@
+/*
+ * 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.
+ */
+
+#define LOG_TAG "android.hardware.power@1.1-service"
+
+#include <android/log.h>
+#include <hidl/HidlTransportSupport.h>
+#include <android/hardware/power/1.1/IPower.h>
+#include <hardware/power.h>
+#include "Power.h"
+
+using android::sp;
+using android::status_t;
+using android::OK;
+
+// libhwbinder:
+using android::hardware::configureRpcThreadpool;
+using android::hardware::joinRpcThreadpool;
+
+// Generated HIDL files
+using android::hardware::power::V1_1::IPower;
+using android::hardware::power::V1_1::implementation::Power;
+
+int main() {
+
+    status_t status;
+    android::sp<IPower> service = nullptr;
+    const hw_module_t* hw_module = nullptr;
+    power_module_t* power_module = nullptr;
+    int err;
+
+    ALOGI("Power HAL Service 1.1 (Default) is starting.");
+
+    err = hw_get_module(POWER_HARDWARE_MODULE_ID, &hw_module);
+    if (err) {
+        ALOGE("hw_get_module %s failed: %d", POWER_HARDWARE_MODULE_ID, err);
+        goto shutdown;
+    }
+
+    if (!hw_module->methods || !hw_module->methods->open) {
+        power_module = reinterpret_cast<power_module_t*>(
+            const_cast<hw_module_t*>(hw_module));
+    } else {
+        err = hw_module->methods->open(hw_module, POWER_HARDWARE_MODULE_ID,
+                                           reinterpret_cast<hw_device_t**>(&power_module));
+        if (err) {
+            ALOGE("Passthrough failed to load legacy HAL.");
+            goto shutdown;
+        }
+    }
+
+    service = new Power(power_module);
+    if (service == nullptr) {
+        ALOGE("Can not create an instance of Power HAL Iface, exiting.");
+
+        goto shutdown;
+    }
+
+    configureRpcThreadpool(1, true /*callerWillJoin*/);
+
+    status = service->registerAsService();
+    if (status != OK) {
+        ALOGE("Could not register service for Power HAL Iface (%d).", status);
+        goto shutdown;
+    }
+
+    ALOGI("Power Service is ready");
+    joinRpcThreadpool();
+    //Should not pass this line
+
+shutdown:
+    // In normal operation, we don't expect the thread pool to exit
+
+    ALOGE("Power Service is shutting down");
+    return 1;
+}
diff --git a/power/1.1/types.hal b/power/1.1/types.hal
new file mode 100644
index 0000000..5298d4e
--- /dev/null
+++ b/power/1.1/types.hal
@@ -0,0 +1,75 @@
+/*
+ * 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.power@1.1;
+
+/**
+ * Subsytem-level sleep state stats:
+ * PowerStateSubsystemSleepState represents the sleep states
+ * a subsystem (e.g. wifi, bt) is capable of getting into.
+ *
+ * SoCs like wifi, bt usually have more than one subsystem level sleep state.
+ */
+struct PowerStateSubsystemSleepState {
+    /**
+     * Subsystem-level Sleep state name.
+     */
+    string name;
+
+    /**
+     * Time spent in msec at this subsystem-level sleep state since boot.
+     */
+    uint64_t residencyInMsecSinceBoot;
+
+    /**
+     * Total number of times sub-system entered this state.
+     */
+    uint64_t totalTransitions;
+
+    /**
+     * Timestamp of last entry of this state measured in MSec
+     */
+    uint64_t lastEntryTimestampMs;
+
+    /**
+     * This subsystem-level sleep state can only be reached during system suspend
+     */
+    bool supportedOnlyInSuspend;
+};
+
+/**
+ * Subsytem-level sleep state stats:
+ * PowerStateSubsystem represents a subsystem (e.g. wifi, bt)
+ * and all the sleep states this susbsystem is capable of getting into.
+ *
+ * SoCs like wifi, bt usually have more than one subsystem level sleep state.
+ */
+struct PowerStateSubsystem {
+    /**
+     * Subsystem name (e.g. wifi, bt etc.)
+     */
+    string name;
+
+    /**
+     * states represents the list of sleep states supported by this susbsystem.
+     * Higher the index in the returned <states> vector deeper the state is
+     * i.e. lesser steady-state power is consumed by the subsystem to
+     * to be resident in that state.
+     *
+     * Vector of size zero implies either the info is not available
+     * or the subsystem does not have any sleep states.
+     */
+    vec<PowerStateSubsystemSleepState> states;
+};
diff --git a/power/1.1/vts/functional/Android.bp b/power/1.1/vts/functional/Android.bp
new file mode 100644
index 0000000..f886bd2
--- /dev/null
+++ b/power/1.1/vts/functional/Android.bp
@@ -0,0 +1,34 @@
+//
+// 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.
+//
+
+cc_test {
+    name: "VtsHalPowerV1_1TargetTest",
+    defaults: ["hidl_defaults"],
+    srcs: ["VtsHalPowerV1_1TargetTest.cpp"],
+    shared_libs: [
+        "libbase",
+        "liblog",
+        "libhidlbase",
+        "libhidltransport",
+        "libutils",
+        "android.hardware.power@1.1",
+    ],
+    static_libs: ["VtsHalHidlTargetTestBase"],
+    cflags: [
+        "-O0",
+        "-g",
+    ]
+}
diff --git a/power/1.1/vts/functional/VtsHalPowerV1_1TargetTest.cpp b/power/1.1/vts/functional/VtsHalPowerV1_1TargetTest.cpp
new file mode 100644
index 0000000..1d0d50f
--- /dev/null
+++ b/power/1.1/vts/functional/VtsHalPowerV1_1TargetTest.cpp
@@ -0,0 +1,62 @@
+/*
+ * 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 "power_hidl_hal_test"
+#include <android-base/logging.h>
+#include <android/hardware/power/1.1/IPower.h>
+
+#include <VtsHalHidlTargetTestBase.h>
+
+using ::android::hardware::power::V1_1::IPower;
+using ::android::hardware::power::V1_1::PowerStateSubsystem;
+using ::android::hardware::power::V1_0::Status;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::sp;
+
+class PowerHidlTest : public ::testing::VtsHalHidlTargetTestBase {
+ public:
+  virtual void SetUp() override {
+    power = ::testing::VtsHalHidlTargetTestBase::getService<IPower>();
+    ASSERT_NE(power, nullptr);
+  }
+
+  virtual void TearDown() override {}
+
+  sp<IPower> power;
+};
+
+// Sanity check Power::getSubsystemLowPowerStats().
+TEST_F(PowerHidlTest, GetSubsystemLowPowerStats) {
+  hidl_vec<PowerStateSubsystem> vec;
+  Status s;
+  auto cb = [&vec, &s](hidl_vec<PowerStateSubsystem> subsystems,
+                       Status status) {
+    vec = subsystems;
+    s = status;
+  };
+
+  Return<void> ret = power->getSubsystemLowPowerStats(cb);
+  ASSERT_TRUE(ret.isOk());
+  ASSERT_TRUE(s == Status::SUCCESS || s == Status::FILESYSTEM_ERROR);
+}
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  int status = RUN_ALL_TESTS();
+  LOG(INFO) << "Test result = " << status;
+  return status;
+}
diff --git a/power/Android.bp b/power/Android.bp
index ed19a37..8cb3ea3 100644
--- a/power/Android.bp
+++ b/power/Android.bp
@@ -2,5 +2,7 @@
 subdirs = [
     "1.0",
     "1.0/default",
-    "1.0/vts/functional",
+    "1.1",
+    "1.1/default",
+    "1.1/vts/functional",
 ]
diff --git a/radio/1.0/Android.bp b/radio/1.0/Android.bp
index e89a743..b58d85a 100644
--- a/radio/1.0/Android.bp
+++ b/radio/1.0/Android.bp
@@ -15,7 +15,7 @@
 genrule {
     name: "android.hardware.radio@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio@1.0",
     srcs: [
         ":android.hardware.radio@1.0_hal",
     ],
@@ -32,7 +32,7 @@
 genrule {
     name: "android.hardware.radio@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio@1.0",
     srcs: [
         ":android.hardware.radio@1.0_hal",
     ],
diff --git a/radio/1.0/IRadioResponse.hal b/radio/1.0/IRadioResponse.hal
index 23c4d41..437e191 100644
--- a/radio/1.0/IRadioResponse.hal
+++ b/radio/1.0/IRadioResponse.hal
@@ -328,6 +328,12 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:NOT_PROVISIONED
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getSignalStrengthResponse(RadioResponseInfo info, SignalStrength sigStrength);
 
@@ -351,6 +357,12 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:NOT_PROVISIONED
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getDataRegistrationStateResponse(RadioResponseInfo info,
             DataRegStateResult dataRegResponse);
@@ -364,6 +376,10 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getOperatorResponse(RadioResponseInfo info, string longName, string shortName,
             string numeric);
@@ -375,6 +391,16 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:OPERATION_NOT_ALLOWED
+     *   RadioError:INVALID_STATE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:DEVICE_IN_USE
+     *   RadioError:OPERATION_NOT_ALLOWED
+     *   RadioError:INVALID_MODEM_STATE
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway setRadioPowerResponse(RadioResponseInfo info);
 
@@ -464,6 +490,8 @@
      *   RadioError:OP_NOT_ALLOWED_BEFORE_REG_TO_NW
      *   RadioError:OP_NOT_ALLOWED_DURING_VOICE_CALL
      *   RadioError:REQUEST_NOT_SUPPORTED
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway setupDataCallResponse(RadioResponseInfo info, SetupDataCallResult dcResponse);
 
@@ -692,6 +720,10 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:INVALID_CALL_ID
+     *   RadioError:INVALID_STATE
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway deactivateDataCallResponse(RadioResponseInfo info);
 
@@ -765,6 +797,12 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getNetworkSelectionModeResponse(RadioResponseInfo info, bool manual);
 
@@ -776,6 +814,12 @@
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:ILLEGAL_SIM_OR_ME
      *   RadioError:OPERATION_NOT_ALLOWED
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      *
      * Returns RadioError:ILLEGAL_SIM_OR_ME when the failure is permanent and
      * no retries needed, such as illegal SIM or ME.
@@ -790,6 +834,13 @@
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:ILLEGAL_SIM_OR_ME
      *   RadioError:OPERATION_NOT_ALLOWED
+     *   RadioError:INVALID_STATE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      *
      * Returns RadioError:ILLEGAL_SIM_OR_ME when the failure is permanent and
      * no retries needed, such as illegal SIM or ME.
@@ -810,6 +861,8 @@
      *   RadioError:INTERNAL_ERR
      *   RadioError:NO_MEMORY
      *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
+     *   RadioError:CANCELLED
      */
     oneway getAvailableNetworksResponse(RadioResponseInfo info,
             vec<OperatorInfo> networkInfos);
@@ -858,6 +911,12 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:EMPTY_RECORD
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:NOT_PROVISIONED
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getBasebandVersionResponse(RadioResponseInfo info, string version);
 
@@ -1006,6 +1065,12 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:OPERATION_NOT_ALLOWED
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway setBandModeResponse(RadioResponseInfo info);
 
@@ -1017,6 +1082,11 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getAvailableBandModesResponse(RadioResponseInfo info, vec<RadioBandMode> bandModes);
 
@@ -1083,6 +1153,12 @@
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:OPERATION_NOT_ALLOWED
      *   RadioError:MODE_NOT_SUPPORTED
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway setPreferredNetworkTypeResponse(RadioResponseInfo info);
 
@@ -1093,6 +1169,12 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getPreferredNetworkTypeResponse(RadioResponseInfo info,
             PreferredNetworkType nwType);
@@ -1105,6 +1187,12 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:NO_NETWORK_FOUND
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getNeighboringCidsResponse(RadioResponseInfo info, vec<NeighboringCell> cells);
 
@@ -1114,6 +1202,12 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway setLocationUpdatesResponse(RadioResponseInfo info);
 
@@ -1134,6 +1228,13 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
+     *   RadioError:OPERATION_NOT_ALLOWED
      */
     oneway setCdmaRoamingPreferenceResponse(RadioResponseInfo info);
 
@@ -1145,6 +1246,11 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getCdmaRoamingPreferenceResponse(RadioResponseInfo info, CdmaRoamingType type);
 
@@ -1424,6 +1530,13 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:SUBSCRIPTION_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:NOT_PROVISIONED
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getCDMASubscriptionResponse(RadioResponseInfo info, string mdn, string hSid,
             string hNid, string min, string prl);
@@ -1480,6 +1593,12 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:NOT_PROVISIONED
      *
      * If a empty string value is returned for any of the device id, it means that there was error
      * accessing the device.
@@ -1495,6 +1614,12 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:OPERATION_NO_ALLOWED
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:NO_MEMORY
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway exitEmergencyCallbackModeResponse(RadioResponseInfo info);
 
@@ -1622,6 +1747,12 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:NO_NETWORK_FOUND
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getCellInfoListResponse(RadioResponseInfo info, vec<CellInfo> cellInfo);
 
@@ -1631,6 +1762,10 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
      */
     oneway setCellInfoListRateResponse(RadioResponseInfo info);
 
@@ -1641,6 +1776,13 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:SUBSCRIPTION_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:NOT_PROVISIONED
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway setInitialAttachApnResponse(RadioResponseInfo info);
 
@@ -1771,6 +1913,12 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:SUBSCRIPTION_NOT_SUPPORTED
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway setUiccSubscriptionResponse(RadioResponseInfo info);
 
@@ -1780,6 +1928,13 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:DEVICE_IN_USE
+     *   RadioError:INVALID_MODEM_STATE
      */
     oneway setDataAllowedResponse(RadioResponseInfo info);
 
@@ -1820,6 +1975,10 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:OPERATION_NOT_ALLOWED
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway requestShutdownResponse(RadioResponseInfo info);
 
@@ -1831,6 +1990,8 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:OPERATION_NOT_ALLOWED
+     *   RadioError:INVALID_STATE
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway getRadioCapabilityResponse(RadioResponseInfo info, RadioCapability rc);
 
@@ -1843,6 +2004,13 @@
      *   RadioError:NONE means a unsol radioCapability() will be sent within 30 seconds.
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:OPERATION_NOT_ALLOWED
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:MODEM_ERR
+     *   RadioError:INVALID_STATE
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway setRadioCapabilityResponse(RadioResponseInfo info, RadioCapability rc);
 
@@ -1854,6 +2022,8 @@
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
      *   RadioError:LCE_NOT_SUPPORTED
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway startLceServiceResponse(RadioResponseInfo info, LceStatusInfo statusInfo);
 
@@ -1886,6 +2056,11 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:MODEM_ERR
+     *   RadioError:NOT_PROVISIONED
      */
     oneway getModemActivityInfoResponse(RadioResponseInfo info, ActivityStatsInfo activityInfo);
 
@@ -1926,6 +2101,11 @@
      * Valid errors returned:
      *   RadioError:NONE
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:INVALID_ARGUMENTS
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway sendDeviceStateResponse(RadioResponseInfo info);
 
@@ -1936,6 +2116,10 @@
      *   RadioError:NONE
      *   RadioError:INVALID_ARGUMENTS
      *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:NO_MEMORY
+     *   RadioError:INTERNAL_ERR
+     *   RadioError:SYSTEM_ERR
+     *   RadioError:REQUEST_NOT_SUPPORTED
      */
     oneway setIndicationFilterResponse(RadioResponseInfo info);
 
diff --git a/radio/1.1/Android.bp b/radio/1.1/Android.bp
index 4987004..c352b6d 100644
--- a/radio/1.1/Android.bp
+++ b/radio/1.1/Android.bp
@@ -3,6 +3,7 @@
 filegroup {
     name: "android.hardware.radio@1.1_hal",
     srcs: [
+        "types.hal",
         "IRadio.hal",
         "IRadioIndication.hal",
         "IRadioResponse.hal",
@@ -12,11 +13,12 @@
 genrule {
     name: "android.hardware.radio@1.1_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio@1.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio@1.1",
     srcs: [
         ":android.hardware.radio@1.1_hal",
     ],
     out: [
+        "android/hardware/radio/1.1/types.cpp",
         "android/hardware/radio/1.1/RadioAll.cpp",
         "android/hardware/radio/1.1/RadioIndicationAll.cpp",
         "android/hardware/radio/1.1/RadioResponseAll.cpp",
@@ -26,11 +28,13 @@
 genrule {
     name: "android.hardware.radio@1.1_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio@1.1",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio@1.1",
     srcs: [
         ":android.hardware.radio@1.1_hal",
     ],
     out: [
+        "android/hardware/radio/1.1/types.h",
+        "android/hardware/radio/1.1/hwtypes.h",
         "android/hardware/radio/1.1/IRadio.h",
         "android/hardware/radio/1.1/IHwRadio.h",
         "android/hardware/radio/1.1/BnHwRadio.h",
diff --git a/radio/1.1/IRadio.hal b/radio/1.1/IRadio.hal
index c2bfa53..44b08fe 100644
--- a/radio/1.1/IRadio.hal
+++ b/radio/1.1/IRadio.hal
@@ -51,4 +51,34 @@
      */
      oneway setCarrierInfoForImsiEncryption(int32_t serial, vec<uint8_t> carrierKey,
              string keyIdentifier);
+
+    /**
+     * Set SIM card power state.
+     * Request is equivalent to inserting or removing the card.
+     *
+     * The radio modem must generate IRadioIndication.simStatusChanged() as if the SIM had been
+     * inserted or removed.
+     *
+     * @param serial Serial number of request
+     * @param powerUp POWER_DOWN if powering down the SIM card,
+     *                POWER_UP if powering up the SIM card,
+     *                POWER_UP_PASS_THROUGH if powering up the SIM card in pass through mode.
+     * When SIM card is in POWER_UP_PASS_THROUGH, the modem does not send any command to it
+     * (for example SELECT of MF, or TERMINAL CAPABILITY), and the SIM card is controlled
+     * completely by Telephony sending APDUs directly. The SIM card state must be
+     * RIL_CARDSTATE_PRESENT and the number of card apps will be 0.
+     * No new error code is generated. Emergency calls are supported in the same way as if the
+     * SIM card is absent.
+     * POWER_UP_PASS_THROUGH mode is valid only for the specific card session where it is activated,
+     * and normal behavior occurs at the next SIM initialization, unless POWER_UP_PASS_THROUGH mode
+     * is requested again.
+     * The device is required to power down the SIM card before it can switch the mode between
+     * POWER_UP and POWER_UP_PASS_THROUGH.
+     * At device power up, the SIM interface is powered up automatically. Each subsequent request
+     * to this method is processed only after the completion of the previous one.
+     *
+     * Response callback is IRadioResponse.setSimCardPowerResponse_1_1()
+     */
+    oneway setSimCardPower_1_1(int32_t serial, CardPowerState powerUp);
+
 };
diff --git a/radio/1.1/IRadioResponse.hal b/radio/1.1/IRadioResponse.hal
index b0aece9..7727ef1 100644
--- a/radio/1.1/IRadioResponse.hal
+++ b/radio/1.1/IRadioResponse.hal
@@ -34,4 +34,16 @@
      *   RadioError:MODEM_INTERNAL_FAILURE
      */
     oneway setCarrierInfoForImsiEncryptionResponse(RadioResponseInfo info);
+
+    /**
+     * @param info Response info struct containing response type, serial no. and error
+     *
+     * Valid errors returned:
+     *   RadioError:NONE
+     *   RadioError:RADIO_NOT_AVAILABLE
+     *   RadioError:REQUEST_NOT_SUPPORTED
+     *   RadioError:INVALID_ARGUMENTS
+     */
+    oneway setSimCardPowerResponse_1_1(RadioResponseInfo info);
+
 };
diff --git a/radio/1.1/types.hal b/radio/1.1/types.hal
new file mode 100644
index 0000000..266f64f
--- /dev/null
+++ b/radio/1.1/types.hal
@@ -0,0 +1,23 @@
+/*
+ * 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.radio@1.1;
+
+enum CardPowerState : int32_t {
+    POWER_DOWN,
+    POWER_UP,
+    POWER_UP_PASS_THROUGH,
+};
diff --git a/radio/deprecated/1.0/Android.bp b/radio/deprecated/1.0/Android.bp
index af93ec5..a812a74 100644
--- a/radio/deprecated/1.0/Android.bp
+++ b/radio/deprecated/1.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.radio.deprecated@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio.deprecated@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio.deprecated@1.0",
     srcs: [
         ":android.hardware.radio.deprecated@1.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.radio.deprecated@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio.deprecated@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.radio.deprecated@1.0",
     srcs: [
         ":android.hardware.radio.deprecated@1.0_hal",
     ],
diff --git a/renderscript/1.0/Android.bp b/renderscript/1.0/Android.bp
index b92b6f6..a033b41 100644
--- a/renderscript/1.0/Android.bp
+++ b/renderscript/1.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.renderscript@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0",
     srcs: [
         ":android.hardware.renderscript@1.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.renderscript@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.renderscript@1.0",
     srcs: [
         ":android.hardware.renderscript@1.0_hal",
     ],
diff --git a/renderscript/1.0/vts/functional/Android.bp b/renderscript/1.0/vts/functional/Android.bp
index 635e2e6..5256c1f 100644
--- a/renderscript/1.0/vts/functional/Android.bp
+++ b/renderscript/1.0/vts/functional/Android.bp
@@ -32,6 +32,7 @@
         "libhidltransport",
         "libnativehelper",
         "libutils",
+        "libnativewindow",
         "android.hardware.renderscript@1.0",
     ],
     static_libs: ["VtsHalHidlTargetTestBase"],
diff --git a/sensors/1.0/Android.bp b/sensors/1.0/Android.bp
index 4ab3ffb..256ed9b 100644
--- a/sensors/1.0/Android.bp
+++ b/sensors/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.sensors@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.sensors@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.sensors@1.0",
     srcs: [
         ":android.hardware.sensors@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.sensors@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.sensors@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.sensors@1.0",
     srcs: [
         ":android.hardware.sensors@1.0_hal",
     ],
diff --git a/sensors/1.0/default/android.hardware.sensors@1.0-service.rc b/sensors/1.0/default/android.hardware.sensors@1.0-service.rc
index c085552..059e5db 100644
--- a/sensors/1.0/default/android.hardware.sensors@1.0-service.rc
+++ b/sensors/1.0/default/android.hardware.sensors@1.0-service.rc
@@ -2,3 +2,4 @@
     class hal
     user system
     group system
+    capabilities SYS_NICE
diff --git a/soundtrigger/2.0/Android.bp b/soundtrigger/2.0/Android.bp
index 402339a..2ef3fcc 100644
--- a/soundtrigger/2.0/Android.bp
+++ b/soundtrigger/2.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.soundtrigger@2.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.soundtrigger@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.soundtrigger@2.0",
     srcs: [
         ":android.hardware.soundtrigger@2.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.soundtrigger@2.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.soundtrigger@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.soundtrigger@2.0",
     srcs: [
         ":android.hardware.soundtrigger@2.0_hal",
     ],
diff --git a/tests/bar/1.0/Android.bp b/tests/bar/1.0/Android.bp
index 8b2111f..e0dbe98 100644
--- a/tests/bar/1.0/Android.bp
+++ b/tests/bar/1.0/Android.bp
@@ -15,7 +15,7 @@
 genrule {
     name: "android.hardware.tests.bar@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.bar@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.bar@1.0",
     srcs: [
         ":android.hardware.tests.bar@1.0_hal",
     ],
@@ -32,7 +32,7 @@
 genrule {
     name: "android.hardware.tests.bar@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.bar@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.bar@1.0",
     srcs: [
         ":android.hardware.tests.bar@1.0_hal",
     ],
diff --git a/tests/baz/1.0/Android.bp b/tests/baz/1.0/Android.bp
index 22e1e4b..cc9e2a4 100644
--- a/tests/baz/1.0/Android.bp
+++ b/tests/baz/1.0/Android.bp
@@ -14,7 +14,7 @@
 genrule {
     name: "android.hardware.tests.baz@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.baz@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.baz@1.0",
     srcs: [
         ":android.hardware.tests.baz@1.0_hal",
     ],
@@ -30,7 +30,7 @@
 genrule {
     name: "android.hardware.tests.baz@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.baz@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.baz@1.0",
     srcs: [
         ":android.hardware.tests.baz@1.0_hal",
     ],
diff --git a/tests/expression/1.0/Android.bp b/tests/expression/1.0/Android.bp
index 9b938b1..8bdad0e 100644
--- a/tests/expression/1.0/Android.bp
+++ b/tests/expression/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.tests.expression@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.expression@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.expression@1.0",
     srcs: [
         ":android.hardware.tests.expression@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.tests.expression@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.expression@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.expression@1.0",
     srcs: [
         ":android.hardware.tests.expression@1.0_hal",
     ],
diff --git a/tests/extension/light/2.0/Android.bp b/tests/extension/light/2.0/Android.bp
index 19cbb58..deb9fb7 100644
--- a/tests/extension/light/2.0/Android.bp
+++ b/tests/extension/light/2.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.tests.extension.light@2.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.extension.light@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.extension.light@2.0",
     srcs: [
         ":android.hardware.tests.extension.light@2.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.tests.extension.light@2.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.extension.light@2.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.extension.light@2.0",
     srcs: [
         ":android.hardware.tests.extension.light@2.0_hal",
     ],
diff --git a/tests/foo/1.0/Android.bp b/tests/foo/1.0/Android.bp
index da2120f..54260e9 100644
--- a/tests/foo/1.0/Android.bp
+++ b/tests/foo/1.0/Android.bp
@@ -15,7 +15,7 @@
 genrule {
     name: "android.hardware.tests.foo@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.foo@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.foo@1.0",
     srcs: [
         ":android.hardware.tests.foo@1.0_hal",
     ],
@@ -32,7 +32,7 @@
 genrule {
     name: "android.hardware.tests.foo@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.foo@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.foo@1.0",
     srcs: [
         ":android.hardware.tests.foo@1.0_hal",
     ],
diff --git a/tests/hash/1.0/Android.bp b/tests/hash/1.0/Android.bp
index db72039..c2aa804 100644
--- a/tests/hash/1.0/Android.bp
+++ b/tests/hash/1.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.tests.hash@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.hash@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.hash@1.0",
     srcs: [
         ":android.hardware.tests.hash@1.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.tests.hash@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.hash@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.hash@1.0",
     srcs: [
         ":android.hardware.tests.hash@1.0_hal",
     ],
diff --git a/tests/inheritance/1.0/Android.bp b/tests/inheritance/1.0/Android.bp
index 8569c40..6b99a55 100644
--- a/tests/inheritance/1.0/Android.bp
+++ b/tests/inheritance/1.0/Android.bp
@@ -13,7 +13,7 @@
 genrule {
     name: "android.hardware.tests.inheritance@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.inheritance@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.inheritance@1.0",
     srcs: [
         ":android.hardware.tests.inheritance@1.0_hal",
     ],
@@ -28,7 +28,7 @@
 genrule {
     name: "android.hardware.tests.inheritance@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.inheritance@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.inheritance@1.0",
     srcs: [
         ":android.hardware.tests.inheritance@1.0_hal",
     ],
diff --git a/tests/libhwbinder/1.0/Android.bp b/tests/libhwbinder/1.0/Android.bp
index 62e0050..cfebfbb 100644
--- a/tests/libhwbinder/1.0/Android.bp
+++ b/tests/libhwbinder/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.tests.libhwbinder@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.libhwbinder@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.libhwbinder@1.0",
     srcs: [
         ":android.hardware.tests.libhwbinder@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.tests.libhwbinder@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.libhwbinder@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.libhwbinder@1.0",
     srcs: [
         ":android.hardware.tests.libhwbinder@1.0_hal",
     ],
diff --git a/tests/libhwbinder/1.0/default/ScheduleTest.h b/tests/libhwbinder/1.0/default/ScheduleTest.h
index ad6dd9d..b1ed660 100644
--- a/tests/libhwbinder/1.0/default/ScheduleTest.h
+++ b/tests/libhwbinder/1.0/default/ScheduleTest.h
@@ -31,6 +31,8 @@
     // Methods from ::android::hidl::base::V1_0::IBase follow.
 };
 
+extern "C" IScheduleTest* HIDL_FETCH_IScheduleTest(const char* name);
+
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace libhwbinder
diff --git a/tests/memory/1.0/Android.bp b/tests/memory/1.0/Android.bp
index 4d8febf..ed64f5d 100644
--- a/tests/memory/1.0/Android.bp
+++ b/tests/memory/1.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.tests.memory@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.memory@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.memory@1.0",
     srcs: [
         ":android.hardware.tests.memory@1.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.tests.memory@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.memory@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.memory@1.0",
     srcs: [
         ":android.hardware.tests.memory@1.0_hal",
     ],
diff --git a/tests/msgq/1.0/Android.bp b/tests/msgq/1.0/Android.bp
index e5d3a82..04a64f6 100644
--- a/tests/msgq/1.0/Android.bp
+++ b/tests/msgq/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.tests.msgq@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.msgq@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.msgq@1.0",
     srcs: [
         ":android.hardware.tests.msgq@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.tests.msgq@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.msgq@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.msgq@1.0",
     srcs: [
         ":android.hardware.tests.msgq@1.0_hal",
     ],
diff --git a/tests/pointer/1.0/Android.bp b/tests/pointer/1.0/Android.bp
index d1eafb0..ae0d0c8 100644
--- a/tests/pointer/1.0/Android.bp
+++ b/tests/pointer/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.tests.pointer@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.pointer@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.pointer@1.0",
     srcs: [
         ":android.hardware.tests.pointer@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.tests.pointer@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.pointer@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.pointer@1.0",
     srcs: [
         ":android.hardware.tests.pointer@1.0_hal",
     ],
diff --git a/tests/versioning/1.0/Android.bp b/tests/versioning/1.0/Android.bp
index 13c1327..c3e4b57 100644
--- a/tests/versioning/1.0/Android.bp
+++ b/tests/versioning/1.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.tests.versioning@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@1.0",
     srcs: [
         ":android.hardware.tests.versioning@1.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.tests.versioning@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@1.0",
     srcs: [
         ":android.hardware.tests.versioning@1.0_hal",
     ],
diff --git a/tests/versioning/2.2/Android.bp b/tests/versioning/2.2/Android.bp
index 910f7b4..624a61e 100644
--- a/tests/versioning/2.2/Android.bp
+++ b/tests/versioning/2.2/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.tests.versioning@2.2_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.2",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.2",
     srcs: [
         ":android.hardware.tests.versioning@2.2_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.tests.versioning@2.2_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.2",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.2",
     srcs: [
         ":android.hardware.tests.versioning@2.2_hal",
     ],
diff --git a/tests/versioning/2.3/Android.bp b/tests/versioning/2.3/Android.bp
index 6359eba..247b2ff 100644
--- a/tests/versioning/2.3/Android.bp
+++ b/tests/versioning/2.3/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.tests.versioning@2.3_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.3",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.3",
     srcs: [
         ":android.hardware.tests.versioning@2.3_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.tests.versioning@2.3_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.3",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.3",
     srcs: [
         ":android.hardware.tests.versioning@2.3_hal",
     ],
diff --git a/tests/versioning/2.4/Android.bp b/tests/versioning/2.4/Android.bp
index 67cc318..ff9ca1f 100644
--- a/tests/versioning/2.4/Android.bp
+++ b/tests/versioning/2.4/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.tests.versioning@2.4_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.4",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.4",
     srcs: [
         ":android.hardware.tests.versioning@2.4_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.tests.versioning@2.4_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.4",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.versioning@2.4",
     srcs: [
         ":android.hardware.tests.versioning@2.4_hal",
     ],
diff --git a/tetheroffload/config/1.0/Android.bp b/tetheroffload/config/1.0/Android.bp
index 09fc574..ddf7c22 100644
--- a/tetheroffload/config/1.0/Android.bp
+++ b/tetheroffload/config/1.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.tetheroffload.config@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tetheroffload.config@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tetheroffload.config@1.0",
     srcs: [
         ":android.hardware.tetheroffload.config@1.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.tetheroffload.config@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tetheroffload.config@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tetheroffload.config@1.0",
     srcs: [
         ":android.hardware.tetheroffload.config@1.0_hal",
     ],
diff --git a/tetheroffload/control/1.0/Android.bp b/tetheroffload/control/1.0/Android.bp
index 9361e8b..6f50446 100644
--- a/tetheroffload/control/1.0/Android.bp
+++ b/tetheroffload/control/1.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.tetheroffload.control@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tetheroffload.control@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tetheroffload.control@1.0",
     srcs: [
         ":android.hardware.tetheroffload.control@1.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.tetheroffload.control@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tetheroffload.control@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tetheroffload.control@1.0",
     srcs: [
         ":android.hardware.tetheroffload.control@1.0_hal",
     ],
diff --git a/thermal/1.0/Android.bp b/thermal/1.0/Android.bp
index ceabfbd..bbede02 100644
--- a/thermal/1.0/Android.bp
+++ b/thermal/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.thermal@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.thermal@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.thermal@1.0",
     srcs: [
         ":android.hardware.thermal@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.thermal@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.thermal@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.thermal@1.0",
     srcs: [
         ":android.hardware.thermal@1.0_hal",
     ],
diff --git a/tv/cec/1.0/Android.bp b/tv/cec/1.0/Android.bp
index 3be3904..6aca979 100644
--- a/tv/cec/1.0/Android.bp
+++ b/tv/cec/1.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.tv.cec@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.cec@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.cec@1.0",
     srcs: [
         ":android.hardware.tv.cec@1.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.tv.cec@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.cec@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.cec@1.0",
     srcs: [
         ":android.hardware.tv.cec@1.0_hal",
     ],
diff --git a/tv/input/1.0/Android.bp b/tv/input/1.0/Android.bp
index 13b9c2a..a0d7109 100644
--- a/tv/input/1.0/Android.bp
+++ b/tv/input/1.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.tv.input@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.input@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.input@1.0",
     srcs: [
         ":android.hardware.tv.input@1.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.tv.input@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.input@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.input@1.0",
     srcs: [
         ":android.hardware.tv.input@1.0_hal",
     ],
diff --git a/usb/1.0/Android.bp b/usb/1.0/Android.bp
index c4b0d4d..4c5c8e3 100644
--- a/usb/1.0/Android.bp
+++ b/usb/1.0/Android.bp
@@ -12,7 +12,7 @@
 genrule {
     name: "android.hardware.usb@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.usb@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.usb@1.0",
     srcs: [
         ":android.hardware.usb@1.0_hal",
     ],
@@ -26,7 +26,7 @@
 genrule {
     name: "android.hardware.usb@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.usb@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.usb@1.0",
     srcs: [
         ":android.hardware.usb@1.0_hal",
     ],
diff --git a/vibrator/1.0/Android.bp b/vibrator/1.0/Android.bp
index 092719f..32be077 100644
--- a/vibrator/1.0/Android.bp
+++ b/vibrator/1.0/Android.bp
@@ -11,7 +11,7 @@
 genrule {
     name: "android.hardware.vibrator@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.vibrator@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.vibrator@1.0",
     srcs: [
         ":android.hardware.vibrator@1.0_hal",
     ],
@@ -24,7 +24,7 @@
 genrule {
     name: "android.hardware.vibrator@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.vibrator@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.vibrator@1.0",
     srcs: [
         ":android.hardware.vibrator@1.0_hal",
     ],
diff --git a/vr/1.0/Android.bp b/vr/1.0/Android.bp
index 8344aae..f0aef5c 100644
--- a/vr/1.0/Android.bp
+++ b/vr/1.0/Android.bp
@@ -10,7 +10,7 @@
 genrule {
     name: "android.hardware.vr@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.vr@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.vr@1.0",
     srcs: [
         ":android.hardware.vr@1.0_hal",
     ],
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.vr@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.vr@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.vr@1.0",
     srcs: [
         ":android.hardware.vr@1.0_hal",
     ],
diff --git a/wifi/1.0/Android.bp b/wifi/1.0/Android.bp
index 256fad4..3a44608 100644
--- a/wifi/1.0/Android.bp
+++ b/wifi/1.0/Android.bp
@@ -23,7 +23,7 @@
 genrule {
     name: "android.hardware.wifi@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi@1.0",
     srcs: [
         ":android.hardware.wifi@1.0_hal",
     ],
@@ -48,7 +48,7 @@
 genrule {
     name: "android.hardware.wifi@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi@1.0",
     srcs: [
         ":android.hardware.wifi@1.0_hal",
     ],
diff --git a/wifi/supplicant/1.0/Android.bp b/wifi/supplicant/1.0/Android.bp
index bc57cf7..c692f9a 100644
--- a/wifi/supplicant/1.0/Android.bp
+++ b/wifi/supplicant/1.0/Android.bp
@@ -22,7 +22,7 @@
 genrule {
     name: "android.hardware.wifi.supplicant@1.0_genc++",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi.supplicant@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi.supplicant@1.0",
     srcs: [
         ":android.hardware.wifi.supplicant@1.0_hal",
     ],
@@ -46,7 +46,7 @@
 genrule {
     name: "android.hardware.wifi.supplicant@1.0_genc++_headers",
     tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi.supplicant@1.0",
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi.supplicant@1.0",
     srcs: [
         ":android.hardware.wifi.supplicant@1.0_hal",
     ],