diff --git a/audio/2.0/Android.bp b/audio/2.0/Android.bp
index 2ded34b..254c939 100644
--- a/audio/2.0/Android.bp
+++ b/audio/2.0/Android.bp
@@ -86,18 +86,18 @@
     generated_headers: ["android.hardware.audio@2.0_genc++_headers"],
     export_generated_headers: ["android.hardware.audio@2.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
         "android.hardware.audio.common@2.0",
-        "android.hardware.audio.effect@2.0",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "android.hardware.audio.common@2.0",
-        "android.hardware.audio.effect@2.0",
     ],
 }
diff --git a/audio/2.0/IDevice.hal b/audio/2.0/IDevice.hal
index 84e0d28..38bfe21 100644
--- a/audio/2.0/IDevice.hal
+++ b/audio/2.0/IDevice.hal
@@ -180,19 +180,20 @@
 
     /*
      * Gets the HW synchronization source of the device. Calling this method is
-     * equivalent to getting AUDIO_PARAMETER_STREAM_HW_AV_SYNC on the legacy
-     * HAL.
+     * equivalent to getting AUDIO_PARAMETER_HW_AV_SYNC on the legacy HAL.
      *
-     * @return retval operation completion status.
      * @return hwAvSync HW synchronization source
      */
-    getHwAvSync() generates (Result retval, AudioHwSync hwAvSync);
+    getHwAvSync() generates (AudioHwSync hwAvSync);
 
     /*
      * Sets whether the screen is on. Calling this method is equivalent to
      * setting AUDIO_PARAMETER_KEY_SCREEN_STATE on the legacy HAL.
+     *
+     * @param turnedOn whether the screen is turned on.
+     * @return retval operation completion status.
      */
-    setScreenState(bool turnedOn);
+    setScreenState(bool turnedOn) generates (Result retval);
 
     /*
      * Generic method for retrieving vendor-specific parameter values.
diff --git a/audio/2.0/IStream.hal b/audio/2.0/IStream.hal
index 09ba42a..dc43346 100644
--- a/audio/2.0/IStream.hal
+++ b/audio/2.0/IStream.hal
@@ -134,18 +134,20 @@
     /*
      * Applies audio effect to the stream.
      *
-     * @param effect the effect to apply.
+     * @param effectId effect ID (obtained from IEffectsFactory.createEffect) of
+     *                 the effect to apply.
      * @return retval operation completion status.
      */
-    addEffect(IEffect effect) generates (Result retval);
+    addEffect(uint64_t effectId) generates (Result retval);
 
     /*
      * Stops application of the effect to the stream.
      *
-     * @param effect the effect to apply.
+     * @param effectId effect ID (obtained from IEffectsFactory.createEffect) of
+     *                 the effect to remove.
      * @return retval operation completion status.
      */
-    removeEffect(IEffect effect) generates (Result retval);
+    removeEffect(uint64_t effectId) generates (Result retval);
 
     /*
      * Put the audio hardware input/output into standby mode.
@@ -158,10 +160,9 @@
     /*
      * Return the set of device(s) which this stream is connected to.
      *
-     * @return retval operation completion status.
      * @return device set of device(s) which this stream is connected to.
      */
-    getDevice() generates (Result retval, AudioDevice device);
+    getDevice() generates (AudioDevice device);
 
     /*
      * Connects the stream to the device.
diff --git a/audio/2.0/IStreamIn.hal b/audio/2.0/IStreamIn.hal
index 049df75..6cf7425 100644
--- a/audio/2.0/IStreamIn.hal
+++ b/audio/2.0/IStreamIn.hal
@@ -61,10 +61,9 @@
      * typically occurs when the user space process is blocked longer than the
      * capacity of audio driver buffers.
      *
-     * @return retval operation completion status.
      * @return framesLost the number of input audio frames lost.
      */
-    getInputFramesLost() generates (Result retval, uint32_t framesLost);
+    getInputFramesLost() generates (uint32_t framesLost);
 
     /**
      * Return a recent count of the number of audio frames received and the
diff --git a/audio/2.0/IStreamOut.hal b/audio/2.0/IStreamOut.hal
index adce538..55a852d 100644
--- a/audio/2.0/IStreamOut.hal
+++ b/audio/2.0/IStreamOut.hal
@@ -142,12 +142,12 @@
      * 'setCallback' has not been called, then 'drain' must block until
      * completion.
      *
-     * If 'type' is 'AUDIO_DRAIN_ALL', the drain completes when all previously
-     * written data has been played.
+     * If 'type' is 'ALL', the drain completes when all previously written data
+     * has been played.
      *
-     * If 'type' is 'AUDIO_DRAIN_EARLY_NOTIFY', the drain completes shortly
-     * before all data for the current track has played to allow time for the
-     * framework to perform a gapless track switch.
+     * If 'type' is 'EARLY_NOTIFY', the drain completes shortly before all data
+     * for the current track has played to allow time for the framework to
+     * perform a gapless track switch.
      *
      * Drain must return immediately on 'stop' and 'flush' calls.
      *
diff --git a/audio/2.0/default/Android.mk b/audio/2.0/default/Android.mk
index a987b41..5108448 100644
--- a/audio/2.0/default/Android.mk
+++ b/audio/2.0/default/Android.mk
@@ -17,20 +17,55 @@
 LOCAL_PATH := $(call my-dir)
 
 include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.audio@2.0-impl
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_SRC_FILES := \
+    Conversions.cpp \
+    Device.cpp \
+    DevicesFactory.cpp \
+    ParametersUtil.cpp \
+    PrimaryDevice.cpp \
+    Stream.cpp \
+    StreamIn.cpp \
+    StreamOut.cpp \
+
+LOCAL_SHARED_LIBRARIES := \
+    libhidlbase \
+    libhidltransport \
+    libhwbinder \
+    libutils \
+    libhardware \
+    liblog \
+    android.hardware.audio@2.0 \
+    android.hardware.audio.common@2.0 \
+    android.hardware.audio.common@2.0-util \
+
+LOCAL_WHOLE_STATIC_LIBRARIES := libmedia_helper
+
+include $(BUILD_SHARED_LIBRARY)
+
+#
+# Service
+#
+
+include $(CLEAR_VARS)
 LOCAL_MODULE := android.hardware.audio@2.0-service
 LOCAL_INIT_RC := android.hardware.audio@2.0-service.rc
 LOCAL_MODULE_RELATIVE_PATH := hw
 LOCAL_SRC_FILES := \
-  service.cpp
+    service.cpp
 
 LOCAL_SHARED_LIBRARIES := \
-  libhidl \
-  liblog \
-  libhwbinder \
-  libutils \
-  libhardware \
-  android.hardware.soundtrigger@2.0 \
-  android.hardware.audio.common@2.0
+    libhidlbase \
+    libhidltransport \
+    liblog \
+    libhwbinder \
+    libutils \
+    libhardware \
+    android.hardware.audio@2.0 \
+    android.hardware.audio.common@2.0 \
+    android.hardware.audio.effect@2.0 \
+    android.hardware.soundtrigger@2.0 \
 
 ifeq ($(strip $(AUDIOSERVER_MULTILIB)),)
 LOCAL_MULTILIB := 32
diff --git a/audio/2.0/default/Conversions.cpp b/audio/2.0/default/Conversions.cpp
new file mode 100644
index 0000000..1ba16e1
--- /dev/null
+++ b/audio/2.0/default/Conversions.cpp
@@ -0,0 +1,63 @@
+/*
+ * 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.
+ */
+
+#include <stdio.h>
+
+#include "Conversions.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+std::string deviceAddressToHal(const DeviceAddress& address) {
+    // HAL assumes that the address is NUL-terminated.
+    char halAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN];
+    memset(halAddress, 0, sizeof(halAddress));
+    uint32_t halDevice = static_cast<uint32_t>(address.device);
+    if ((halDevice & AUDIO_DEVICE_OUT_ALL_A2DP) != 0
+            || (halDevice & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) != 0) {
+        snprintf(halAddress, sizeof(halAddress),
+                "%02X:%02X:%02X:%02X:%02X:%02X",
+                address.address.mac[0], address.address.mac[1], address.address.mac[2],
+                address.address.mac[3], address.address.mac[4], address.address.mac[5]);
+    } else if ((halDevice & AUDIO_DEVICE_OUT_IP) != 0 || (halDevice & AUDIO_DEVICE_IN_IP) != 0) {
+        snprintf(halAddress, sizeof(halAddress),
+                "%d.%d.%d.%d",
+                address.address.ipv4[0], address.address.ipv4[1],
+                address.address.ipv4[2], address.address.ipv4[3]);
+    } else if ((halDevice & AUDIO_DEVICE_OUT_ALL_USB) != 0
+            || (halDevice & AUDIO_DEVICE_IN_ALL_USB) != 0) {
+        snprintf(halAddress, sizeof(halAddress),
+                "card=%d;device=%d",
+                address.address.alsa.card, address.address.alsa.device);
+    } else if ((halDevice & AUDIO_DEVICE_OUT_BUS) != 0 || (halDevice & AUDIO_DEVICE_IN_BUS) != 0) {
+        snprintf(halAddress, sizeof(halAddress),
+                "%s", address.busAddress.c_str());
+    } else if ((halDevice & AUDIO_DEVICE_OUT_REMOTE_SUBMIX) != 0
+            || (halDevice & AUDIO_DEVICE_IN_REMOTE_SUBMIX) != 0) {
+        snprintf(halAddress, sizeof(halAddress),
+                "%s", address.rSubmixAddress.c_str());
+    }
+    return halAddress;
+}
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
diff --git a/audio/2.0/default/Conversions.h b/audio/2.0/default/Conversions.h
new file mode 100644
index 0000000..ebda5c5
--- /dev/null
+++ b/audio/2.0/default/Conversions.h
@@ -0,0 +1,41 @@
+/*
+ * 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_audio_V2_0_Conversions_H_
+#define android_hardware_audio_V2_0_Conversions_H_
+
+#include <string>
+
+#include <android/hardware/audio/2.0/types.h>
+#include <system/audio.h>
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+using ::android::hardware::audio::V2_0::DeviceAddress;
+
+std::string deviceAddressToHal(const DeviceAddress& address);
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // android_hardware_audio_V2_0_Conversions_H_
diff --git a/audio/2.0/default/Device.cpp b/audio/2.0/default/Device.cpp
new file mode 100644
index 0000000..05824c7
--- /dev/null
+++ b/audio/2.0/default/Device.cpp
@@ -0,0 +1,534 @@
+ /*
+ * 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"
+
+#include <algorithm>
+#include <memory.h>
+#include <string.h>
+
+#include <utils/Log.h>
+
+#include "Conversions.h"
+#include "Device.h"
+#include "StreamIn.h"
+#include "StreamOut.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+Device::Device(audio_hw_device_t* device)
+        : mDevice(device) {
+}
+
+Device::~Device() {
+    int status = audio_hw_device_close(mDevice);
+    ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice, strerror(-status));
+    mDevice = nullptr;
+}
+
+// static
+void Device::audioConfigToHal(const AudioConfig& config, audio_config_t* halConfig) {
+    memset(halConfig, 0, sizeof(audio_config_t));
+    halConfig->sample_rate = config.sampleRateHz;
+    halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask);
+    halConfig->format = static_cast<audio_format_t>(config.format);
+    audioOffloadInfoToHal(config.offloadInfo, &halConfig->offload_info);
+    halConfig->frame_count = config.frameCount;
+}
+
+// static
+void Device::audioGainConfigFromHal(
+        const struct audio_gain_config& halConfig, AudioGainConfig* config) {
+    config->index = halConfig.index;
+    config->mode = AudioGainMode(halConfig.mode);
+    config->channelMask = AudioChannelMask(halConfig.channel_mask);
+    for (size_t i = 0; i < sizeof(audio_channel_mask_t) * 8; ++i) {
+        config->values[i] = halConfig.values[i];
+    }
+    config->rampDurationMs = halConfig.ramp_duration_ms;
+}
+
+// static
+void Device::audioGainConfigToHal(
+        const AudioGainConfig& config, struct audio_gain_config* halConfig) {
+    halConfig->index = config.index;
+    halConfig->mode = static_cast<audio_gain_mode_t>(config.mode);
+    halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask);
+    memset(halConfig->values, 0, sizeof(halConfig->values));
+    for (size_t i = 0; i < sizeof(audio_channel_mask_t) * 8; ++i) {
+        halConfig->values[i] = config.values[i];
+    }
+    halConfig->ramp_duration_ms = config.rampDurationMs;
+}
+
+// static
+void Device::audioGainFromHal(const struct audio_gain& halGain, AudioGain* gain) {
+    gain->mode = AudioGainMode(halGain.mode);
+    gain->channelMask = AudioChannelMask(halGain.channel_mask);
+    gain->minValue = halGain.min_value;
+    gain->maxValue = halGain.max_value;
+    gain->defaultValue = halGain.default_value;
+    gain->stepValue = halGain.step_value;
+    gain->minRampMs = halGain.min_ramp_ms;
+    gain->maxRampMs = halGain.max_ramp_ms;
+}
+
+// static
+void Device::audioGainToHal(const AudioGain& gain, struct audio_gain* halGain) {
+    halGain->mode = static_cast<audio_gain_mode_t>(gain.mode);
+    halGain->channel_mask = static_cast<audio_channel_mask_t>(gain.channelMask);
+    halGain->min_value = gain.minValue;
+    halGain->max_value = gain.maxValue;
+    halGain->default_value = gain.defaultValue;
+    halGain->step_value = gain.stepValue;
+    halGain->min_ramp_ms = gain.minRampMs;
+    halGain->max_ramp_ms = gain.maxRampMs;
+}
+
+// static
+void Device::audioOffloadInfoToHal(
+        const AudioOffloadInfo& offload, audio_offload_info_t* halOffload) {
+    *halOffload = AUDIO_INFO_INITIALIZER;
+    halOffload->sample_rate = offload.sampleRateHz;
+    halOffload->channel_mask = static_cast<audio_channel_mask_t>(offload.channelMask);
+    halOffload->stream_type = static_cast<audio_stream_type_t>(offload.streamType);
+    halOffload->bit_rate = offload.bitRatePerSecond;
+    halOffload->duration_us = offload.durationMicroseconds;
+    halOffload->has_video = offload.hasVideo;
+    halOffload->is_streaming = offload.isStreaming;
+}
+
+// static
+void Device::audioPortConfigFromHal(
+        const struct audio_port_config& halConfig, AudioPortConfig* config) {
+    config->id = halConfig.id;
+    config->role = AudioPortRole(halConfig.role);
+    config->type = AudioPortType(halConfig.type);
+    config->configMask = AudioPortConfigMask(halConfig.config_mask);
+    config->sampleRateHz = halConfig.sample_rate;
+    config->channelMask = AudioChannelMask(halConfig.channel_mask);
+    config->format = AudioFormat(halConfig.format);
+    audioGainConfigFromHal(halConfig.gain, &config->gain);
+    switch (halConfig.type) {
+        case AUDIO_PORT_TYPE_NONE: break;
+        case AUDIO_PORT_TYPE_DEVICE: {
+            config->ext.device.hwModule = halConfig.ext.device.hw_module;
+            config->ext.device.type = AudioDevice(halConfig.ext.device.type);
+            memcpy(config->ext.device.address.data(),
+                    halConfig.ext.device.address,
+                    AUDIO_DEVICE_MAX_ADDRESS_LEN);
+            break;
+        }
+        case AUDIO_PORT_TYPE_MIX: {
+            config->ext.mix.hwModule = halConfig.ext.mix.hw_module;
+            config->ext.mix.ioHandle = halConfig.ext.mix.handle;
+            if (halConfig.role == AUDIO_PORT_ROLE_SOURCE) {
+                config->ext.mix.useCase.source = AudioSource(halConfig.ext.mix.usecase.source);
+            } else if (halConfig.role == AUDIO_PORT_ROLE_SINK) {
+                config->ext.mix.useCase.stream = AudioStreamType(halConfig.ext.mix.usecase.stream);
+            }
+            break;
+        }
+        case AUDIO_PORT_TYPE_SESSION: {
+            config->ext.session.session = halConfig.ext.session.session;
+            break;
+        }
+    }
+}
+
+// static
+void Device::audioPortConfigToHal(
+        const AudioPortConfig& config, struct audio_port_config* halConfig) {
+    memset(halConfig, 0, sizeof(audio_port_config));
+    halConfig->id = config.id;
+    halConfig->role = static_cast<audio_port_role_t>(config.role);
+    halConfig->type = static_cast<audio_port_type_t>(config.type);
+    halConfig->config_mask = static_cast<unsigned int>(config.configMask);
+    halConfig->sample_rate = config.sampleRateHz;
+    halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask);
+    halConfig->format = static_cast<audio_format_t>(config.format);
+    audioGainConfigToHal(config.gain, &halConfig->gain);
+    switch (config.type) {
+        case AudioPortType::NONE: break;
+        case AudioPortType::DEVICE: {
+            halConfig->ext.device.hw_module = config.ext.device.hwModule;
+            halConfig->ext.device.type = static_cast<audio_devices_t>(config.ext.device.type);
+            memcpy(halConfig->ext.device.address,
+                    config.ext.device.address.data(),
+                    AUDIO_DEVICE_MAX_ADDRESS_LEN);
+            break;
+        }
+        case AudioPortType::MIX: {
+            halConfig->ext.mix.hw_module = config.ext.mix.hwModule;
+            halConfig->ext.mix.handle = config.ext.mix.ioHandle;
+            if (config.role == AudioPortRole::SOURCE) {
+                halConfig->ext.mix.usecase.source =
+                        static_cast<audio_source_t>(config.ext.mix.useCase.source);
+            } else if (config.role == AudioPortRole::SINK) {
+                halConfig->ext.mix.usecase.stream =
+                        static_cast<audio_stream_type_t>(config.ext.mix.useCase.stream);
+            }
+            break;
+        }
+        case AudioPortType::SESSION: {
+            halConfig->ext.session.session =
+                    static_cast<audio_session_t>(config.ext.session.session);
+            break;
+        }
+    }
+}
+
+// static
+std::unique_ptr<audio_port_config[]> Device::audioPortConfigsToHal(
+        const hidl_vec<AudioPortConfig>& configs) {
+    std::unique_ptr<audio_port_config[]> halConfigs(new audio_port_config[configs.size()]);
+    for (size_t i = 0; i < configs.size(); ++i) {
+        audioPortConfigToHal(configs[i], &halConfigs[i]);
+    }
+    return halConfigs;
+}
+
+// static
+void Device::audioPortFromHal(const struct audio_port& halPort, AudioPort* port) {
+    port->id = halPort.id;
+    port->role = AudioPortRole(halPort.role);
+    port->type = AudioPortType(halPort.type);
+    port->name.setToExternal(halPort.name, strlen(halPort.name));
+    port->sampleRates.resize(halPort.num_sample_rates);
+    for (size_t i = 0; i < halPort.num_sample_rates; ++i) {
+        port->sampleRates[i] = halPort.sample_rates[i];
+    }
+    port->channelMasks.resize(halPort.num_channel_masks);
+    for (size_t i = 0; i < halPort.num_channel_masks; ++i) {
+        port->channelMasks[i] = AudioChannelMask(halPort.channel_masks[i]);
+    }
+    port->formats.resize(halPort.num_formats);
+    for (size_t i = 0; i < halPort.num_formats; ++i) {
+        port->formats[i] = AudioFormat(halPort.formats[i]);
+    }
+    port->gains.resize(halPort.num_gains);
+    for (size_t i = 0; i < halPort.num_gains; ++i) {
+        audioGainFromHal(halPort.gains[i], &port->gains[i]);
+    }
+    audioPortConfigFromHal(halPort.active_config, &port->activeConfig);
+    switch (halPort.type) {
+        case AUDIO_PORT_TYPE_NONE: break;
+        case AUDIO_PORT_TYPE_DEVICE: {
+            port->ext.device.hwModule = halPort.ext.device.hw_module;
+            port->ext.device.type = AudioDevice(halPort.ext.device.type);
+            memcpy(port->ext.device.address.data(),
+                    halPort.ext.device.address,
+                    AUDIO_DEVICE_MAX_ADDRESS_LEN);
+            break;
+        }
+        case AUDIO_PORT_TYPE_MIX: {
+            port->ext.mix.hwModule = halPort.ext.mix.hw_module;
+            port->ext.mix.ioHandle = halPort.ext.mix.handle;
+            port->ext.mix.latencyClass = AudioMixLatencyClass(halPort.ext.mix.latency_class);
+            break;
+        }
+        case AUDIO_PORT_TYPE_SESSION: {
+            port->ext.session.session = halPort.ext.session.session;
+            break;
+        }
+    }
+}
+
+// static
+void Device::audioPortToHal(const AudioPort& port, struct audio_port* halPort) {
+    memset(halPort, 0, sizeof(audio_port));
+    halPort->id = port.id;
+    halPort->role = static_cast<audio_port_role_t>(port.role);
+    halPort->type = static_cast<audio_port_type_t>(port.type);
+    memcpy(halPort->name,
+            port.name.c_str(),
+            std::min(port.name.size(), static_cast<size_t>(AUDIO_PORT_MAX_NAME_LEN)));
+    halPort->num_sample_rates =
+            std::min(port.sampleRates.size(), static_cast<size_t>(AUDIO_PORT_MAX_SAMPLING_RATES));
+    for (size_t i = 0; i < halPort->num_sample_rates; ++i) {
+        halPort->sample_rates[i] = port.sampleRates[i];
+    }
+    halPort->num_channel_masks =
+            std::min(port.channelMasks.size(), static_cast<size_t>(AUDIO_PORT_MAX_CHANNEL_MASKS));
+    for (size_t i = 0; i < halPort->num_channel_masks; ++i) {
+        halPort->channel_masks[i] = static_cast<audio_channel_mask_t>(port.channelMasks[i]);
+    }
+    halPort->num_formats =
+            std::min(port.formats.size(), static_cast<size_t>(AUDIO_PORT_MAX_FORMATS));
+    for (size_t i = 0; i < halPort->num_formats; ++i) {
+        halPort->formats[i] = static_cast<audio_format_t>(port.formats[i]);
+    }
+    halPort->num_gains = std::min(port.gains.size(), static_cast<size_t>(AUDIO_PORT_MAX_GAINS));
+    for (size_t i = 0; i < halPort->num_gains; ++i) {
+        audioGainToHal(port.gains[i], &halPort->gains[i]);
+    }
+    audioPortConfigToHal(port.activeConfig, &halPort->active_config);
+    switch (port.type) {
+        case AudioPortType::NONE: break;
+        case AudioPortType::DEVICE: {
+            halPort->ext.device.hw_module = port.ext.device.hwModule;
+            halPort->ext.device.type = static_cast<audio_devices_t>(port.ext.device.type);
+            memcpy(halPort->ext.device.address,
+                    port.ext.device.address.data(),
+                    AUDIO_DEVICE_MAX_ADDRESS_LEN);
+            break;
+        }
+        case AudioPortType::MIX: {
+            halPort->ext.mix.hw_module = port.ext.mix.hwModule;
+            halPort->ext.mix.handle = port.ext.mix.ioHandle;
+            halPort->ext.mix.latency_class =
+                    static_cast<audio_mix_latency_class_t>(port.ext.mix.latencyClass);
+            break;
+        }
+        case AudioPortType::SESSION: {
+            halPort->ext.session.session = static_cast<audio_session_t>(port.ext.session.session);
+            break;
+        }
+    }
+}
+
+Result Device::analyzeStatus(const char* funcName, int status) {
+    if (status != 0) {
+        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;
+    }
+}
+
+char* Device::halGetParameters(const char* keys) {
+    return mDevice->get_parameters(mDevice, keys);
+}
+
+int Device::halSetParameters(const char* keysAndValues) {
+    return mDevice->set_parameters(mDevice, keysAndValues);
+}
+
+// Methods from ::android::hardware::audio::V2_0::IDevice follow.
+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 retval;
+}
+
+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));
+    }
+    _hidl_cb(retval, volume);
+    return Void();
+}
+
+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)  {
+    bool mute = false;
+    Result retval = analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));
+    _hidl_cb(retval, mute);
+    return Void();
+}
+
+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));
+    }
+    return retval;
+}
+
+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));
+    }
+    _hidl_cb(retval, mute);
+    return Void();
+}
+
+Return<void> Device::getInputBufferSize(
+        const AudioConfig& config, getInputBufferSize_cb _hidl_cb)  {
+    audio_config_t halConfig;
+    audioConfigToHal(config, &halConfig);
+    size_t halBufferSize = mDevice->get_input_buffer_size(mDevice, &halConfig);
+    Result retval(Result::INVALID_ARGUMENTS);
+    uint64_t bufferSize = 0;
+    if (halBufferSize != 0) {
+        retval = Result::OK;
+        bufferSize = halBufferSize;
+    }
+    _hidl_cb(retval, bufferSize);
+    return Void();
+}
+
+Return<void> Device::openOutputStream(
+        int32_t ioHandle,
+        const DeviceAddress& device,
+        const AudioConfig& config,
+        AudioOutputFlag flags,
+        openOutputStream_cb _hidl_cb)  {
+    audio_config_t halConfig;
+    audioConfigToHal(config, &halConfig);
+    audio_stream_out_t *halStream;
+    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());
+    sp<IStreamOut> streamOut;
+    if (status == OK) {
+        streamOut = new StreamOut(mDevice, halStream);
+    }
+    _hidl_cb(analyzeStatus("open_output_stream", status), streamOut);
+    return Void();
+}
+
+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;
+    audioConfigToHal(config, &halConfig);
+    audio_stream_in_t *halStream;
+    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));
+    sp<IStreamIn> streamIn;
+    if (status == OK) {
+        streamIn = new StreamIn(mDevice, halStream);
+    }
+    _hidl_cb(analyzeStatus("open_input_stream", status), streamIn);
+    return Void();
+}
+
+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(audioPortConfigsToHal(sources));
+        std::unique_ptr<audio_port_config[]> halSinks(audioPortConfigsToHal(sinks));
+        audio_patch_handle_t halPatch;
+        retval = analyzeStatus(
+                "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);
+        }
+    }
+    _hidl_cb(retval, patch);
+    return Void();
+}
+
+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)));
+    }
+    return Result::NOT_SUPPORTED;
+}
+
+Return<void> Device::getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb)  {
+    audio_port halPort;
+    audioPortToHal(port, &halPort);
+    Result retval = analyzeStatus("get_audio_port", mDevice->get_audio_port(mDevice, &halPort));
+    AudioPort resultPort = port;
+    if (retval == Result::OK) {
+        audioPortFromHal(halPort, &resultPort);
+    }
+    _hidl_cb(retval, resultPort);
+    return Void();
+}
+
+Return<Result> Device::setAudioPortConfig(const AudioPortConfig& config)  {
+    if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
+        struct audio_port_config halPortConfig;
+        audioPortConfigToHal(config, &halPortConfig);
+        return analyzeStatus(
+                "set_audio_port_config", mDevice->set_audio_port_config(mDevice, &halPortConfig));
+    }
+    return Result::NOT_SUPPORTED;
+}
+
+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 setParam(AudioParameter::keyScreenState, turnedOn);
+}
+
+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 setParametersImpl(parameters);
+}
+
+Return<void> Device::debugDump(const native_handle_t* fd)  {
+    if (fd->numFds == 1) {
+        analyzeStatus("dump", mDevice->dump(mDevice, fd->data[0]));
+    }
+    return Void();
+}
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
diff --git a/audio/2.0/default/Device.h b/audio/2.0/default/Device.h
new file mode 100644
index 0000000..d7b3128
--- /dev/null
+++ b/audio/2.0/default/Device.h
@@ -0,0 +1,147 @@
+/*
+ * 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 HIDL_GENERATED_android_hardware_audio_V2_0_Device_H_
+#define HIDL_GENERATED_android_hardware_audio_V2_0_Device_H_
+
+#include <memory>
+
+#include <media/AudioParameter.h>
+#include <hardware/audio.h>
+
+#include <android/hardware/audio/2.0/IDevice.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+
+#include "ParametersUtil.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+using ::android::hardware::audio::common::V2_0::AudioConfig;
+using ::android::hardware::audio::common::V2_0::AudioGain;
+using ::android::hardware::audio::common::V2_0::AudioGainConfig;
+using ::android::hardware::audio::common::V2_0::AudioGainMode;
+using ::android::hardware::audio::common::V2_0::AudioHwSync;
+using ::android::hardware::audio::common::V2_0::AudioInputFlag;
+using ::android::hardware::audio::common::V2_0::AudioMixLatencyClass;
+using ::android::hardware::audio::common::V2_0::AudioOffloadInfo;
+using ::android::hardware::audio::common::V2_0::AudioOutputFlag;
+using ::android::hardware::audio::common::V2_0::AudioPatchHandle;
+using ::android::hardware::audio::common::V2_0::AudioPort;
+using ::android::hardware::audio::common::V2_0::AudioPortConfig;
+using ::android::hardware::audio::common::V2_0::AudioPortConfigMask;
+using ::android::hardware::audio::common::V2_0::AudioPortRole;
+using ::android::hardware::audio::common::V2_0::AudioPortType;
+using ::android::hardware::audio::common::V2_0::AudioSource;
+using ::android::hardware::audio::common::V2_0::AudioStreamType;
+using ::android::hardware::audio::V2_0::DeviceAddress;
+using ::android::hardware::audio::V2_0::IDevice;
+using ::android::hardware::audio::V2_0::IStreamIn;
+using ::android::hardware::audio::V2_0::IStreamOut;
+using ::android::hardware::audio::V2_0::ParameterValue;
+using ::android::hardware::audio::V2_0::Result;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct Device : public IDevice, public ParametersUtil {
+    explicit Device(audio_hw_device_t* device);
+
+    // Methods from ::android::hardware::audio::V2_0::IDevice follow.
+    Return<Result> initCheck()  override;
+    Return<Result> setMasterVolume(float volume)  override;
+    Return<void> getMasterVolume(getMasterVolume_cb _hidl_cb)  override;
+    Return<Result> setMicMute(bool mute)  override;
+    Return<void> getMicMute(getMicMute_cb _hidl_cb)  override;
+    Return<Result> setMasterMute(bool mute)  override;
+    Return<void> getMasterMute(getMasterMute_cb _hidl_cb)  override;
+    Return<void> getInputBufferSize(
+            const AudioConfig& config, getInputBufferSize_cb _hidl_cb)  override;
+    Return<void> openOutputStream(
+            int32_t ioHandle,
+            const DeviceAddress& device,
+            const AudioConfig& config,
+            AudioOutputFlag flags,
+            openOutputStream_cb _hidl_cb)  override;
+    Return<void> openInputStream(
+            int32_t ioHandle,
+            const DeviceAddress& device,
+            const AudioConfig& config,
+            AudioInputFlag flags,
+            AudioSource source,
+            openInputStream_cb _hidl_cb)  override;
+    Return<void> createAudioPatch(
+            const hidl_vec<AudioPortConfig>& sources,
+            const hidl_vec<AudioPortConfig>& sinks,
+            createAudioPatch_cb _hidl_cb)  override;
+    Return<Result> releaseAudioPatch(int32_t patch)  override;
+    Return<void> getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb)  override;
+    Return<Result> setAudioPortConfig(const AudioPortConfig& config)  override;
+    Return<AudioHwSync> getHwAvSync()  override;
+    Return<Result> setScreenState(bool turnedOn)  override;
+    Return<void> getParameters(
+            const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  override;
+    Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters)  override;
+    Return<void> debugDump(const native_handle_t* fd)  override;
+
+    // Utility methods for extending interfaces.
+    Result analyzeStatus(const char* funcName, int status);
+    audio_hw_device_t* device() const { return mDevice; }
+
+  private:
+    audio_hw_device_t *mDevice;
+
+    static void audioConfigToHal(const AudioConfig& config, audio_config_t* halConfig);
+    static void audioGainConfigFromHal(
+            const struct audio_gain_config& halConfig, AudioGainConfig* config);
+    static void audioGainConfigToHal(
+            const AudioGainConfig& config, struct audio_gain_config* halConfig);
+    static void audioGainFromHal(const struct audio_gain& halGain, AudioGain* gain);
+    static void audioGainToHal(const AudioGain& gain, struct audio_gain* halGain);
+    static void audioOffloadInfoToHal(
+            const AudioOffloadInfo& offload, audio_offload_info_t* halOffload);
+    static void audioPortConfigFromHal(
+            const struct audio_port_config& halConfig, AudioPortConfig* config);
+    static void audioPortConfigToHal(
+            const AudioPortConfig& config, struct audio_port_config* halConfig);
+    static std::unique_ptr<audio_port_config[]> audioPortConfigsToHal(
+            const hidl_vec<AudioPortConfig>& configs);
+    static void audioPortFromHal(const struct audio_port& halPort, AudioPort* port);
+    static void audioPortToHal(const AudioPort& port, struct audio_port* halPort);
+
+    virtual ~Device();
+
+    // Methods from ParametersUtil.
+    char* halGetParameters(const char* keys) override;
+    int halSetParameters(const char* keysAndValues) override;
+
+    uint32_t version() const { return mDevice->common.version; }
+};
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_audio_V2_0_Device_H_
diff --git a/audio/2.0/default/DevicesFactory.cpp b/audio/2.0/default/DevicesFactory.cpp
new file mode 100644
index 0000000..1e087f2
--- /dev/null
+++ b/audio/2.0/default/DevicesFactory.cpp
@@ -0,0 +1,103 @@
+/*
+ * 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 "DevicesFactoryHAL"
+
+#include <string.h>
+
+#include <utils/Log.h>
+
+#include "Device.h"
+#include "DevicesFactory.h"
+#include "PrimaryDevice.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+// static
+const char* DevicesFactory::deviceToString(IDevicesFactory::Device device) {
+    switch (device) {
+        case IDevicesFactory::Device::PRIMARY: return AUDIO_HARDWARE_MODULE_ID_PRIMARY;
+        case IDevicesFactory::Device::A2DP: return AUDIO_HARDWARE_MODULE_ID_A2DP;
+        case IDevicesFactory::Device::USB: return AUDIO_HARDWARE_MODULE_ID_USB;
+        case IDevicesFactory::Device::R_SUBMIX: return AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX;
+    }
+}
+
+// static
+int DevicesFactory::loadAudioInterface(const char *if_name, audio_hw_device_t **dev)
+{
+    const hw_module_t *mod;
+    int rc;
+
+    rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, &mod);
+    if (rc) {
+        ALOGE("%s couldn't load audio hw module %s.%s (%s)", __func__,
+                AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
+        goto out;
+    }
+    rc = audio_hw_device_open(mod, dev);
+    if (rc) {
+        ALOGE("%s couldn't open audio hw device in %s.%s (%s)", __func__,
+                AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
+        goto out;
+    }
+    if ((*dev)->common.version < AUDIO_DEVICE_API_VERSION_MIN) {
+        ALOGE("%s wrong audio hw device version %04x", __func__, (*dev)->common.version);
+        rc = -EINVAL;
+        audio_hw_device_close(*dev);
+        goto out;
+    }
+    return OK;
+
+out:
+    *dev = NULL;
+    return rc;
+}
+
+// Methods from ::android::hardware::audio::V2_0::IDevicesFactory follow.
+Return<void> DevicesFactory::openDevice(IDevicesFactory::Device device, openDevice_cb _hidl_cb)  {
+    audio_hw_device_t *halDevice;
+    int halStatus = loadAudioInterface(deviceToString(device), &halDevice);
+    Result retval(Result::OK);
+    sp<IDevice> result;
+    if (halStatus == OK) {
+        if (device == IDevicesFactory::Device::PRIMARY) {
+            result = new PrimaryDevice(halDevice);
+        } else {
+            result = new ::android::hardware::audio::V2_0::implementation::Device(halDevice);
+        }
+    } else if (halStatus == -EINVAL) {
+        retval = Result::NOT_INITIALIZED;
+    } else {
+        retval = Result::INVALID_ARGUMENTS;
+    }
+    _hidl_cb(retval, result);
+    return Void();
+}
+
+IDevicesFactory* HIDL_FETCH_IDevicesFactory(const char* /* name */) {
+    return new DevicesFactory();
+}
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
diff --git a/audio/2.0/default/DevicesFactory.h b/audio/2.0/default/DevicesFactory.h
new file mode 100644
index 0000000..0ea9859
--- /dev/null
+++ b/audio/2.0/default/DevicesFactory.h
@@ -0,0 +1,59 @@
+/*
+ * 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 HIDL_GENERATED_android_hardware_audio_V2_0_DevicesFactory_H_
+#define HIDL_GENERATED_android_hardware_audio_V2_0_DevicesFactory_H_
+
+#include <hardware/audio.h>
+
+#include <android/hardware/audio/2.0/IDevicesFactory.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+using ::android::hardware::audio::V2_0::IDevice;
+using ::android::hardware::audio::V2_0::IDevicesFactory;
+using ::android::hardware::audio::V2_0::Result;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct DevicesFactory : public IDevicesFactory {
+    // Methods from ::android::hardware::audio::V2_0::IDevicesFactory follow.
+    Return<void> openDevice(IDevicesFactory::Device device, openDevice_cb _hidl_cb)  override;
+
+  private:
+    static const char* deviceToString(IDevicesFactory::Device device);
+    static int loadAudioInterface(const char *if_name, audio_hw_device_t **dev);
+
+};
+
+extern "C" IDevicesFactory* HIDL_FETCH_IDevicesFactory(const char* name);
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_audio_V2_0_DevicesFactory_H_
diff --git a/audio/2.0/default/ParametersUtil.cpp b/audio/2.0/default/ParametersUtil.cpp
new file mode 100644
index 0000000..75a60b9
--- /dev/null
+++ b/audio/2.0/default/ParametersUtil.cpp
@@ -0,0 +1,134 @@
+/*
+ * 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.
+ */
+
+#include "ParametersUtil.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+Result ParametersUtil::getParam(const char* name, bool* value) {
+    String8 halValue;
+    Result retval = getParam(name, &halValue);
+    *value = false;
+    if (retval == Result::OK) {
+        *value = !(halValue == AudioParameter::valueOff);
+    }
+    return retval;
+}
+
+Result ParametersUtil::getParam(const char* name, int* value) {
+    const String8 halName(name);
+    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;
+}
+
+Result ParametersUtil::getParam(const char* name, String8* value) {
+    const String8 halName(name);
+    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;
+}
+
+void ParametersUtil::getParametersImpl(
+        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);
+    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();
+        }
+        if (result.size() != 0) {
+            retval = Result::OK;
+        }
+    }
+    cb(retval, result);
+}
+
+std::unique_ptr<AudioParameter> ParametersUtil::getParams(const AudioParameter& keys) {
+    String8 paramsAndValues;
+    char *halValues = halGetParameters(keys.keysToString().string());
+    if (halValues != NULL) {
+        paramsAndValues.setTo(halValues);
+        free(halValues);
+    } else {
+        paramsAndValues.clear();
+    }
+    return std::unique_ptr<AudioParameter>(new AudioParameter(paramsAndValues));
+}
+
+Result ParametersUtil::setParam(const char* name, bool value) {
+    AudioParameter param;
+    param.add(String8(name), String8(value ? AudioParameter::valueOn : AudioParameter::valueOff));
+    return setParams(param);
+}
+
+Result ParametersUtil::setParam(const char* name, int value) {
+    AudioParameter param;
+    param.addInt(String8(name), value);
+    return setParams(param);
+}
+
+Result ParametersUtil::setParam(const char* name, const char* value) {
+    AudioParameter param;
+    param.add(String8(name), String8(value));
+    return setParams(param);
+}
+
+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()));
+    }
+    return setParams(params);
+}
+
+Result ParametersUtil::setParams(const AudioParameter& param) {
+    int halStatus = halSetParameters(param.toString().string());
+    if (halStatus == OK)
+        return Result::OK;
+    else if (halStatus == -ENOSYS)
+        return Result::INVALID_STATE;
+    else
+        return Result::INVALID_ARGUMENTS;
+}
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
diff --git a/audio/2.0/default/ParametersUtil.h b/audio/2.0/default/ParametersUtil.h
new file mode 100644
index 0000000..49036dc
--- /dev/null
+++ b/audio/2.0/default/ParametersUtil.h
@@ -0,0 +1,66 @@
+/*
+ * 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_audio_V2_0_ParametersUtil_H_
+#define android_hardware_audio_V2_0_ParametersUtil_H_
+
+#include <functional>
+#include <memory>
+
+#include <android/hardware/audio/2.0/types.h>
+#include <hidl/HidlSupport.h>
+#include <media/AudioParameter.h>
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+using ::android::hardware::audio::V2_0::ParameterValue;
+using ::android::hardware::audio::V2_0::Result;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+
+class ParametersUtil {
+  public:
+    Result getParam(const char* name, bool* value);
+    Result getParam(const char* name, int* value);
+    Result getParam(const char* name, String8* value);
+    void getParametersImpl(
+            const hidl_vec<hidl_string>& keys,
+            std::function<void(Result retval, const hidl_vec<ParameterValue>& parameters)> cb);
+    std::unique_ptr<AudioParameter> getParams(const AudioParameter& keys);
+    Result setParam(const char* name, bool value);
+    Result setParam(const char* name, int value);
+    Result setParam(const char* name, const char* value);
+    Result setParametersImpl(const hidl_vec<ParameterValue>& parameters);
+    Result setParams(const AudioParameter& param);
+
+  protected:
+    virtual ~ParametersUtil() {}
+
+    virtual char* halGetParameters(const char* keys) = 0;
+    virtual int halSetParameters(const char* keysAndValues) = 0;
+};
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // android_hardware_audio_V2_0_ParametersUtil_H_
diff --git a/audio/2.0/default/PrimaryDevice.cpp b/audio/2.0/default/PrimaryDevice.cpp
new file mode 100644
index 0000000..9f5180c
--- /dev/null
+++ b/audio/2.0/default/PrimaryDevice.cpp
@@ -0,0 +1,189 @@
+/*
+ * 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 "PrimaryDeviceHAL"
+
+#include "PrimaryDevice.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+PrimaryDevice::PrimaryDevice(audio_hw_device_t* device)
+        : mDevice(new Device(device)) {
+}
+
+PrimaryDevice::~PrimaryDevice() {}
+
+// Methods from ::android::hardware::audio::V2_0::IDevice follow.
+Return<Result> PrimaryDevice::initCheck()  {
+    return mDevice->initCheck();
+}
+
+Return<Result> PrimaryDevice::setMasterVolume(float volume)  {
+    return mDevice->setMasterVolume(volume);
+}
+
+Return<void> PrimaryDevice::getMasterVolume(getMasterVolume_cb _hidl_cb)  {
+    return mDevice->getMasterVolume(_hidl_cb);
+}
+
+Return<Result> PrimaryDevice::setMicMute(bool mute)  {
+    return mDevice->setMicMute(mute);
+}
+
+Return<void> PrimaryDevice::getMicMute(getMicMute_cb _hidl_cb)  {
+    return mDevice->getMicMute(_hidl_cb);
+}
+
+Return<Result> PrimaryDevice::setMasterMute(bool mute)  {
+    return mDevice->setMasterMute(mute);
+}
+
+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 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 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);
+}
+
+Return<void> PrimaryDevice::createAudioPatch(
+        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 mDevice->releaseAudioPatch(patch);
+}
+
+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 mDevice->setAudioPortConfig(config);
+}
+
+Return<AudioHwSync> PrimaryDevice::getHwAvSync()  {
+    return mDevice->getHwAvSync();
+}
+
+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 mDevice->getParameters(keys, _hidl_cb);
+}
+
+Return<Result> PrimaryDevice::setParameters(const hidl_vec<ParameterValue>& parameters)  {
+    return mDevice->setParameters(parameters);
+}
+
+Return<void> PrimaryDevice::debugDump(const native_handle_t* fd)  {
+    return mDevice->debugDump(fd);
+}
+
+
+// Methods from ::android::hardware::audio::V2_0::IPrimaryDevice follow.
+Return<Result> PrimaryDevice::setVoiceVolume(float volume)  {
+    return mDevice->analyzeStatus(
+            "set_voice_volume",
+            mDevice->device()->set_voice_volume(mDevice->device(), volume));
+}
+
+Return<Result> PrimaryDevice::setMode(AudioMode mode)  {
+    return mDevice->analyzeStatus(
+            "set_mode",
+            mDevice->device()->set_mode(mDevice->device(), static_cast<audio_mode_t>(mode)));
+}
+
+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 mDevice->setParam(AudioParameter::keyBtNrec, enabled);
+}
+
+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 mDevice->setParam(AUDIO_PARAMETER_KEY_BT_SCO_WB, enabled);
+}
+
+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;
+    _hidl_cb(retval, mode);
+    return Void();
+}
+
+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)  {
+    bool enabled;
+    Result retval = mDevice->getParam(AUDIO_PARAMETER_KEY_HAC, &enabled);
+    _hidl_cb(retval, enabled);
+    return Void();
+}
+
+Return<Result> PrimaryDevice::setHacEnabled(bool enabled)  {
+    return mDevice->setParam(AUDIO_PARAMETER_KEY_HAC, enabled);
+}
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
diff --git a/audio/2.0/default/PrimaryDevice.h b/audio/2.0/default/PrimaryDevice.h
new file mode 100644
index 0000000..4c5b590
--- /dev/null
+++ b/audio/2.0/default/PrimaryDevice.h
@@ -0,0 +1,117 @@
+/*
+ * 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 HIDL_GENERATED_android_hardware_audio_V2_0_PrimaryDevice_H_
+#define HIDL_GENERATED_android_hardware_audio_V2_0_PrimaryDevice_H_
+
+#include <android/hardware/audio/2.0/IPrimaryDevice.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+
+#include "Device.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+using ::android::hardware::audio::common::V2_0::AudioConfig;
+using ::android::hardware::audio::common::V2_0::AudioInputFlag;
+using ::android::hardware::audio::common::V2_0::AudioMode;
+using ::android::hardware::audio::common::V2_0::AudioOutputFlag;
+using ::android::hardware::audio::common::V2_0::AudioPort;
+using ::android::hardware::audio::common::V2_0::AudioPortConfig;
+using ::android::hardware::audio::common::V2_0::AudioSource;
+using ::android::hardware::audio::V2_0::DeviceAddress;
+using ::android::hardware::audio::V2_0::IDevice;
+using ::android::hardware::audio::V2_0::IPrimaryDevice;
+using ::android::hardware::audio::V2_0::IStreamIn;
+using ::android::hardware::audio::V2_0::IStreamOut;
+using ::android::hardware::audio::V2_0::ParameterValue;
+using ::android::hardware::audio::V2_0::Result;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct PrimaryDevice : public IPrimaryDevice {
+    explicit PrimaryDevice(audio_hw_device_t* device);
+
+    // Methods from ::android::hardware::audio::V2_0::IDevice follow.
+    Return<Result> initCheck()  override;
+    Return<Result> setMasterVolume(float volume)  override;
+    Return<void> getMasterVolume(getMasterVolume_cb _hidl_cb)  override;
+    Return<Result> setMicMute(bool mute)  override;
+    Return<void> getMicMute(getMicMute_cb _hidl_cb)  override;
+    Return<Result> setMasterMute(bool mute)  override;
+    Return<void> getMasterMute(getMasterMute_cb _hidl_cb)  override;
+    Return<void> getInputBufferSize(
+            const AudioConfig& config, getInputBufferSize_cb _hidl_cb)  override;
+    Return<void> openOutputStream(
+            int32_t ioHandle,
+            const DeviceAddress& device,
+            const AudioConfig& config,
+            AudioOutputFlag flags,
+            openOutputStream_cb _hidl_cb)  override;
+    Return<void> openInputStream(
+            int32_t ioHandle,
+            const DeviceAddress& device,
+            const AudioConfig& config,
+            AudioInputFlag flags,
+            AudioSource source,
+            openInputStream_cb _hidl_cb)  override;
+    Return<void> createAudioPatch(
+            const hidl_vec<AudioPortConfig>& sources,
+            const hidl_vec<AudioPortConfig>& sinks,
+            createAudioPatch_cb _hidl_cb)  override;
+    Return<Result> releaseAudioPatch(int32_t patch)  override;
+    Return<void> getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb)  override;
+    Return<Result> setAudioPortConfig(const AudioPortConfig& config)  override;
+    Return<AudioHwSync> getHwAvSync()  override;
+    Return<Result> setScreenState(bool turnedOn)  override;
+    Return<void> getParameters(
+            const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  override;
+    Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters)  override;
+    Return<void> debugDump(const native_handle_t* fd)  override;
+
+    // Methods from ::android::hardware::audio::V2_0::IPrimaryDevice follow.
+    Return<Result> setVoiceVolume(float volume)  override;
+    Return<Result> setMode(AudioMode mode)  override;
+    Return<void> getBtScoNrecEnabled(getBtScoNrecEnabled_cb _hidl_cb)  override;
+    Return<Result> setBtScoNrecEnabled(bool enabled)  override;
+    Return<void> getBtScoWidebandEnabled(getBtScoWidebandEnabled_cb _hidl_cb)  override;
+    Return<Result> setBtScoWidebandEnabled(bool enabled)  override;
+    Return<void> getTtyMode(getTtyMode_cb _hidl_cb)  override;
+    Return<Result> setTtyMode(IPrimaryDevice::TtyMode mode)  override;
+    Return<void> getHacEnabled(getHacEnabled_cb _hidl_cb)  override;
+    Return<Result> setHacEnabled(bool enabled)  override;
+
+  private:
+    sp<Device> mDevice;
+
+    virtual ~PrimaryDevice();
+};
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_audio_V2_0_PrimaryDevice_H_
diff --git a/audio/2.0/default/Stream.cpp b/audio/2.0/default/Stream.cpp
new file mode 100644
index 0000000..7616bec
--- /dev/null
+++ b/audio/2.0/default/Stream.cpp
@@ -0,0 +1,236 @@
+/*
+ * 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.
+ */
+
+#include <inttypes.h>
+
+#define LOG_TAG "StreamHAL"
+
+#include <hardware/audio.h>
+#include <hardware/audio_effect.h>
+#include <media/TypeConverter.h>
+#include <utils/Log.h>
+#include <utils/SortedVector.h>
+#include <utils/Vector.h>
+
+#include "Conversions.h"
+#include "EffectMap.h"
+#include "Stream.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+Stream::Stream(audio_stream_t* stream)
+        : mStream(stream) {
+}
+
+Stream::~Stream() {
+    mStream = nullptr;
+}
+
+Result Stream::analyzeStatus(const char* funcName, int status) {
+    if (status != 0) {
+        ALOGW("Stream %p %s: %s", mStream, 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;
+    }
+}
+
+char* Stream::halGetParameters(const char* keys) {
+    return mStream->get_parameters(mStream, keys);
+}
+
+int Stream::halSetParameters(const char* keysAndValues) {
+    return mStream->set_parameters(mStream, keysAndValues);
+}
+
+// Methods from ::android::hardware::audio::V2_0::IStream follow.
+Return<uint64_t> Stream::getFrameSize()  {
+    // Needs to be implemented by interface subclasses. But can't be declared as pure virtual,
+    // since interface subclasses implementation do not inherit from this class.
+    LOG_ALWAYS_FATAL("Stream::getFrameSize is pure abstract");
+    return uint64_t {};
+}
+
+Return<uint64_t> Stream::getFrameCount()  {
+    int halFrameCount;
+    Result retval = getParam(AudioParameter::keyFrameCount, &halFrameCount);
+    return retval == Result::OK ? halFrameCount : 0;
+}
+
+Return<uint64_t> Stream::getBufferSize()  {
+    return mStream->get_buffer_size(mStream);
+}
+
+Return<uint32_t> Stream::getSampleRate()  {
+    return mStream->get_sample_rate(mStream);
+}
+
+Return<void> Stream::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb)  {
+    String8 halListValue;
+    Result result = getParam(AudioParameter::keyStreamSupportedSamplingRates, &halListValue);
+    hidl_vec<uint32_t> sampleRates;
+    SortedVector<uint32_t> halSampleRates;
+    if (result == Result::OK) {
+        halSampleRates = samplingRatesFromString(
+                halListValue.string(), AudioParameter::valueListSeparator);
+        sampleRates.setToExternal(halSampleRates.editArray(), halSampleRates.size());
+    }
+    _hidl_cb(sampleRates);
+    return Void();
+}
+
+Return<Result> Stream::setSampleRate(uint32_t sampleRateHz)  {
+    return setParam(AudioParameter::keySamplingRate, static_cast<int>(sampleRateHz));
+}
+
+Return<AudioChannelMask> Stream::getChannelMask()  {
+    return AudioChannelMask(mStream->get_channels(mStream));
+}
+
+Return<void> Stream::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb)  {
+    String8 halListValue;
+    Result result = getParam(AudioParameter::keyStreamSupportedChannels, &halListValue);
+    hidl_vec<AudioChannelMask> channelMasks;
+    SortedVector<audio_channel_mask_t> halChannelMasks;
+    if (result == Result::OK) {
+        halChannelMasks = channelMasksFromString(
+                halListValue.string(), AudioParameter::valueListSeparator);
+        channelMasks.resize(halChannelMasks.size());
+        for (size_t i = 0; i < halChannelMasks.size(); ++i) {
+            channelMasks[i] = AudioChannelMask(halChannelMasks[i]);
+        }
+    }
+     _hidl_cb(channelMasks);
+    return Void();
+}
+
+Return<Result> Stream::setChannelMask(AudioChannelMask mask)  {
+    return setParam(AudioParameter::keyChannels, static_cast<int>(mask));
+}
+
+Return<AudioFormat> Stream::getFormat()  {
+    return AudioFormat(mStream->get_format(mStream));
+}
+
+Return<void> Stream::getSupportedFormats(getSupportedFormats_cb _hidl_cb)  {
+    String8 halListValue;
+    Result result = getParam(AudioParameter::keyStreamSupportedFormats, &halListValue);
+    hidl_vec<AudioFormat> formats;
+    Vector<audio_format_t> halFormats;
+    if (result == Result::OK) {
+        halFormats = formatsFromString(halListValue.string(), AudioParameter::valueListSeparator);
+        formats.resize(halFormats.size());
+        for (size_t i = 0; i < halFormats.size(); ++i) {
+            formats[i] = AudioFormat(halFormats[i]);
+        }
+    }
+     _hidl_cb(formats);
+    return Void();
+}
+
+Return<Result> Stream::setFormat(AudioFormat format)  {
+    return setParam(AudioParameter::keyFormat, static_cast<int>(format));
+}
+
+Return<void> Stream::getAudioProperties(getAudioProperties_cb _hidl_cb)  {
+    uint32_t halSampleRate = mStream->get_sample_rate(mStream);
+    audio_channel_mask_t halMask = mStream->get_channels(mStream);
+    audio_format_t halFormat = mStream->get_format(mStream);
+    _hidl_cb(halSampleRate, AudioChannelMask(halMask), AudioFormat(halFormat));
+    return Void();
+}
+
+Return<Result> Stream::addEffect(uint64_t effectId)  {
+    effect_handle_t halEffect = EffectMap::getInstance().get(effectId);
+    if (halEffect != NULL) {
+        return analyzeStatus("add_audio_effect", mStream->add_audio_effect(mStream, halEffect));
+    } else {
+        ALOGW("Invalid effect ID passed from client: %" PRIu64, effectId);
+        return Result::INVALID_ARGUMENTS;
+    }
+}
+
+Return<Result> Stream::removeEffect(uint64_t effectId)  {
+    effect_handle_t halEffect = EffectMap::getInstance().get(effectId);
+    if (halEffect != NULL) {
+        return analyzeStatus(
+                "remove_audio_effect", mStream->remove_audio_effect(mStream, halEffect));
+    } else {
+        ALOGW("Invalid effect ID passed from client: %" PRIu64, effectId);
+        return Result::INVALID_ARGUMENTS;
+    }
+}
+
+Return<Result> Stream::standby()  {
+    return analyzeStatus("standby", mStream->standby(mStream));
+}
+
+Return<AudioDevice> Stream::getDevice()  {
+    return AudioDevice(mStream->get_device(mStream));
+}
+
+Return<Result> Stream::setDevice(const DeviceAddress& address)  {
+    char* halDeviceAddress =
+            audio_device_address_to_parameter(
+                    static_cast<audio_devices_t>(address.device),
+                    deviceAddressToHal(address).c_str());
+    AudioParameter params((String8(halDeviceAddress)));
+    free(halDeviceAddress);
+    params.addInt(
+            String8(AudioParameter::keyRouting), static_cast<audio_devices_t>(address.device));
+    return setParams(params);
+}
+
+Return<Result> Stream::setConnectedState(const DeviceAddress& address, bool connected)  {
+    return setParam(
+            connected ? AudioParameter::keyStreamConnect : AudioParameter::keyStreamDisconnect,
+            deviceAddressToHal(address).c_str());
+}
+
+Return<Result> Stream::setHwAvSync(uint32_t hwAvSync)  {
+    return setParam(AudioParameter::keyStreamHwAvSync, static_cast<int>(hwAvSync));
+}
+
+Return<void> Stream::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  {
+    getParametersImpl(keys, _hidl_cb);
+    return Void();
+}
+
+Return<Result> Stream::setParameters(const hidl_vec<ParameterValue>& parameters)  {
+    return setParametersImpl(parameters);
+}
+
+Return<void> Stream::debugDump(const native_handle_t* fd)  {
+    if (fd->numFds == 1) {
+        analyzeStatus("dump", mStream->dump(mStream, fd->data[0]));
+    }
+    return Void();
+}
+
+} // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
diff --git a/audio/2.0/default/Stream.h b/audio/2.0/default/Stream.h
new file mode 100644
index 0000000..f28fbff
--- /dev/null
+++ b/audio/2.0/default/Stream.h
@@ -0,0 +1,94 @@
+/*
+ * 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 HIDL_GENERATED_android_hardware_audio_V2_0_Stream_H_
+#define HIDL_GENERATED_android_hardware_audio_V2_0_Stream_H_
+
+#include <android/hardware/audio/2.0/IStream.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+
+#include "ParametersUtil.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+using ::android::hardware::audio::common::V2_0::AudioChannelMask;
+using ::android::hardware::audio::common::V2_0::AudioDevice;
+using ::android::hardware::audio::common::V2_0::AudioFormat;
+using ::android::hardware::audio::V2_0::DeviceAddress;
+using ::android::hardware::audio::V2_0::IStream;
+using ::android::hardware::audio::V2_0::ParameterValue;
+using ::android::hardware::audio::V2_0::Result;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct Stream : public IStream, public ParametersUtil {
+    explicit Stream(audio_stream_t* stream);
+
+    // Methods from ::android::hardware::audio::V2_0::IStream follow.
+    Return<uint64_t> getFrameSize()  override;
+    Return<uint64_t> getFrameCount()  override;
+    Return<uint64_t> getBufferSize()  override;
+    Return<uint32_t> getSampleRate()  override;
+    Return<void> getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb)  override;
+    Return<Result> setSampleRate(uint32_t sampleRateHz)  override;
+    Return<AudioChannelMask> getChannelMask()  override;
+    Return<void> getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb)  override;
+    Return<Result> setChannelMask(AudioChannelMask mask)  override;
+    Return<AudioFormat> getFormat()  override;
+    Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb)  override;
+    Return<Result> setFormat(AudioFormat format)  override;
+    Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb)  override;
+    Return<Result> addEffect(uint64_t effectId)  override;
+    Return<Result> removeEffect(uint64_t effectId)  override;
+    Return<Result> standby()  override;
+    Return<AudioDevice> getDevice()  override;
+    Return<Result> setDevice(const DeviceAddress& address)  override;
+    Return<Result> setConnectedState(const DeviceAddress& address, bool connected)  override;
+    Return<Result> setHwAvSync(uint32_t hwAvSync)  override;
+    Return<void> getParameters(
+            const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  override;
+    Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters)  override;
+    Return<void> debugDump(const native_handle_t* fd)  override;
+
+    // Utility methods for extending interfaces.
+    Result analyzeStatus(const char* funcName, int status);
+
+  private:
+    audio_stream_t *mStream;
+
+    virtual ~Stream();
+
+    // Methods from ParametersUtil.
+    char* halGetParameters(const char* keys) override;
+    int halSetParameters(const char* keysAndValues) override;
+};
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_audio_V2_0_Stream_H_
diff --git a/audio/2.0/default/StreamIn.cpp b/audio/2.0/default/StreamIn.cpp
new file mode 100644
index 0000000..b590d1a
--- /dev/null
+++ b/audio/2.0/default/StreamIn.cpp
@@ -0,0 +1,191 @@
+/*
+ * 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 "StreamInHAL"
+
+#include <hardware/audio.h>
+#include <utils/Log.h>
+
+#include "StreamIn.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+StreamIn::StreamIn(audio_hw_device_t* device, audio_stream_in_t* stream)
+        : mDevice(device), mStream(stream), mStreamCommon(new Stream(&stream->common)) {
+}
+
+StreamIn::~StreamIn() {
+    mDevice->close_input_stream(mDevice, mStream);
+    mStream = nullptr;
+    mDevice = nullptr;
+}
+
+// Methods from ::android::hardware::audio::V2_0::IStream follow.
+Return<uint64_t> StreamIn::getFrameSize()  {
+    return audio_stream_in_frame_size(mStream);
+}
+
+Return<uint64_t> StreamIn::getFrameCount()  {
+    return mStreamCommon->getFrameCount();
+}
+
+Return<uint64_t> StreamIn::getBufferSize()  {
+    return mStreamCommon->getBufferSize();
+}
+
+Return<uint32_t> StreamIn::getSampleRate()  {
+    return mStreamCommon->getSampleRate();
+}
+
+Return<void> StreamIn::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb)  {
+    return mStreamCommon->getSupportedSampleRates(_hidl_cb);
+}
+
+Return<Result> StreamIn::setSampleRate(uint32_t sampleRateHz)  {
+    return mStreamCommon->setSampleRate(sampleRateHz);
+}
+
+Return<AudioChannelMask> StreamIn::getChannelMask()  {
+    return mStreamCommon->getChannelMask();
+}
+
+Return<void> StreamIn::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb)  {
+    return mStreamCommon->getSupportedChannelMasks(_hidl_cb);
+}
+
+Return<Result> StreamIn::setChannelMask(AudioChannelMask mask)  {
+    return mStreamCommon->setChannelMask(mask);
+}
+
+Return<AudioFormat> StreamIn::getFormat()  {
+    return mStreamCommon->getFormat();
+}
+
+Return<void> StreamIn::getSupportedFormats(getSupportedFormats_cb _hidl_cb)  {
+    return mStreamCommon->getSupportedFormats(_hidl_cb);
+}
+
+Return<Result> StreamIn::setFormat(AudioFormat format)  {
+    return mStreamCommon->setFormat(format);
+}
+
+Return<void> StreamIn::getAudioProperties(getAudioProperties_cb _hidl_cb)  {
+    return mStreamCommon->getAudioProperties(_hidl_cb);
+}
+
+Return<Result> StreamIn::addEffect(uint64_t effectId)  {
+    return mStreamCommon->addEffect(effectId);
+}
+
+Return<Result> StreamIn::removeEffect(uint64_t effectId)  {
+    return mStreamCommon->removeEffect(effectId);
+}
+
+Return<Result> StreamIn::standby()  {
+    return mStreamCommon->standby();
+}
+
+Return<AudioDevice> StreamIn::getDevice()  {
+    return mStreamCommon->getDevice();
+}
+
+Return<Result> StreamIn::setDevice(const DeviceAddress& address)  {
+    return mStreamCommon->setDevice(address);
+}
+
+Return<Result> StreamIn::setConnectedState(const DeviceAddress& address, bool connected)  {
+    return mStreamCommon->setConnectedState(address, connected);
+}
+
+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 mStreamCommon->getParameters(keys, _hidl_cb);
+}
+
+Return<Result> StreamIn::setParameters(const hidl_vec<ParameterValue>& parameters)  {
+    return mStreamCommon->setParameters(parameters);
+}
+
+Return<void> StreamIn::debugDump(const native_handle_t* fd)  {
+    return mStreamCommon->debugDump(fd);
+}
+
+
+// Methods from ::android::hardware::audio::V2_0::IStreamIn follow.
+Return<void> StreamIn::getAudioSource(getAudioSource_cb _hidl_cb)  {
+    int halSource;
+    Result retval = mStreamCommon->getParam(AudioParameter::keyInputSource, &halSource);
+    AudioSource source(AudioSource::DEFAULT);
+    if (retval == Result::OK) {
+        source = AudioSource(halSource);
+    }
+    _hidl_cb(retval, source);
+    return Void();
+}
+
+Return<Result> StreamIn::setGain(float gain)  {
+    return mStreamCommon->analyzeStatus("set_gain", mStream->set_gain(mStream, gain));
+}
+
+Return<void> StreamIn::read(uint64_t size, read_cb _hidl_cb)  {
+    // TODO(mnaganov): Replace with FMQ version.
+    hidl_vec<uint8_t> data;
+    data.resize(size);
+    Result retval(Result::OK);
+    ssize_t readResult = mStream->read(mStream, &data[0], data.size());
+    if (readResult >= 0 && static_cast<size_t>(readResult) != data.size()) {
+        data.resize(readResult);
+    } else if (readResult < 0) {
+        data.resize(0);
+        retval = mStreamCommon->analyzeStatus("read", readResult);
+    }
+    _hidl_cb(retval, data);
+    return Void();
+}
+
+Return<uint32_t> StreamIn::getInputFramesLost()  {
+    return mStream->get_input_frames_lost(mStream);
+}
+
+Return<void> StreamIn::getCapturePosition(getCapturePosition_cb _hidl_cb)  {
+    Result retval(Result::NOT_SUPPORTED);
+    uint64_t frames = 0, time = 0;
+    if (mStream->get_capture_position != NULL) {
+        int64_t halFrames, halTime;
+        retval = mStreamCommon->analyzeStatus(
+                "get_capture_position",
+                mStream->get_capture_position(mStream, &halFrames, &halTime));
+        if (retval == Result::OK) {
+            frames = halFrames;
+            time = halTime;
+        }
+    }
+    _hidl_cb(retval, frames, time);
+    return Void();
+}
+
+} // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
diff --git a/audio/2.0/default/StreamIn.h b/audio/2.0/default/StreamIn.h
new file mode 100644
index 0000000..83f620c
--- /dev/null
+++ b/audio/2.0/default/StreamIn.h
@@ -0,0 +1,98 @@
+/*
+ * 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 HIDL_GENERATED_android_hardware_audio_V2_0_StreamIn_H_
+#define HIDL_GENERATED_android_hardware_audio_V2_0_StreamIn_H_
+
+#include <android/hardware/audio/2.0/IStreamIn.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+
+#include "Stream.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+using ::android::hardware::audio::common::V2_0::AudioChannelMask;
+using ::android::hardware::audio::common::V2_0::AudioDevice;
+using ::android::hardware::audio::common::V2_0::AudioFormat;
+using ::android::hardware::audio::common::V2_0::AudioSource;
+using ::android::hardware::audio::V2_0::DeviceAddress;
+using ::android::hardware::audio::V2_0::IStream;
+using ::android::hardware::audio::V2_0::IStreamIn;
+using ::android::hardware::audio::V2_0::ParameterValue;
+using ::android::hardware::audio::V2_0::Result;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct StreamIn : public IStreamIn {
+    StreamIn(audio_hw_device_t* device, audio_stream_in_t* stream);
+
+    // Methods from ::android::hardware::audio::V2_0::IStream follow.
+    Return<uint64_t> getFrameSize()  override;
+    Return<uint64_t> getFrameCount()  override;
+    Return<uint64_t> getBufferSize()  override;
+    Return<uint32_t> getSampleRate()  override;
+    Return<void> getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb)  override;
+    Return<Result> setSampleRate(uint32_t sampleRateHz)  override;
+    Return<AudioChannelMask> getChannelMask()  override;
+    Return<void> getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb)  override;
+    Return<Result> setChannelMask(AudioChannelMask mask)  override;
+    Return<AudioFormat> getFormat()  override;
+    Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb)  override;
+    Return<Result> setFormat(AudioFormat format)  override;
+    Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb)  override;
+    Return<Result> addEffect(uint64_t effectId)  override;
+    Return<Result> removeEffect(uint64_t effectId)  override;
+    Return<Result> standby()  override;
+    Return<AudioDevice> getDevice()  override;
+    Return<Result> setDevice(const DeviceAddress& address)  override;
+    Return<Result> setConnectedState(const DeviceAddress& address, bool connected)  override;
+    Return<Result> setHwAvSync(uint32_t hwAvSync)  override;
+    Return<void> getParameters(
+            const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  override;
+    Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters)  override;
+    Return<void> debugDump(const native_handle_t* fd)  override;
+
+    // Methods from ::android::hardware::audio::V2_0::IStreamIn follow.
+    Return<void> getAudioSource(getAudioSource_cb _hidl_cb)  override;
+    Return<Result> setGain(float gain)  override;
+    Return<void> read(uint64_t size, read_cb _hidl_cb)  override;
+    Return<uint32_t> getInputFramesLost()  override;
+    Return<void> getCapturePosition(getCapturePosition_cb _hidl_cb)  override;
+
+  private:
+    audio_hw_device_t *mDevice;
+    audio_stream_in_t *mStream;
+    sp<Stream> mStreamCommon;
+
+    virtual ~StreamIn();
+};
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_audio_V2_0_StreamIn_H_
diff --git a/audio/2.0/default/StreamOut.cpp b/audio/2.0/default/StreamOut.cpp
new file mode 100644
index 0000000..34bae29
--- /dev/null
+++ b/audio/2.0/default/StreamOut.cpp
@@ -0,0 +1,275 @@
+/*
+ * 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 "StreamOutHAL"
+
+#include <hardware/audio.h>
+#include <utils/Log.h>
+
+#include "StreamOut.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+StreamOut::StreamOut(audio_hw_device_t* device, audio_stream_out_t* stream)
+        : mDevice(device), mStream(stream), mStreamCommon(new Stream(&stream->common)) {
+}
+
+StreamOut::~StreamOut() {
+    mCallback.clear();
+    mDevice->close_output_stream(mDevice, mStream);
+    mStream = nullptr;
+    mDevice = nullptr;
+}
+
+// Methods from ::android::hardware::audio::V2_0::IStream follow.
+Return<uint64_t> StreamOut::getFrameSize()  {
+    return audio_stream_out_frame_size(mStream);
+}
+
+Return<uint64_t> StreamOut::getFrameCount()  {
+    return mStreamCommon->getFrameCount();
+}
+
+Return<uint64_t> StreamOut::getBufferSize()  {
+    return mStreamCommon->getBufferSize();
+}
+
+Return<uint32_t> StreamOut::getSampleRate()  {
+    return mStreamCommon->getSampleRate();
+}
+
+Return<void> StreamOut::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb)  {
+    return mStreamCommon->getSupportedSampleRates(_hidl_cb);
+}
+
+Return<Result> StreamOut::setSampleRate(uint32_t sampleRateHz)  {
+    return mStreamCommon->setSampleRate(sampleRateHz);
+}
+
+Return<AudioChannelMask> StreamOut::getChannelMask()  {
+    return mStreamCommon->getChannelMask();
+}
+
+Return<void> StreamOut::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb)  {
+    return mStreamCommon->getSupportedChannelMasks(_hidl_cb);
+}
+
+Return<Result> StreamOut::setChannelMask(AudioChannelMask mask)  {
+    return mStreamCommon->setChannelMask(mask);
+}
+
+Return<AudioFormat> StreamOut::getFormat()  {
+    return mStreamCommon->getFormat();
+}
+
+Return<void> StreamOut::getSupportedFormats(getSupportedFormats_cb _hidl_cb)  {
+    return mStreamCommon->getSupportedFormats(_hidl_cb);
+}
+
+Return<Result> StreamOut::setFormat(AudioFormat format)  {
+    return mStreamCommon->setFormat(format);
+}
+
+Return<void> StreamOut::getAudioProperties(getAudioProperties_cb _hidl_cb)  {
+    return mStreamCommon->getAudioProperties(_hidl_cb);
+}
+
+Return<Result> StreamOut::addEffect(uint64_t effectId)  {
+    return mStreamCommon->addEffect(effectId);
+}
+
+Return<Result> StreamOut::removeEffect(uint64_t effectId)  {
+    return mStreamCommon->removeEffect(effectId);
+}
+
+Return<Result> StreamOut::standby()  {
+    return mStreamCommon->standby();
+}
+
+Return<AudioDevice> StreamOut::getDevice()  {
+    return mStreamCommon->getDevice();
+}
+
+Return<Result> StreamOut::setDevice(const DeviceAddress& address)  {
+    return mStreamCommon->setDevice(address);
+}
+
+Return<Result> StreamOut::setConnectedState(const DeviceAddress& address, bool connected)  {
+    return mStreamCommon->setConnectedState(address, connected);
+}
+
+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 mStreamCommon->getParameters(keys, _hidl_cb);
+}
+
+Return<Result> StreamOut::setParameters(const hidl_vec<ParameterValue>& parameters)  {
+    return mStreamCommon->setParameters(parameters);
+}
+
+Return<void> StreamOut::debugDump(const native_handle_t* fd)  {
+    return mStreamCommon->debugDump(fd);
+}
+
+
+// Methods from ::android::hardware::audio::V2_0::IStreamOut follow.
+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 = mStreamCommon->analyzeStatus(
+                "set_volume", mStream->set_volume(mStream, left, right));
+    }
+    return retval;
+}
+
+Return<void> StreamOut::write(const hidl_vec<uint8_t>& data, write_cb _hidl_cb)  {
+    // TODO(mnaganov): Replace with FMQ version.
+    Result retval(Result::OK);
+    uint64_t written = 0;
+    ssize_t writeResult = mStream->write(mStream, &data[0], data.size());
+    if (writeResult >= 0) {
+        written = writeResult;
+    } else {
+        retval = mStreamCommon->analyzeStatus("write", writeResult);
+        written = 0;
+    }
+    _hidl_cb(retval, written);
+    return Void();
+}
+
+Return<void> StreamOut::getRenderPosition(getRenderPosition_cb _hidl_cb)  {
+    uint32_t halDspFrames;
+    Result retval = mStreamCommon->analyzeStatus(
+            "get_render_position", mStream->get_render_position(mStream, &halDspFrames));
+    _hidl_cb(retval, halDspFrames);
+    return Void();
+}
+
+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 = mStreamCommon->analyzeStatus(
+                "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)  {
+    if (mStream->set_callback == NULL) return Result::NOT_SUPPORTED;
+    int result = mStream->set_callback(mStream, StreamOut::asyncCallback, this);
+    if (result == 0) {
+        mCallback = callback;
+    }
+    return mStreamCommon->analyzeStatus("set_callback", result);
+}
+
+// static
+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 == 0) return 0;
+    sp<IStreamOutCallback> callback = self->mCallback.promote();
+    if (callback == 0) return 0;
+    ALOGV("asyncCallback() event %d", event);
+    switch (event) {
+        case STREAM_CBK_EVENT_WRITE_READY:
+            callback->onWriteReady();
+            break;
+        case STREAM_CBK_EVENT_DRAIN_READY:
+            callback->onDrainReady();
+            break;
+        case STREAM_CBK_EVENT_ERROR:
+            callback->onError();
+            break;
+        default:
+            ALOGW("asyncCallback() unknown event %d", event);
+            break;
+    }
+    return 0;
+}
+
+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 ?
+            mStreamCommon->analyzeStatus("pause", mStream->pause(mStream)) :
+            Result::NOT_SUPPORTED;
+}
+
+Return<Result> StreamOut::resume()  {
+    return mStream->resume != NULL ?
+            mStreamCommon->analyzeStatus("resume", mStream->resume(mStream)) :
+            Result::NOT_SUPPORTED;
+}
+
+Return<bool> StreamOut::supportsDrain()  {
+    return mStream->drain != NULL;
+}
+
+Return<Result> StreamOut::drain(AudioDrain type)  {
+    return mStream->drain != NULL ?
+            mStreamCommon->analyzeStatus(
+                    "drain", mStream->drain(mStream, static_cast<audio_drain_type_t>(type))) :
+            Result::NOT_SUPPORTED;
+}
+
+Return<Result> StreamOut::flush()  {
+    return mStream->flush != NULL ?
+            mStreamCommon->analyzeStatus("flush", mStream->flush(mStream)) :
+            Result::NOT_SUPPORTED;
+}
+
+Return<void> StreamOut::getPresentationPosition(getPresentationPosition_cb _hidl_cb)  {
+    Result retval(Result::NOT_SUPPORTED);
+    uint64_t frames = 0;
+    TimeSpec timeStamp = { 0, 0 };
+    if (mStream->get_presentation_position != NULL) {
+        struct timespec halTimeStamp;
+        retval = mStreamCommon->analyzeStatus(
+                "get_presentation_position",
+                mStream->get_presentation_position(mStream, &frames, &halTimeStamp));
+        if (retval == Result::OK) {
+            timeStamp.tvSec = halTimeStamp.tv_sec;
+            timeStamp.tvNSec = halTimeStamp.tv_nsec;
+        }
+    }
+    _hidl_cb(retval, frames, timeStamp);
+    return Void();
+}
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
diff --git a/audio/2.0/default/StreamOut.h b/audio/2.0/default/StreamOut.h
new file mode 100644
index 0000000..51b7df8
--- /dev/null
+++ b/audio/2.0/default/StreamOut.h
@@ -0,0 +1,113 @@
+/*
+ * 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 HIDL_GENERATED_android_hardware_audio_V2_0_StreamOut_H_
+#define HIDL_GENERATED_android_hardware_audio_V2_0_StreamOut_H_
+
+#include <android/hardware/audio/2.0/IStreamOut.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+
+#include "Stream.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace V2_0 {
+namespace implementation {
+
+using ::android::hardware::audio::common::V2_0::AudioChannelMask;
+using ::android::hardware::audio::common::V2_0::AudioDevice;
+using ::android::hardware::audio::common::V2_0::AudioFormat;
+using ::android::hardware::audio::V2_0::AudioDrain;
+using ::android::hardware::audio::V2_0::DeviceAddress;
+using ::android::hardware::audio::V2_0::IStream;
+using ::android::hardware::audio::V2_0::IStreamOut;
+using ::android::hardware::audio::V2_0::IStreamOutCallback;
+using ::android::hardware::audio::V2_0::ParameterValue;
+using ::android::hardware::audio::V2_0::Result;
+using ::android::hardware::audio::V2_0::TimeSpec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct StreamOut : public IStreamOut {
+    StreamOut(audio_hw_device_t* device, audio_stream_out_t* stream);
+
+    // Methods from ::android::hardware::audio::V2_0::IStream follow.
+    Return<uint64_t> getFrameSize()  override;
+    Return<uint64_t> getFrameCount()  override;
+    Return<uint64_t> getBufferSize()  override;
+    Return<uint32_t> getSampleRate()  override;
+    Return<void> getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb)  override;
+    Return<Result> setSampleRate(uint32_t sampleRateHz)  override;
+    Return<AudioChannelMask> getChannelMask()  override;
+    Return<void> getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb)  override;
+    Return<Result> setChannelMask(AudioChannelMask mask)  override;
+    Return<AudioFormat> getFormat()  override;
+    Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb)  override;
+    Return<Result> setFormat(AudioFormat format)  override;
+    Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb)  override;
+    Return<Result> addEffect(uint64_t effectId)  override;
+    Return<Result> removeEffect(uint64_t effectId)  override;
+    Return<Result> standby()  override;
+    Return<AudioDevice> getDevice()  override;
+    Return<Result> setDevice(const DeviceAddress& address)  override;
+    Return<Result> setConnectedState(const DeviceAddress& address, bool connected)  override;
+    Return<Result> setHwAvSync(uint32_t hwAvSync)  override;
+    Return<void> getParameters(
+            const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  override;
+    Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters)  override;
+    Return<void> debugDump(const native_handle_t* fd)  override;
+
+    // Methods from ::android::hardware::audio::V2_0::IStreamOut follow.
+    Return<uint32_t> getLatency()  override;
+    Return<Result> setVolume(float left, float right)  override;
+    Return<void> write(const hidl_vec<uint8_t>& data, write_cb _hidl_cb)  override;
+    Return<void> getRenderPosition(getRenderPosition_cb _hidl_cb)  override;
+    Return<void> getNextWriteTimestamp(getNextWriteTimestamp_cb _hidl_cb)  override;
+    Return<Result> setCallback(const sp<IStreamOutCallback>& callback)  override;
+    Return<void> supportsPauseAndResume(supportsPauseAndResume_cb _hidl_cb)  override;
+    Return<Result> pause()  override;
+    Return<Result> resume()  override;
+    Return<bool> supportsDrain()  override;
+    Return<Result> drain(AudioDrain type)  override;
+    Return<Result> flush()  override;
+    Return<void> getPresentationPosition(getPresentationPosition_cb _hidl_cb)  override;
+
+  private:
+    audio_hw_device_t *mDevice;
+    audio_stream_out_t *mStream;
+    sp<Stream> mStreamCommon;
+    // Do not store sp<> to avoid creating a reference loop if the entity that holds
+    // onto the output stream owns or implements the callback.
+    wp<IStreamOutCallback> mCallback;
+
+    virtual ~StreamOut();
+
+    static int asyncCallback(stream_callback_event_t event, void *param, void *cookie);
+};
+
+}  // namespace implementation
+}  // namespace V2_0
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_audio_V2_0_StreamOut_H_
diff --git a/audio/2.0/default/service.cpp b/audio/2.0/default/service.cpp
index 39708c2..147f7b9 100644
--- a/audio/2.0/default/service.cpp
+++ b/audio/2.0/default/service.cpp
@@ -14,28 +14,23 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "soundtriggerhal"
+#define LOG_TAG "audiohalservice"
 
-#include <hwbinder/IInterface.h>
-#include <hwbinder/IPCThreadState.h>
-#include <hwbinder/ProcessState.h>
-#include <utils/Errors.h>
-#include <utils/Log.h>
-#include <utils/Looper.h>
-#include <utils/StrongPointer.h>
+#include <hidl/LegacySupport.h>
+#include <android/hardware/audio/2.0/IDevicesFactory.h>
+#include <android/hardware/audio/effect/2.0/IEffectsFactory.h>
 #include <android/hardware/soundtrigger/2.0/ISoundTriggerHw.h>
 
 using android::hardware::IPCThreadState;
 using android::hardware::ProcessState;
+using android::hardware::audio::effect::V2_0::IEffectsFactory;
+using android::hardware::audio::V2_0::IDevicesFactory;
 using android::hardware::soundtrigger::V2_0::ISoundTriggerHw;
+using android::hardware::registerPassthroughServiceImplementation;
 
 int main(int /* argc */, char* /* argv */ []) {
-    android::sp<ISoundTriggerHw> service =
-            ISoundTriggerHw::getService("sound_trigger.primary", true /* getStub */);
-
-    service->registerAsService("sound_trigger.primary");
-
-    ProcessState::self()->setThreadPoolMaxThreadCount(0);
-    ProcessState::self()->startThreadPool();
-    IPCThreadState::self()->joinThreadPool();
+    registerPassthroughServiceImplementation<IDevicesFactory>("audio_devices_factory");
+    registerPassthroughServiceImplementation<IEffectsFactory>("audio_effects_factory");
+    registerPassthroughServiceImplementation<ISoundTriggerHw>("sound_trigger.primary");
+    return android::hardware::launchRpcServer(16);
 }
diff --git a/audio/2.0/types.hal b/audio/2.0/types.hal
index 6369885..9a5e4f1 100644
--- a/audio/2.0/types.hal
+++ b/audio/2.0/types.hal
@@ -66,7 +66,7 @@
             int32_t card;
             int32_t device;
         } alsa;             // used for USB_*
-        int32_t busId;      // used for BUS
     } address;
+    string busAddress;      // used for BUS
     string rSubmixAddress;  // used for REMOTE_SUBMIX
 };
diff --git a/audio/common/2.0/Android.bp b/audio/common/2.0/Android.bp
index 89ce3b6..c539c3c 100644
--- a/audio/common/2.0/Android.bp
+++ b/audio/common/2.0/Android.bp
@@ -30,13 +30,15 @@
     generated_headers: ["android.hardware.audio.common@2.0_genc++_headers"],
     export_generated_headers: ["android.hardware.audio.common@2.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/audio/common/2.0/default/Android.mk b/audio/common/2.0/default/Android.mk
new file mode 100644
index 0000000..aa60eb2
--- /dev/null
+++ b/audio/common/2.0/default/Android.mk
@@ -0,0 +1,29 @@
+#
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.audio.common@2.0-util
+LOCAL_SRC_FILES := \
+    EffectMap.cpp \
+
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
+
+LOCAL_SHARED_LIBRARIES := \
+    libutils \
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/audio/common/2.0/default/EffectMap.cpp b/audio/common/2.0/default/EffectMap.cpp
new file mode 100644
index 0000000..703b91c
--- /dev/null
+++ b/audio/common/2.0/default/EffectMap.cpp
@@ -0,0 +1,57 @@
+/*
+ * 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.
+ */
+
+#include <atomic>
+
+#include "EffectMap.h"
+
+namespace android {
+
+ANDROID_SINGLETON_STATIC_INSTANCE(EffectMap);
+
+// static
+const uint64_t EffectMap::INVALID_ID = 0;
+
+// static
+uint64_t EffectMap::makeUniqueId() {
+    static std::atomic<uint64_t> counter{INVALID_ID + 1};
+    return counter++;
+}
+
+uint64_t EffectMap::add(effect_handle_t handle) {
+    uint64_t newId = makeUniqueId();
+    std::lock_guard<std::mutex> lock(mLock);
+    mEffects.add(newId, handle);
+    return newId;
+}
+
+effect_handle_t EffectMap::get(const uint64_t& id) {
+    std::lock_guard<std::mutex> lock(mLock);
+    ssize_t idx = mEffects.indexOfKey(id);
+    return idx >= 0 ? mEffects[idx] : NULL;
+}
+
+void EffectMap::remove(effect_handle_t handle) {
+    std::lock_guard<std::mutex> lock(mLock);
+    for (size_t i = 0; i < mEffects.size(); ++i) {
+        if (mEffects[i] == handle) {
+            mEffects.removeItemsAt(i);
+            break;
+        }
+    }
+}
+
+}  // namespace android
diff --git a/audio/common/2.0/default/EffectMap.h b/audio/common/2.0/default/EffectMap.h
new file mode 100644
index 0000000..82bbb1f
--- /dev/null
+++ b/audio/common/2.0/default/EffectMap.h
@@ -0,0 +1,46 @@
+/*
+ * 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_audio_V2_0_EffectMap_H_
+#define android_hardware_audio_V2_0_EffectMap_H_
+
+#include <mutex>
+
+#include <hardware/audio_effect.h>
+#include <utils/KeyedVector.h>
+#include <utils/Singleton.h>
+
+namespace android {
+
+// This class needs to be in 'android' ns because Singleton macros require that.
+class EffectMap : public Singleton<EffectMap> {
+  public:
+    static const uint64_t INVALID_ID;
+
+    uint64_t add(effect_handle_t handle);
+    effect_handle_t get(const uint64_t& id);
+    void remove(effect_handle_t handle);
+
+  private:
+    static uint64_t makeUniqueId();
+
+    std::mutex mLock;
+    KeyedVector<uint64_t, effect_handle_t> mEffects;
+};
+
+}  // namespace android
+
+#endif  // android_hardware_audio_V2_0_EffectMap_H_
diff --git a/audio/common/2.0/types.hal b/audio/common/2.0/types.hal
index a5ec68d..75fdb52 100644
--- a/audio/common/2.0/types.hal
+++ b/audio/common/2.0/types.hal
@@ -555,8 +555,7 @@
     IN_IP                    = BIT_IN | 0x80000,
     /* audio bus implemented by the audio system (e.g an MOST stereo channel) */
     IN_BUS                   = BIT_IN | 0x100000,
-    IN_DEFAULT               = BIT_IN |
-                                            BIT_DEFAULT,
+    IN_DEFAULT               = BIT_IN | BIT_DEFAULT,
 
     IN_ALL     = (IN_COMMUNICATION |
             IN_AMBIENT |
@@ -798,10 +797,10 @@
             union UseCase {
                 AudioStreamType stream;
                 AudioSource source;
-            };
+            } useCase;
         } mix;
         AudioPortConfigSessionExt session;
-    };
+    } ext;
 };
 
 /*
@@ -849,16 +848,5 @@
         AudioPortDeviceExt device;
         AudioPortMixExt mix;
         AudioPortSessionExt session;
-    };
-};
-
-/*
- * An audio patch represents a connection between one or more source ports and
- * one or more sink ports. Patches are connected and disconnected by audio
- * policy manager or by applications via framework APIs.
- */
-struct AudioPatch {
-    AudioPatchHandle id;
-    vec<AudioPortConfig> sources;
-    vec<AudioPortConfig> sinks;
+    } ext;
 };
diff --git a/audio/common/Android.mk b/audio/common/Android.mk
new file mode 100644
index 0000000..f9e3276
--- /dev/null
+++ b/audio/common/Android.mk
@@ -0,0 +1,19 @@
+#
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(call all-subdir-makefiles)
diff --git a/audio/effect/2.0/Android.bp b/audio/effect/2.0/Android.bp
index 78829be..11ea604 100644
--- a/audio/effect/2.0/Android.bp
+++ b/audio/effect/2.0/Android.bp
@@ -142,14 +142,16 @@
     generated_headers: ["android.hardware.audio.effect@2.0_genc++_headers"],
     export_generated_headers: ["android.hardware.audio.effect@2.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
         "android.hardware.audio.common@2.0",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "android.hardware.audio.common@2.0",
diff --git a/audio/effect/2.0/IEffectsFactory.hal b/audio/effect/2.0/IEffectsFactory.hal
index 6763825..c82b4a2 100644
--- a/audio/effect/2.0/IEffectsFactory.hal
+++ b/audio/effect/2.0/IEffectsFactory.hal
@@ -50,9 +50,11 @@
      *                 directed to in audio HAL.
      * @return retval operation completion status.
      * @return result the interface for the created effect.
+     * @return effectId the unique ID of the effect to be used with
+     *                  IStream::addEffect and IStream::removeEffect methods.
      */
     createEffect(Uuid uid, AudioSession session, AudioIoHandle ioHandle)
-            generates (Result retval, IEffect result);
+        generates (Result retval, IEffect result, uint64_t effectId);
 
     /*
      * Dumps information about effects into the provided file descriptor.
diff --git a/audio/effect/2.0/default/Android.mk b/audio/effect/2.0/default/Android.mk
index 13106f3..9b99737 100644
--- a/audio/effect/2.0/default/Android.mk
+++ b/audio/effect/2.0/default/Android.mk
@@ -20,12 +20,14 @@
     VisualizerEffect.cpp \
 
 LOCAL_SHARED_LIBRARIES := \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     libutils \
     libeffects \
     liblog \
     android.hardware.audio.common@2.0 \
+    android.hardware.audio.common@2.0-util \
     android.hardware.audio.effect@2.0 \
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/audio/effect/2.0/default/Effect.cpp b/audio/effect/2.0/default/Effect.cpp
index 8ab0749..82d0292 100644
--- a/audio/effect/2.0/default/Effect.cpp
+++ b/audio/effect/2.0/default/Effect.cpp
@@ -23,6 +23,7 @@
 
 #include "Conversions.h"
 #include "Effect.h"
+#include "EffectMap.h"
 
 namespace android {
 namespace hardware {
@@ -45,6 +46,7 @@
 Effect::~Effect() {
     int status = EffectRelease(mHandle);
     ALOGW_IF(status, "Error releasing effect %p: %s", mHandle, strerror(-status));
+    EffectMap::getInstance().remove(mHandle);
     mHandle = 0;
 }
 
diff --git a/audio/effect/2.0/default/EffectsFactory.cpp b/audio/effect/2.0/default/EffectsFactory.cpp
index f7c5d62..30fcb26 100644
--- a/audio/effect/2.0/default/EffectsFactory.cpp
+++ b/audio/effect/2.0/default/EffectsFactory.cpp
@@ -36,6 +36,7 @@
 #include "EffectsFactory.h"
 #include "DownmixEffect.h"
 #include "Effect.h"
+#include "EffectMap.h"
 #include "EnvironmentalReverbEffect.h"
 #include "EqualizerEffect.h"
 #include "LoudnessEnhancerEffect.h"
@@ -157,12 +158,16 @@
     Result retval(Result::OK);
     status_t status = EffectCreate(&halUuid, session, ioHandle, &handle);
     sp<IEffect> effect;
+    uint64_t effectId = EffectMap::INVALID_ID;
     if (status == OK) {
         effect_descriptor_t halDescriptor;
         memset(&halDescriptor, 0, sizeof(effect_descriptor_t));
         status = (*handle)->get_descriptor(handle, &halDescriptor);
         if (status == OK) {
             effect = dispatchEffectInstanceCreation(halDescriptor, handle);
+            effectId = EffectMap::getInstance().add(handle);
+        } else {
+            EffectRelease(handle);
         }
     }
     if (status != OK) {
@@ -173,7 +178,7 @@
             retval = Result::NOT_INITIALIZED;
         }
     }
-    _hidl_cb(retval, effect);
+    _hidl_cb(retval, effect, effectId);
     return Void();
 }
 
diff --git a/audio/effect/2.0/vts/functional/Android.bp b/audio/effect/2.0/vts/functional/Android.bp
index fc198e5..b82d44a 100644
--- a/audio/effect/2.0/vts/functional/Android.bp
+++ b/audio/effect/2.0/vts/functional/Android.bp
@@ -22,7 +22,8 @@
         "libbase",
         "liblog",
         "libcutils",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libnativehelper",
         "libutils",
diff --git a/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp b/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp
index ddd5eac..c7878d5 100644
--- a/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp
+++ b/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp
@@ -84,13 +84,14 @@
   ASSERT_TRUE(gotEffect);
   Result retval = Result::NOT_INITIALIZED;
   sp<IEffect> effect;
-  ret = effectsFactory->createEffect(effectUuid, 1, 1,
-                                     [&](Result r, const sp<IEffect>& result) {
-                                       retval = r;
-                                       if (r == Result::OK) {
-                                         effect = result;
-                                       }
-                                     });
+  ret = effectsFactory->createEffect(
+      effectUuid, 1 /* session */, 1 /* ioHandle */,
+      [&](Result r, const sp<IEffect>& result, uint64_t /*effectId*/) {
+        retval = r;
+        if (r == Result::OK) {
+          effect = result;
+        }
+      });
   EXPECT_EQ(ret.getStatus().exceptionCode(), Status::EX_NONE);
   EXPECT_EQ(retval, Result::OK);
   EXPECT_NE(effect, nullptr);
diff --git a/benchmarks/msgq/1.0/Android.bp b/benchmarks/msgq/1.0/Android.bp
index a527b32..06ec3da 100644
--- a/benchmarks/msgq/1.0/Android.bp
+++ b/benchmarks/msgq/1.0/Android.bp
@@ -34,13 +34,15 @@
     generated_headers: ["android.hardware.benchmarks.msgq@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.benchmarks.msgq@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/biometrics/fingerprint/2.1/Android.bp b/biometrics/fingerprint/2.1/Android.bp
index 9d2af44..cea7200 100644
--- a/biometrics/fingerprint/2.1/Android.bp
+++ b/biometrics/fingerprint/2.1/Android.bp
@@ -46,13 +46,15 @@
     generated_headers: ["android.hardware.biometrics.fingerprint@2.1_genc++_headers"],
     export_generated_headers: ["android.hardware.biometrics.fingerprint@2.1_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/biometrics/fingerprint/2.1/IBiometricsFingerprint.hal b/biometrics/fingerprint/2.1/IBiometricsFingerprint.hal
index b7f8d88..3b24a2c 100644
--- a/biometrics/fingerprint/2.1/IBiometricsFingerprint.hal
+++ b/biometrics/fingerprint/2.1/IBiometricsFingerprint.hal
@@ -25,13 +25,12 @@
    * This call must block if the HAL state machine is in busy state until HAL
    * leaves the busy state.
    *
-   * @return isOk indicates if the request is accepted.
-   * @return debugErrno is a value the framework logs in case isOk == false.
+   * @return debugErrno is a value the framework logs in case it is not 0.
    */
   @callflow(next={"setActiveGroup"})
   @entry
   setNotify(IBiometricsFingerprintClientCallback clientCallback)
-      generates (bool isOk, int32_t debugErrno);
+      generates (RequestStatus debugErrno);
 
   /*
    * Fingerprint pre-enroll enroll request:
@@ -62,25 +61,23 @@
    * @param gid a framework defined fingerprint set (group) id.
    * @param timeoutSec a timeout in seconds.
    *
-   * @return isOk indicates if the request is accepted.
-   * @return debugErrno is a value the framework logs in case isOk == false.
+   * @return debugErrno is a value the framework logs in case it is not 0.
    *
    * A notify() function may be called with a more detailed error structure.
    */
   @callflow(next={"cancel", "enroll", "postEnroll", "remove"})
-  enroll(HwAuthToken hat, uint32_t gid, uint32_t timeoutSec)
-      generates (bool isOk, int32_t debugErrno);
+  enroll(uint8_t[69] hat, uint32_t gid, uint32_t timeoutSec)
+      generates (RequestStatus debugErrno);
 
   /*
    * Finishes the enroll operation and invalidates the preEnroll() generated
    * challenge. This must be called at the end of a multi-finger enrollment
    * session to indicate that no more fingers may be added.
    *
-   * @return isOk indicates if the request is accepted.
-   * @return debugErrno is a value the framework logs in case isOk == false.
+   * @return debugErrno is a value the framework logs in case it is not 0.
    */
   @callflow(next={"authenticate", "setActiveGroup", "enumerate", "remove"})
-  postEnroll() generates (bool isOk, int32_t debugErrno);
+  postEnroll() generates (RequestStatus debugErrno);
 
   /*
    * getAuthenticatorId:
@@ -99,12 +96,11 @@
    * to all running clients. Switches the HAL state machine back to the idle
    * state. Unlike enrollDone() doesn't invalidate the preEnroll() challenge.
    *
-   * @return isOk indicates if the request is accepted.
-   * @return debugErrno is a value the framework logs in case isOk == false.
+   * @return debugErrno is a value the framework logs in case it is not 0.
    */
   @callflow(next={"authenticate", "enroll", "enumerate", "remove",
     "setActiveGroup"})
-  cancel() generates (bool isOk, int32_t debugErrno);
+  cancel() generates (RequestStatus debugErrno);
 
   /*
    * Enumerate all the fingerprint templates found in the directory set by
@@ -115,11 +111,10 @@
    * fingerprintMsg.data.enumerated.remainingTemplates indicating how many more
    * enumeration messages to expect.
    *
-   * @return isOk indicates if the request is accepted.
-   * @return debugErrno is a value the framework logs in case isOk == false.
+   * @return debugErrno is a value the framework logs in case it is not 0.
    */
   @callflow(next={"remove", "enroll", "authenticate", "setActiveGroup"})
-  enumerate() generates (bool isOk, int32_t debugErrno);
+  enumerate() generates (RequestStatus debugErrno);
 
   /*
    * Fingerprint remove request:
@@ -135,12 +130,11 @@
    * @param fid template id to delete or 0 to delete all templates within the
    * current group.
    *
-   * @return isOk indicates if the request is accepted.
-   * @return debugErrno is a value the framework logs in case isOk == false.
+   * @return debugErrno is a value the framework logs in case it is not 0.
    */
   @callflow(next={"enumerate", "authenticate", "cancel", "getAuthenticatorId",
     "setActiveGroup"})
-  remove(uint32_t gid, uint32_t fid) generates (bool isOk, int32_t debugErrno);
+  remove(uint32_t gid, uint32_t fid) generates (RequestStatus debugErrno);
 
   /*
    * Restricts the HAL operation to a set of fingerprints belonging to a group
@@ -150,12 +144,11 @@
    * @param gid the fingerprint group (set) id.
    * @param storePath filesystem path to the template storage directory.
    *
-   * @return isOk indicates if the request is accepted.
-   * @return debugErrno is a value the framework logs in case isOk == false.
+   * @return debugErrno is a value the framework logs in case it is not 0.
    */
   @callflow(next={"authenticate", "preEnroll", "enumerate", "remove"})
   setActiveGroup(uint32_t gid, string storePath)
-      generates (bool isOk, int32_t debugErrno);
+      generates (RequestStatus debugErrno);
 
   /*
    * Authenticates an operation identified by operationId
@@ -163,10 +156,9 @@
    * @param operationId operation id.
    * @param gid fingerprint group id.
    *
-   * @return isOk indicates if the request is accepted.
-   * @return debugErrno is a value the framework logs in case isOk == false.
+   * @return debugErrno is a value the framework logs in case it is not 0.
    */
   @callflow(next={"cancel", "preEnroll", "remove"})
   authenticate(uint64_t operationId, uint32_t gid)
-      generates (bool isOk, int32_t debugErrno);
+      generates (RequestStatus debugErrno);
 };
diff --git a/biometrics/fingerprint/2.1/default/Android.mk b/biometrics/fingerprint/2.1/default/Android.mk
index be8bae6..c487c7a 100644
--- a/biometrics/fingerprint/2.1/default/Android.mk
+++ b/biometrics/fingerprint/2.1/default/Android.mk
@@ -8,7 +8,8 @@
 
 LOCAL_SHARED_LIBRARIES := \
     liblog \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhardware \
     libhwbinder \
     libutils \
diff --git a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
index 3ee7836..1316686 100644
--- a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
+++ b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#define LOG_TAG "android.hardware.biometrics.fingerprint@2.1-impl"
 
 #include <hardware/hardware.h>
 #include <hardware/fingerprint.h>
@@ -25,6 +26,9 @@
 namespace V2_1 {
 namespace implementation {
 
+using RequestStatus =
+        android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
+
 sp<IBiometricsFingerprintClientCallback>
     BiometricsFingerprint::mClientCallback = nullptr;
 
@@ -46,78 +50,81 @@
     mDevice = NULL;
 }
 
-Return<void> BiometricsFingerprint::setNotify(
-        const sp<IBiometricsFingerprintClientCallback>& clientCallback,
-        setNotify_cb cb)  {
+Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) {
+    switch(error) {
+        case 0: return RequestStatus::SYS_OK;
+        case -2: return RequestStatus::SYS_ENOENT;
+        case -4: return RequestStatus::SYS_EINTR;
+        case -5: return RequestStatus::SYS_EIO;
+        case -11: return RequestStatus::SYS_EAGAIN;
+        case -12: return RequestStatus::SYS_ENOMEM;
+        case -13: return RequestStatus::SYS_EACCES;
+        case -14: return RequestStatus::SYS_EFAULT;
+        case -16: return RequestStatus::SYS_EBUSY;
+        case -22: return RequestStatus::SYS_EINVAL;
+        case -28: return RequestStatus::SYS_ENOSPC;
+        case -110: return RequestStatus::SYS_ETIMEDOUT;
+        default:
+            ALOGE("An unknown error returned from fingerprint vendor library");
+            return RequestStatus::SYS_UNKNOWN;
+    }
+}
+
+Return<RequestStatus> BiometricsFingerprint::setNotify(
+        const sp<IBiometricsFingerprintClientCallback>& clientCallback) {
     mClientCallback = clientCallback;
-    int32_t debugErrno = mDevice->set_notify(mDevice, notify);
-    cb(debugErrno == 0, debugErrno);
-    return Void();
+    return RequestStatus::SYS_OK;
 }
 
 Return<uint64_t> BiometricsFingerprint::preEnroll()  {
     return mDevice->pre_enroll(mDevice);
 }
 
-Return<void> BiometricsFingerprint::enroll(const HwAuthToken& hat, uint32_t gid,
-        uint32_t timeoutSec, enroll_cb cb)  {
+Return<RequestStatus> BiometricsFingerprint::enroll(const hidl_array<uint8_t, 69>& hat,
+        uint32_t gid, uint32_t timeoutSec) {
     const hw_auth_token_t* authToken =
-        reinterpret_cast<const hw_auth_token_t*>(&hat);
-    int32_t debugErrno = mDevice->enroll(mDevice, authToken, gid, timeoutSec);
-    cb(debugErrno == 0, debugErrno);
-    return Void();
+        reinterpret_cast<const hw_auth_token_t*>(hat.data());
+    return ErrorFilter(mDevice->enroll(mDevice, authToken, gid, timeoutSec));
 }
 
-Return<void> BiometricsFingerprint::postEnroll(postEnroll_cb cb) {
-    int32_t debugErrno = mDevice->post_enroll(mDevice);
-    cb(debugErrno == 0, debugErrno);
-    return Void();
+Return<RequestStatus> BiometricsFingerprint::postEnroll() {
+    return ErrorFilter(mDevice->post_enroll(mDevice));
 }
 
 Return<uint64_t> BiometricsFingerprint::getAuthenticatorId() {
     return mDevice->get_authenticator_id(mDevice);
 }
 
-Return<void> BiometricsFingerprint::cancel(cancel_cb cb) {
-    int32_t debugErrno = mDevice->cancel(mDevice);
-    cb(debugErrno == 0, debugErrno);
-    return Void();
+Return<RequestStatus> BiometricsFingerprint::cancel() {
+    return ErrorFilter(mDevice->cancel(mDevice));
 }
 
-Return<void> BiometricsFingerprint::enumerate(enumerate_cb cb)  {
-    int32_t debugErrno = mDevice->enumerate(mDevice);
-    cb(debugErrno == 0, debugErrno);
-    return Void();
+Return<RequestStatus> BiometricsFingerprint::enumerate()  {
+    return ErrorFilter(mDevice->enumerate(mDevice));
 }
 
-Return<void> BiometricsFingerprint::remove(uint32_t gid, uint32_t fid,
-        remove_cb cb)  {
-    int32_t debugErrno = mDevice->remove(mDevice, gid, fid);
-    cb(debugErrno == 0, debugErrno);
-    return Void();
+Return<RequestStatus> BiometricsFingerprint::remove(uint32_t gid, uint32_t fid) {
+    return ErrorFilter(mDevice->remove(mDevice, gid, fid));
 }
 
-Return<void> BiometricsFingerprint::setActiveGroup(uint32_t gid,
-        const hidl_string& storePath, setActiveGroup_cb cb)  {
+Return<RequestStatus> BiometricsFingerprint::setActiveGroup(uint32_t gid,
+        const hidl_string& storePath) {
     if (storePath.size() >= PATH_MAX || storePath.size() <= 0) {
         ALOGE("Bad path length: %zd", storePath.size());
     }
-    int32_t debugErrno = mDevice->set_active_group(mDevice, gid,
-        storePath.c_str());
-    cb(debugErrno == 0, debugErrno);
-    return Void();
+    return ErrorFilter(mDevice->set_active_group(mDevice, gid,
+                                                    storePath.c_str()));
 }
 
-Return<void> BiometricsFingerprint::authenticate(uint64_t operationId,
-        uint32_t gid, authenticate_cb cb)  {
-    int32_t debugErrno = mDevice->authenticate(mDevice, operationId, gid);
-    cb(debugErrno == 0, debugErrno);
-    return Void();
+Return<RequestStatus> BiometricsFingerprint::authenticate(uint64_t operationId,
+        uint32_t gid) {
+    return ErrorFilter(mDevice->authenticate(mDevice, operationId, gid));
 }
 
 IBiometricsFingerprint* HIDL_FETCH_IBiometricsFingerprint(const char*) {
     int err;
     const hw_module_t *hw_mdl = NULL;
+    ALOGE("Opening fingerprint hal library...");
     if (0 != (err = hw_get_module(FINGERPRINT_HARDWARE_MODULE_ID, &hw_mdl))) {
         ALOGE("Can't open fingerprint HW Module, error: %d", err);
         return nullptr;
@@ -141,8 +148,16 @@
         return nullptr;
     }
 
-    return new BiometricsFingerprint(
-        reinterpret_cast<fingerprint_device_t*>(device));
+    fingerprint_device_t* fp_device =
+        reinterpret_cast<fingerprint_device_t*>(device);
+
+    if (0 != (err =
+            fp_device->set_notify(fp_device, BiometricsFingerprint::notify))) {
+        ALOGE("Can't register fingerprint module callback, error: %d", err);
+        return nullptr;
+    }
+
+    return new BiometricsFingerprint(fp_device);
 }
 
 } // namespace implementation
diff --git a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h
index 4fdc328..de8727b 100644
--- a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h
+++ b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-#ifndef HIDL_GENERATED_android_hardware_biometrics_fingerprint_V2_1_BiometricsFingerprint_H_
-#define HIDL_GENERATED_android_hardware_biometrics_fingerprint_V2_1_BiometricsFingerprint_H_
+#ifndef ANDROID_HARDWARE_BIOMETRICS_FINGERPRINT_V2_1_BIOMETRICSFINGERPRINT_H
+#define ANDROID_HARDWARE_BIOMETRICS_FINGERPRINT_V2_1_BIOMETRICSFINGERPRINT_H
 
 #include <utils/Log.h>
+#include <hidl/MQDescriptor.h>
 #include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprint.h>
 #include <hidl/Status.h>
 
-#include <hidl/MQDescriptor.h>
 namespace android {
 namespace hardware {
 namespace biometrics {
@@ -29,9 +29,9 @@
 namespace V2_1 {
 namespace implementation {
 
-using ::android::hardware::biometrics::fingerprint::V2_1::HwAuthToken;
 using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint;
 using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;
+using ::android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
 using ::android::hardware::Return;
 using ::android::hardware::Void;
 using ::android::hardware::hidl_vec;
@@ -43,16 +43,16 @@
     BiometricsFingerprint(fingerprint_device_t *device);
     ~BiometricsFingerprint();
     // Methods from ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint follow.
-    Return<void> setNotify(const sp<IBiometricsFingerprintClientCallback>& clientCallback, setNotify_cb _hidl_cb)  override;
-    Return<uint64_t> preEnroll()  override;
-    Return<void> enroll(const HwAuthToken& hat, uint32_t gid, uint32_t timeoutSec, enroll_cb _hidl_cb)  override;
-    Return<void> postEnroll(postEnroll_cb _hidl_cb)  override;
-    Return<uint64_t> getAuthenticatorId()  override;
-    Return<void> cancel(cancel_cb _hidl_cb)  override;
-    Return<void> enumerate(enumerate_cb _hidl_cb)  override;
-    Return<void> remove(uint32_t gid, uint32_t fid, remove_cb _hidl_cb)  override;
-    Return<void> setActiveGroup(uint32_t gid, const hidl_string& storePath, setActiveGroup_cb _hidl_cb)  override;
-    Return<void> authenticate(uint64_t operationId, uint32_t gid, authenticate_cb _hidl_cb)  override;
+    Return<RequestStatus> setNotify(const sp<IBiometricsFingerprintClientCallback>& clientCallback) override;
+    Return<uint64_t> preEnroll() override;
+    Return<RequestStatus> enroll(const hidl_array<uint8_t, 69>& hat, uint32_t gid, uint32_t timeoutSec) override;
+    Return<RequestStatus> postEnroll() override;
+    Return<uint64_t> getAuthenticatorId() override;
+    Return<RequestStatus> cancel() override;
+    Return<RequestStatus> enumerate() override;
+    Return<RequestStatus> remove(uint32_t gid, uint32_t fid) override;
+    Return<RequestStatus> setActiveGroup(uint32_t gid, const hidl_string& storePath) override;
+    Return<RequestStatus> authenticate(uint64_t operationId, uint32_t gid) override;
     static void notify(const fingerprint_msg_t *notify_msg) {
         if (mClientCallback == nullptr) {
             ALOGE("Receiving callbacks before the client callback is registered.");
@@ -63,6 +63,7 @@
         mClientCallback->notify(msg);
     }
 private:
+    Return<RequestStatus> ErrorFilter(int32_t error);
     static sp<IBiometricsFingerprintClientCallback> mClientCallback;
     fingerprint_device_t *mDevice;
 };
@@ -76,4 +77,4 @@
 }  // namespace hardware
 }  // namespace android
 
-#endif  // HIDL_GENERATED_android_hardware_biometrics_fingerprint_V2_1_BiometricsFingerprint_H_
+#endif  // ANDROID_HARDWARE_BIOMETRICS_FINGERPRINT_V2_1_BIOMETRICSFINGERPRINT_H
diff --git a/biometrics/fingerprint/2.1/types.hal b/biometrics/fingerprint/2.1/types.hal
index cf68c04..201ec7c 100644
--- a/biometrics/fingerprint/2.1/types.hal
+++ b/biometrics/fingerprint/2.1/types.hal
@@ -17,6 +17,27 @@
 package android.hardware.biometrics.fingerprint@2.1;
 
 /*
+ * Request status indicates whether the request is accepted by the vendor
+ * implementation or not. These values are taken from the errno set,
+ * except for the SYS_UNKNOWN
+ */
+enum RequestStatus : int32_t {
+  SYS_UNKNOWN = 1,
+  SYS_OK = 0,
+  SYS_ENOENT = -2,
+  SYS_EINTR = -4,
+  SYS_EIO = -5,
+  SYS_EAGAIN = -11,
+  SYS_ENOMEM = -12,
+  SYS_EACCES = -13,
+  SYS_EFAULT = -14,
+  SYS_EBUSY = -16,
+  SYS_EINVAL = -22,
+  SYS_ENOSPC = -28,
+  SYS_ETIMEDOUT = -110,
+};
+
+/*
  * Fingerprint errors are meant to tell the framework to terminate the current
  * operation and ask for the user to correct the situation. These will almost
  * always result in messaging and user interaction to correct the problem.
@@ -66,25 +87,6 @@
   ACQUIRED_VENDOR_BASE = 1000,
 };
 
-/* TODO import from keymaster HIDL when available */
-enum HwAuthenticatorType : uint32_t {
-  HW_AUTH_NONE = 0,
-  HW_AUTH_PASSWORD = 1,
-  HW_AUTH_FINGERPRINT = 2,
-  HW_AUTH_ANY = 0xffffffff,
-};
-
-/* TODO import from keymaster HIDL when available */
-struct HwAuthToken {
-  uint8_t version;
-  uint64_t challenge;
-  uint64_t userId;
-  uint64_t authenticatorId;
-  uint32_t authenticatorType;
-  uint64_t timestamp;
-  uint8_t[32] hmac;
-};
-
 struct FingerprintFingerId {
   /* Group ID */
   uint32_t gid;
@@ -121,7 +123,7 @@
   /* Matched template ID */
   FingerprintFingerId finger;
   /* Authentication result from the keymaster */
-  HwAuthToken hat;
+  uint8_t[69] hat;
 };
 
 /* Run time type identification for the notify() call payload. */
@@ -137,12 +139,12 @@
 struct FingerprintMsg {
   /* Selects the payload below */
   FingerprintMsgType type;
-  union data {
+  union Data {
     FingerprintError error;
     FingerprintEnroll enroll;
     FingerprintEnumerated enumerated;
     FingerprintRemoved removed;
     FingerprintAcquired acquired;
     FingerprintAuthenticated authenticated;
-  };
+  } data;
 };
diff --git a/bluetooth/1.0/Android.bp b/bluetooth/1.0/Android.bp
index d8f3ca5..67417fb 100644
--- a/bluetooth/1.0/Android.bp
+++ b/bluetooth/1.0/Android.bp
@@ -46,13 +46,15 @@
     generated_headers: ["android.hardware.bluetooth@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.bluetooth@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/boot/1.0/Android.bp b/boot/1.0/Android.bp
index cad7497..835d358 100644
--- a/boot/1.0/Android.bp
+++ b/boot/1.0/Android.bp
@@ -38,13 +38,15 @@
     generated_headers: ["android.hardware.boot@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.boot@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/boot/1.0/default/Android.mk b/boot/1.0/default/Android.mk
index 50fd1e4..be67779 100644
--- a/boot/1.0/default/Android.mk
+++ b/boot/1.0/default/Android.mk
@@ -8,7 +8,8 @@
 
 LOCAL_SHARED_LIBRARIES := \
     liblog \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     libhardware \
     libutils \
@@ -27,7 +28,8 @@
     liblog \
     libhwbinder \
     libhardware \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libutils \
     android.hardware.boot@1.0 \
 
diff --git a/boot/1.0/vts/Android.mk b/boot/1.0/vts/Android.mk
index 16b92c1..8a56b27 100644
--- a/boot/1.0/vts/Android.mk
+++ b/boot/1.0/vts/Android.mk
@@ -25,18 +25,14 @@
   BootControl.vts \
   types.vts \
 
-LOCAL_C_INCLUDES := \
-  android.hardware.boot@1.0\
-  system/core/base/include \
-  system/core/include \
-
 LOCAL_SHARED_LIBRARIES += \
   android.hardware.boot@1.0 \
   libbase \
   libutils \
   libcutils \
   liblog \
-  libhidl \
+  libhidlbase \
+  libhidltransport \
   libhwbinder \
   libprotobuf-cpp-full \
   libvts_common \
@@ -44,10 +40,6 @@
   libvts_measurement \
   libvts_multidevice_proto \
 
-LOCAL_CFLAGS += -DENABLE_TREBLE
-
-LOCAL_STATIC_LIBRARIES := \
-
 LOCAL_PROTOC_OPTIMIZE_TYPE := full
 
 LOCAL_MULTILIB := both
@@ -73,7 +65,8 @@
    libbase \
    libcutils \
    liblog \
-   libhidl \
+   libhidlbase \
+   libhidltransport \
    libhwbinder \
    libprotobuf-cpp-full \
    libvts_common \
diff --git a/broadcastradio/1.0/Android.bp b/broadcastradio/1.0/Android.bp
index c337e08..a876ac2 100644
--- a/broadcastradio/1.0/Android.bp
+++ b/broadcastradio/1.0/Android.bp
@@ -62,13 +62,15 @@
     generated_headers: ["android.hardware.broadcastradio@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.broadcastradio@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/contexthub/1.0/Android.bp b/contexthub/1.0/Android.bp
index 23c44de..f13ef5b 100644
--- a/contexthub/1.0/Android.bp
+++ b/contexthub/1.0/Android.bp
@@ -46,13 +46,15 @@
     generated_headers: ["android.hardware.contexthub@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.contexthub@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/example/extension/light/2.0/Android.bp b/example/extension/light/2.0/Android.bp
index 2a4eddf..ae93a6b 100644
--- a/example/extension/light/2.0/Android.bp
+++ b/example/extension/light/2.0/Android.bp
@@ -38,14 +38,16 @@
     generated_headers: ["android.hardware.example.extension.light@2.0_genc++_headers"],
     export_generated_headers: ["android.hardware.example.extension.light@2.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
         "android.hardware.light@2.0",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "android.hardware.light@2.0",
diff --git a/example/extension/light/2.0/default/Android.mk b/example/extension/light/2.0/default/Android.mk
index fa68787..55c21b9 100644
--- a/example/extension/light/2.0/default/Android.mk
+++ b/example/extension/light/2.0/default/Android.mk
@@ -8,7 +8,8 @@
     Light.cpp \
 
 LOCAL_SHARED_LIBRARIES := \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     libutils \
     android.hardware.light@2.0 \
diff --git a/gnss/1.0/Android.bp b/gnss/1.0/Android.bp
index 1f538ca..f33f1c6 100644
--- a/gnss/1.0/Android.bp
+++ b/gnss/1.0/Android.bp
@@ -166,13 +166,15 @@
     generated_headers: ["android.hardware.gnss@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.gnss@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/graphics/allocator/2.0/Android.bp b/graphics/allocator/2.0/Android.bp
index 004d7d2..d6e88a3 100644
--- a/graphics/allocator/2.0/Android.bp
+++ b/graphics/allocator/2.0/Android.bp
@@ -38,14 +38,18 @@
     generated_headers: ["android.hardware.graphics.allocator@2.0_genc++_headers"],
     export_generated_headers: ["android.hardware.graphics.allocator@2.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
+        "android.hardware.graphics.common@1.0",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
+        "android.hardware.graphics.common@1.0",
     ],
 }
diff --git a/graphics/allocator/2.0/Android.mk b/graphics/allocator/2.0/Android.mk
deleted file mode 100644
index 3165fed..0000000
--- a/graphics/allocator/2.0/Android.mk
+++ /dev/null
@@ -1,38 +0,0 @@
-# This file is autogenerated by hidl-gen. Do not edit manually.
-
-LOCAL_PATH := $(call my-dir)
-
-################################################################################
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := android.hardware.graphics.allocator@2.0-java-constants
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-
-intermediates := $(local-generated-sources-dir)
-
-HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
-#
-GEN := $(intermediates)/android/hardware/graphics/allocator/2.0/Constants.java
-$(GEN): $(HIDL)
-$(GEN): $(LOCAL_PATH)/types.hal
-$(GEN): $(LOCAL_PATH)/IAllocator.hal
-
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava-constants -randroid.hardware:hardware/interfaces \
-        android.hardware.graphics.allocator@2.0
-
-$(GEN):
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-# Avoid dependency cycle of framework.jar -> this-library -> framework.jar
-LOCAL_NO_STANDARD_LIBRARIES := true
-LOCAL_JAVA_LIBRARIES := core-oj
-
-include $(BUILD_STATIC_JAVA_LIBRARY)
-
-
-
-include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/graphics/allocator/2.0/IAllocator.hal b/graphics/allocator/2.0/IAllocator.hal
index c5bb088..9a45444 100644
--- a/graphics/allocator/2.0/IAllocator.hal
+++ b/graphics/allocator/2.0/IAllocator.hal
@@ -16,6 +16,8 @@
 
 package android.hardware.graphics.allocator@2.0;
 
+import android.hardware.graphics.common@1.0::PixelFormat;
+
 interface IAllocator {
     enum Capability : int32_t {
         /* reserved */
@@ -26,11 +28,16 @@
          * is supported.
          */
         TEST_ALLOCATE = 1,
+
+        /*
+         * layerCount must be 1 unless this capability is supported.
+         */
+        LAYERED_BUFFERS = 2,
     };
 
     struct BufferDescriptorInfo {
         /*
-         * The width specifies how many columns of pixels should be in the
+         * The width specifies how many columns of pixels must be in the
          * allocated buffer, but does not necessarily represent the offset in
          * columns between the same column in adjacent rows. The rows may be
          * padded.
@@ -38,11 +45,16 @@
         uint32_t width;
 
        /*
-        * The height specifies how many rows of pixels should be in the
+        * The height specifies how many rows of pixels must be in the
         * allocated buffer.
         */
         uint32_t height;
 
+       /*
+        * The number of image layers that must be in the allocated buffer.
+        */
+        uint32_t layerCount;
+
         /* Buffer pixel format. */
         PixelFormat format;
 
diff --git a/graphics/allocator/2.0/default/Android.bp b/graphics/allocator/2.0/default/Android.bp
index 8eac8f5..994feb3 100644
--- a/graphics/allocator/2.0/default/Android.bp
+++ b/graphics/allocator/2.0/default/Android.bp
@@ -8,7 +8,8 @@
         "libbase",
         "libcutils",
         "libhardware",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "liblog",
         "libutils",
@@ -23,7 +24,8 @@
 
     shared_libs: [
         "android.hardware.graphics.allocator@2.0",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "liblog",
         "libutils",
diff --git a/graphics/allocator/2.0/default/Gralloc.cpp b/graphics/allocator/2.0/default/Gralloc.cpp
index a7fc6c1..8a74661 100644
--- a/graphics/allocator/2.0/default/Gralloc.cpp
+++ b/graphics/allocator/2.0/default/Gralloc.cpp
@@ -74,6 +74,7 @@
         GRALLOC1_PFN_DESTROY_DESCRIPTOR destroyDescriptor;
         GRALLOC1_PFN_SET_DIMENSIONS setDimensions;
         GRALLOC1_PFN_SET_FORMAT setFormat;
+        GRALLOC1_PFN_SET_LAYER_COUNT setLayerCount;
         GRALLOC1_PFN_SET_CONSUMER_USAGE setConsumerUsage;
         GRALLOC1_PFN_SET_PRODUCER_USAGE setProducerUsage;
         GRALLOC1_PFN_ALLOCATE allocate;
@@ -135,6 +136,10 @@
             GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR);
     initDispatch(mDispatch.setDimensions, GRALLOC1_FUNCTION_SET_DIMENSIONS);
     initDispatch(mDispatch.setFormat, GRALLOC1_FUNCTION_SET_FORMAT);
+    if (hasCapability(Capability::LAYERED_BUFFERS)) {
+        initDispatch(
+                mDispatch.setLayerCount, GRALLOC1_FUNCTION_SET_LAYER_COUNT);
+    }
     initDispatch(mDispatch.setConsumerUsage,
             GRALLOC1_FUNCTION_SET_CONSUMER_USAGE);
     initDispatch(mDispatch.setProducerUsage,
@@ -191,6 +196,11 @@
         err = mDispatch.setFormat(mDevice, descriptor,
                 static_cast<int32_t>(descriptorInfo.format));
     }
+    if (err == GRALLOC1_ERROR_NONE &&
+            hasCapability(Capability::LAYERED_BUFFERS)) {
+        err = mDispatch.setLayerCount(mDevice, descriptor,
+                descriptorInfo.layerCount);
+    }
     if (err == GRALLOC1_ERROR_NONE) {
         uint64_t producerUsageMask = descriptorInfo.producerUsageMask;
         if (producerUsageMask & GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN) {
diff --git a/graphics/allocator/2.0/types.hal b/graphics/allocator/2.0/types.hal
index 23b7345..6081db9 100644
--- a/graphics/allocator/2.0/types.hal
+++ b/graphics/allocator/2.0/types.hal
@@ -136,36 +136,5 @@
     /* bits 48-63 are reserved for vendor extensions */
 };
 
-/*
- * Copied from android_pixel_format_t.
- *
- * TODO(olv) copy comments as well and have android_pixel_format_t generated
- */
-@export(name="android_pixel_format", value_prefix="HAL_PIXEL_FORMAT_")
-enum PixelFormat : int32_t {
-    RGBA_8888              = 1,
-    RGBX_8888              = 2,
-    RGB_888                = 3,
-    RGB_565                = 4,
-    BGRA_8888              = 5,
-    YV12                   = 0x32315659,
-    Y8                     = 0x20203859,
-    Y16                    = 0x20363159,
-    RAW16                  = 0x20,
-    RAW10                  = 0x25,
-    RAW12                  = 0x26,
-    RAW_OPAQUE             = 0x24,
-    BLOB                   = 0x21,
-    IMPLEMENTATION_DEFINED = 0x22,
-    YCbCr_420_888          = 0x23,
-    YCbCr_422_888          = 0x27,
-    YCbCr_444_888          = 0x28,
-    FLEX_RGB_888           = 0x29,
-    FLEX_RGBA_8888         = 0x2A,
-    YCbCr_422_SP           = 0x10,
-    YCrCb_420_SP           = 0x11,
-    YCbCr_422_I            = 0x14,
-};
-
 typedef uint64_t BufferDescriptor;
 typedef uint64_t Buffer;
diff --git a/graphics/common/1.0/Android.bp b/graphics/common/1.0/Android.bp
index fa95ca0..6c6ebbe 100644
--- a/graphics/common/1.0/Android.bp
+++ b/graphics/common/1.0/Android.bp
@@ -30,13 +30,15 @@
     generated_headers: ["android.hardware.graphics.common@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.graphics.common@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/graphics/common/1.0/Android.mk b/graphics/common/1.0/Android.mk
new file mode 100644
index 0000000..17b67b6
--- /dev/null
+++ b/graphics/common/1.0/Android.mk
@@ -0,0 +1,265 @@
+# This file is autogenerated by hidl-gen. Do not edit manually.
+
+LOCAL_PATH := $(call my-dir)
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.graphics.common@1.0-java
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(local-generated-sources-dir)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+
+#
+# Build types.hal (ColorMode)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/ColorMode.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 \
+        android.hardware.graphics.common@1.0::types.ColorMode
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (ColorTransform)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/ColorTransform.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 \
+        android.hardware.graphics.common@1.0::types.ColorTransform
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (Dataspace)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/Dataspace.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 \
+        android.hardware.graphics.common@1.0::types.Dataspace
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (Hdr)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/Hdr.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 \
+        android.hardware.graphics.common@1.0::types.Hdr
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (PixelFormat)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/PixelFormat.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 \
+        android.hardware.graphics.common@1.0::types.PixelFormat
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (Transform)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/Transform.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 \
+        android.hardware.graphics.common@1.0::types.Transform
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+include $(BUILD_JAVA_LIBRARY)
+
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.graphics.common@1.0-java-static
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(local-generated-sources-dir)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+
+#
+# Build types.hal (ColorMode)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/ColorMode.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 \
+        android.hardware.graphics.common@1.0::types.ColorMode
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (ColorTransform)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/ColorTransform.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 \
+        android.hardware.graphics.common@1.0::types.ColorTransform
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (Dataspace)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/Dataspace.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 \
+        android.hardware.graphics.common@1.0::types.Dataspace
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (Hdr)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/Hdr.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 \
+        android.hardware.graphics.common@1.0::types.Hdr
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (PixelFormat)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/PixelFormat.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 \
+        android.hardware.graphics.common@1.0::types.PixelFormat
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (Transform)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/Transform.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 \
+        android.hardware.graphics.common@1.0::types.Transform
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+include $(BUILD_STATIC_JAVA_LIBRARY)
+
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.graphics.common@1.0-java-constants
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(local-generated-sources-dir)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+#
+GEN := $(intermediates)/android/hardware/graphics/common/1.0/Constants.java
+$(GEN): $(HIDL)
+$(GEN): $(LOCAL_PATH)/types.hal
+
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+        -Ljava-constants -randroid.hardware:hardware/interfaces \
+        android.hardware.graphics.common@1.0
+
+$(GEN):
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+# Avoid dependency cycle of framework.jar -> this-library -> framework.jar
+LOCAL_NO_STANDARD_LIBRARIES := true
+LOCAL_JAVA_LIBRARIES := core-oj
+
+include $(BUILD_STATIC_JAVA_LIBRARY)
+
+
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/graphics/common/1.0/types.hal b/graphics/common/1.0/types.hal
index 395af49..9726c3a 100644
--- a/graphics/common/1.0/types.hal
+++ b/graphics/common/1.0/types.hal
@@ -38,6 +38,12 @@
     BGRA_8888          = 5,
 
     /*
+     * The following formats use a 16bit float per color component.
+     */
+    RGBA_FP16          = 0x10,
+    RGBX_FP16          = 0x11,
+
+    /*
      * 0x100 - 0x1FF
      *
      * This range is reserved for pixel formats that are specific to the HAL
@@ -658,6 +664,28 @@
      */
     STANDARD_FILM = 9 << STANDARD_SHIFT,
 
+    /*
+     * SMPTE EG 432-1 and SMPTE RP 431-2. (DCI-P3)
+     * Primaries:       x       y
+     *  green           0.265   0.690
+     *  blue            0.150   0.060
+     *  red             0.680   0.320
+     *  white (D65)     0.3127  0.3290
+     */
+    STANDARD_DCI_P3 = 10 << STANDARD_SHIFT,
+
+    /*
+     * Adobe RGB
+     * Primaries:       x       y
+     *  green           0.210   0.710
+     *  blue            0.150   0.060
+     *  red             0.640   0.330
+     *  white (D65)     0.3127  0.3290
+     */
+    STANDARD_ADOBE_RGB = 11 << STANDARD_SHIFT,
+
+
+
     TRANSFER_SHIFT = 22,
 
     /*
@@ -730,6 +758,16 @@
     TRANSFER_GAMMA2_2 = 4 << TRANSFER_SHIFT,
 
     /*
+     *  display gamma 2.6.
+     *
+     * Transfer characteristic curve:
+     *  E = L ^ (1/2.6)
+     *      L - luminance of image 0 <= L <= 1 for conventional colorimetry
+     *      E - corresponding electrical signal
+     */
+    TRANSFER_GAMMA2_6 = 5 << TRANSFER_SHIFT,
+
+    /*
      *  display gamma 2.8.
      *
      * Transfer characteristic curve:
@@ -737,7 +775,7 @@
      *      L - luminance of image 0 <= L <= 1 for conventional colorimetry
      *      E - corresponding electrical signal
      */
-    TRANSFER_GAMMA2_8 = 5 << TRANSFER_SHIFT,
+    TRANSFER_GAMMA2_8 = 6 << TRANSFER_SHIFT,
 
     /*
      * SMPTE ST 2084
@@ -753,7 +791,7 @@
      *          L = 1 corresponds to 10000 cd/m2
      *      E - corresponding electrical signal
      */
-    TRANSFER_ST2084 = 6 << TRANSFER_SHIFT,
+    TRANSFER_ST2084 = 7 << TRANSFER_SHIFT,
 
     /*
      * ARIB STD-B67 Hybrid Log Gamma
@@ -769,7 +807,7 @@
      *          to reference white level of 100 cd/m2
      *      E - corresponding electrical signal
      */
-    TRANSFER_HLG = 7 << TRANSFER_SHIFT,
+    TRANSFER_HLG = 8 << TRANSFER_SHIFT,
 
     RANGE_SHIFT = 27,
 
@@ -816,6 +854,15 @@
     RANGE_LIMITED = 2 << RANGE_SHIFT,
 
     /*
+     * Extended range is used for scRGB. Intended for use with
+     * floating point pixel formats. [0.0 - 1.0] is the standard
+     * sRGB space. Values outside the range 0.0 - 1.0 can encode
+     * color outside the sRGB gamut.
+     * Used to blend / merge multiple dataspaces on a single display.
+     */
+    RANGE_EXTENDED = 3 << RANGE_SHIFT,
+
+    /*
      * Legacy dataspaces
      */
 
@@ -835,6 +882,21 @@
 
 
     /*
+     * scRGB linear encoding:
+     *
+     * The red, green, and blue components are stored in extended sRGB space,
+     * but are linear, not gamma-encoded.
+     * The RGB primaries and the white point are the same as BT.709.
+     *
+     * The values are floating point.
+     * A pixel value of 1.0, 1.0, 1.0 corresponds to sRGB white (D65) at 80 nits.
+     * Values beyond the range [0.0 - 1.0] would correspond to other colors
+     * spaces and/or HDR content.
+     */
+    V0_SCRGB_LINEAR = STANDARD_BT709 | TRANSFER_LINEAR | RANGE_EXTENDED,
+
+
+    /*
      * sRGB gamma encoding:
      *
      * The red, green and blue components are stored in sRGB space, and
@@ -853,6 +915,24 @@
 
 
     /*
+     * scRGB:
+     *
+     * The red, green, and blue components are stored in extended sRGB space,
+     * but are linear, not gamma-encoded.
+     * The RGB primaries and the white point are the same as BT.709.
+     *
+     * The values are floating point.
+     * A pixel value of 1.0, 1.0, 1.0 corresponds to sRGB white (D65) at 80 nits.
+     * Values beyond the range [0.0 - 1.0] would correspond to other colors
+     * spaces and/or HDR content.
+     *
+     * TODO (courtneygo): Will we actually use this? We intend to use FP16
+     * storage for data using scRGB so we can do all work in linear space
+     * and don't have to worry as much about limited precision.
+     */
+    V0_SCRGB = STANDARD_BT709 | TRANSFER_SRGB | RANGE_EXTENDED,
+
+    /*
      * YCbCr Colorspaces
      * -----------------
      *
@@ -908,6 +988,59 @@
 
     V0_BT709 = STANDARD_BT709 | TRANSFER_SMPTE_170M | RANGE_LIMITED,
 
+
+    /*
+     * SMPTE EG 432-1 and SMPTE RP 431-2.
+     *
+     * Digital Cinema DCI-P3
+     *
+     * Use full range, linear transfer and D65 DCI-P3 standard
+     */
+    DCI_P3_LINEAR = STANDARD_DCI_P3 | TRANSFER_LINEAR | RANGE_FULL,
+
+
+    /*
+     * SMPTE EG 432-1 and SMPTE RP 431-2.
+     *
+     * Digital Cinema DCI-P3
+     *
+     * Use full range, gamma 2.6 transfer and D65 DCI-P3 standard
+     * Note: Application is responsible for gamma encoding the data as
+     * a 2.6 gamma encoding is not supported in HW.
+     */
+    DCI_P3 = STANDARD_DCI_P3 | TRANSFER_GAMMA2_6 | RANGE_FULL,
+
+
+    /*
+     * Adobe RGB
+     *
+     * Use full range, gamma 2.2 transfer and Adobe RGB primaries
+     * Note: Application is responsible for gamma encoding the data as
+     * a 2.2 gamma encoding is not supported in HW.
+     */
+    ADOBE_RGB = STANDARD_ADOBE_RGB | TRANSFER_GAMMA2_2 | RANGE_FULL,
+
+
+    /*
+     * ITU-R Recommendation 2020 (BT.2020)
+     *
+     * Ultra High-definition television
+     *
+     * Use full range, linear transfer and BT2020 standard
+     */
+    BT2020_LINEAR = STANDARD_BT2020 | TRANSFER_LINEAR | RANGE_FULL,
+
+
+    /*
+     * ITU-R Recommendation 2020 (BT.2020)
+     *
+     * Ultra High-definition television
+     *
+     * Use full range, BT.709 transfer and BT2020 standard
+     */
+    BT2020 = STANDARD_BT2020 | TRANSFER_SMPTE_170M | RANGE_FULL,
+
+
     /*
      * Data spaces for non-color formats
      */
diff --git a/graphics/composer/2.1/Android.bp b/graphics/composer/2.1/Android.bp
index fa58dbb..106a821 100644
--- a/graphics/composer/2.1/Android.bp
+++ b/graphics/composer/2.1/Android.bp
@@ -46,16 +46,18 @@
     generated_headers: ["android.hardware.graphics.composer@2.1_genc++_headers"],
     export_generated_headers: ["android.hardware.graphics.composer@2.1_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
-        "android.hardware.graphics.allocator@2.0",
+        "android.hardware.graphics.common@1.0",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
-        "android.hardware.graphics.allocator@2.0",
+        "android.hardware.graphics.common@1.0",
     ],
 }
diff --git a/graphics/composer/2.1/IComposer.hal b/graphics/composer/2.1/IComposer.hal
index 7bfa22b..dd61c11 100644
--- a/graphics/composer/2.1/IComposer.hal
+++ b/graphics/composer/2.1/IComposer.hal
@@ -16,7 +16,7 @@
 
 package android.hardware.graphics.composer@2.1;
 
-import android.hardware.graphics.allocator@2.0::PixelFormat;
+import android.hardware.graphics.common@1.0;
 import IComposerCallback;
 
 interface IComposer {
@@ -845,7 +845,7 @@
      */
 
     /*
-     * Asynchonously sets the position of a cursor layer.
+     * Asynchronously sets the position of a cursor layer.
      *
      * Prior to validateDisplay, a layer may be marked as Composition::CURSOR.
      * If validation succeeds (i.e., the device does not request a composition
diff --git a/graphics/composer/2.1/default/Android.bp b/graphics/composer/2.1/default/Android.bp
index 6936347..22f4906 100644
--- a/graphics/composer/2.1/default/Android.bp
+++ b/graphics/composer/2.1/default/Android.bp
@@ -8,7 +8,8 @@
         "libbase",
         "libcutils",
         "libhardware",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "liblog",
         "libutils",
@@ -29,7 +30,8 @@
         "libbinder",
         "libcutils",
         "libhardware",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "liblog",
         "libutils",
diff --git a/graphics/composer/2.1/default/Hwc.cpp b/graphics/composer/2.1/default/Hwc.cpp
index d45a955..7fa5119 100644
--- a/graphics/composer/2.1/default/Hwc.cpp
+++ b/graphics/composer/2.1/default/Hwc.cpp
@@ -37,7 +37,12 @@
 namespace V2_1 {
 namespace implementation {
 
-using android::hardware::graphics::allocator::V2_0::PixelFormat;
+using android::hardware::graphics::common::V1_0::PixelFormat;
+using android::hardware::graphics::common::V1_0::Transform;
+using android::hardware::graphics::common::V1_0::Dataspace;
+using android::hardware::graphics::common::V1_0::ColorMode;
+using android::hardware::graphics::common::V1_0::ColorTransform;
+using android::hardware::graphics::common::V1_0::Hdr;
 
 namespace {
 
diff --git a/graphics/composer/2.1/types.hal b/graphics/composer/2.1/types.hal
index 3c591b3..9c2e1d7 100644
--- a/graphics/composer/2.1/types.hal
+++ b/graphics/composer/2.1/types.hal
@@ -32,132 +32,3 @@
 typedef uint32_t Config;
 typedef uint64_t Display;
 typedef uint64_t Layer;
-
-/*
- * Copied from android_transform_t
- *
- * TODO(olv) copy comments over and generate android_transform_t
- */
-enum Transform : int32_t {
-    FLIP_H    = 0x1,
-    FLIP_V    = 0x2,
-    ROT_90    = 0x4,
-    ROT_180   = 0x3,
-    ROT_270   = 0x7,
-    RESERVED  = 0x8,
-};
-
-/*
- * Copied from android_color_mode_t
- *
- * TODO(olv) copy comments over and generate android_color_mode_t
- */
-enum ColorMode : int32_t {
-  NATIVE                        = 0,
-  STANDARD_BT601_625            = 1,
-  STANDARD_BT601_625_UNADJUSTED = 2,
-  STANDARD_BT601_525            = 3,
-  STANDARD_BT601_525_UNADJUSTED = 4,
-  STANDARD_BT709                = 5,
-  DCI_P3                        = 6,
-  SRGB                          = 7,
-  ADOBE_RGB                     = 8,
-};
-
-/*
- * Copied from android_color_transform_t
- *
- * TODO(olv) copy comments over and generate android_color_transform_t
- */
-enum ColorTransform : int32_t {
-    IDENTITY             = 0,
-    ARBITRARY_MATRIX     = 1,
-    VALUE_INVERSE        = 2,
-    GRAYSCALE            = 3,
-    CORRECT_PROTANOPIA   = 4,
-    CORRECT_DEUTERANOPIA = 5,
-    CORRECT_TRITANOPIA   = 6
-};
-
-/*
- * Copied from android_dataspace_t
- *
- * TODO(olv) copy comments over and generate android_dataspace_t
- */
-enum Dataspace : int32_t {
-    UNKNOWN                            = 0x0,
-    ARBITRARY                          = 0x1,
-
-    STANDARD_SHIFT                     = 16,
-    STANDARD_MASK                      = 63 << STANDARD_SHIFT,
-    STANDARD_UNSPECIFIED               = 0 << STANDARD_SHIFT,
-    STANDARD_BT709                     = 1 << STANDARD_SHIFT,
-    STANDARD_BT601_625                 = 2 << STANDARD_SHIFT,
-    STANDARD_BT601_625_UNADJUSTED      = 3 << STANDARD_SHIFT,
-    STANDARD_BT601_525                 = 4 << STANDARD_SHIFT,
-    STANDARD_BT601_525_UNADJUSTED      = 5 << STANDARD_SHIFT,
-    STANDARD_BT2020                    = 6 << STANDARD_SHIFT,
-    STANDARD_BT2020_CONSTANT_LUMINANCE = 7 << STANDARD_SHIFT,
-    STANDARD_BT470M                    = 8 << STANDARD_SHIFT,
-    STANDARD_FILM                      = 9 << STANDARD_SHIFT,
-
-    TRANSFER_SHIFT                     = 22,
-    TRANSFER_MASK                      = 31 << TRANSFER_SHIFT,
-    TRANSFER_UNSPECIFIED               = 0 << TRANSFER_SHIFT,
-    TRANSFER_LINEAR                    = 1 << TRANSFER_SHIFT,
-    TRANSFER_SRGB                      = 2 << TRANSFER_SHIFT,
-    TRANSFER_SMPTE_170M                = 3 << TRANSFER_SHIFT,
-    TRANSFER_GAMMA2_2                  = 4 << TRANSFER_SHIFT,
-    TRANSFER_GAMMA2_8                  = 5 << TRANSFER_SHIFT,
-    TRANSFER_ST2084                    = 6 << TRANSFER_SHIFT,
-    TRANSFER_HLG                       = 7 << TRANSFER_SHIFT,
-
-    RANGE_SHIFT                        = 27,
-    RANGE_MASK                         = 7 << RANGE_SHIFT,
-    RANGE_UNSPECIFIED                  = 0 << RANGE_SHIFT,
-    RANGE_FULL                         = 1 << RANGE_SHIFT,
-    RANGE_LIMITED                      = 2 << RANGE_SHIFT,
-
-    SRGB_LINEAR                        = 0x200,
-    V0_SRGB_LINEAR                     = STANDARD_BT709 |
-                                         TRANSFER_LINEAR |
-                                         RANGE_FULL,
-
-    SRGB                               = 0x201,
-    V0_SRGB                            = STANDARD_BT709 |
-                                         TRANSFER_SRGB |
-                                         RANGE_FULL,
-
-    JFIF                               = 0x101,
-    V0_JFIF                            = STANDARD_BT601_625 |
-                                         TRANSFER_SMPTE_170M |
-                                         RANGE_FULL,
-
-    BT601_625                          = 0x102,
-    V0_BT601_625                       = STANDARD_BT601_625 |
-                                         TRANSFER_SMPTE_170M |
-                                         RANGE_LIMITED,
-
-    BT601_525                          = 0x103,
-    V0_BT601_525                       = STANDARD_BT601_525 |
-                                         TRANSFER_SMPTE_170M |
-                                         RANGE_LIMITED,
-
-    BT709                              = 0x104,
-    V0_BT709                           = STANDARD_BT709 |
-                                         TRANSFER_SMPTE_170M |
-                                         RANGE_LIMITED,
-
-    DEPTH                              = 0x1000,
-};
-
-/*
- * Copied from android_hdr_t
- *
- * TODO(olv) copy comments over and generate android_hdr_t
- */
-enum Hdr : int32_t {
-    DOLBY_VISION = 1,
-    HDR10        = 2,
-    HLG          = 3,
-};
diff --git a/graphics/mapper/2.0/default/Android.bp b/graphics/mapper/2.0/default/Android.bp
index b738ae8..7da6eb1 100644
--- a/graphics/mapper/2.0/default/Android.bp
+++ b/graphics/mapper/2.0/default/Android.bp
@@ -21,7 +21,8 @@
     shared_libs: [
         "android.hardware.graphics.allocator@2.0",
         "libhardware",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "liblog",
     ],
diff --git a/graphics/mapper/2.0/default/GrallocMapper.cpp b/graphics/mapper/2.0/default/GrallocMapper.cpp
index eeca5c7..2af1d2c 100644
--- a/graphics/mapper/2.0/default/GrallocMapper.cpp
+++ b/graphics/mapper/2.0/default/GrallocMapper.cpp
@@ -15,10 +15,13 @@
 
 #define LOG_TAG "GrallocMapperPassthrough"
 
+#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
 #include <android/hardware/graphics/mapper/2.0/IMapper.h>
 #include <hardware/gralloc1.h>
 #include <log/log.h>
 
+#include <unordered_set>
+
 namespace android {
 namespace hardware {
 namespace graphics {
@@ -26,6 +29,8 @@
 namespace V2_0 {
 namespace implementation {
 
+using Capability = allocator::V2_0::IAllocator::Capability;
+
 class GrallocDevice : public Device {
 public:
     GrallocDevice();
@@ -38,6 +43,8 @@
             uint32_t* outWidth, uint32_t* outHeight);
     Error getFormat(const native_handle_t* bufferHandle,
             PixelFormat* outFormat);
+    Error getLayerCount(const native_handle_t* bufferHandle,
+            uint32_t* outLayerCount);
     Error getProducerUsageMask(const native_handle_t* bufferHandle,
             uint64_t* outUsageMask);
     Error getConsumerUsageMask(const native_handle_t* bufferHandle,
@@ -58,15 +65,21 @@
             int32_t* outReleaseFence);
 
 private:
+    void initCapabilities();
+
     void initDispatch();
+    bool hasCapability(Capability capability) const;
 
     gralloc1_device_t* mDevice;
 
+    std::unordered_set<Capability> mCapabilities;
+
     struct {
         GRALLOC1_PFN_RETAIN retain;
         GRALLOC1_PFN_RELEASE release;
         GRALLOC1_PFN_GET_DIMENSIONS getDimensions;
         GRALLOC1_PFN_GET_FORMAT getFormat;
+        GRALLOC1_PFN_GET_LAYER_COUNT getLayerCount;
         GRALLOC1_PFN_GET_PRODUCER_USAGE getProducerUsage;
         GRALLOC1_PFN_GET_CONSUMER_USAGE getConsumerUsage;
         GRALLOC1_PFN_GET_BACKING_STORE getBackingStore;
@@ -96,6 +109,7 @@
         LOG_ALWAYS_FATAL("failed to open gralloc1 device");
     }
 
+    initCapabilities();
     initDispatch();
 }
 
@@ -104,6 +118,19 @@
     gralloc1_close(mDevice);
 }
 
+void GrallocDevice::initCapabilities()
+{
+    uint32_t count;
+    mDevice->getCapabilities(mDevice, &count, nullptr);
+
+    std::vector<Capability> caps(count);
+    mDevice->getCapabilities(mDevice, &count, reinterpret_cast<
+              std::underlying_type<Capability>::type*>(caps.data()));
+    caps.resize(count);
+
+    mCapabilities.insert(caps.cbegin(), caps.cend());
+}
+
 void GrallocDevice::initDispatch()
 {
 #define CHECK_FUNC(func, desc) do {                                   \
@@ -118,6 +145,9 @@
     CHECK_FUNC(release, GRALLOC1_FUNCTION_RELEASE);
     CHECK_FUNC(getDimensions, GRALLOC1_FUNCTION_GET_DIMENSIONS);
     CHECK_FUNC(getFormat, GRALLOC1_FUNCTION_GET_FORMAT);
+    if (hasCapability(Capability::LAYERED_BUFFERS)) {
+        CHECK_FUNC(getLayerCount, GRALLOC1_FUNCTION_GET_LAYER_COUNT);
+    }
     CHECK_FUNC(getProducerUsage, GRALLOC1_FUNCTION_GET_PRODUCER_USAGE);
     CHECK_FUNC(getConsumerUsage, GRALLOC1_FUNCTION_GET_CONSUMER_USAGE);
     CHECK_FUNC(getBackingStore, GRALLOC1_FUNCTION_GET_BACKING_STORE);
@@ -130,6 +160,11 @@
 #undef CHECK_FUNC
 }
 
+bool GrallocDevice::hasCapability(Capability capability) const
+{
+    return (mCapabilities.count(capability) > 0);
+}
+
 Error GrallocDevice::retain(const native_handle_t* bufferHandle)
 {
     int32_t error = mDispatch.retain(mDevice, bufferHandle);
@@ -158,6 +193,19 @@
     return static_cast<Error>(error);
 }
 
+Error GrallocDevice::getLayerCount(const native_handle_t* bufferHandle,
+        uint32_t* outLayerCount)
+{
+    if (hasCapability(Capability::LAYERED_BUFFERS)) {
+        int32_t error = mDispatch.getLayerCount(mDevice, bufferHandle,
+                outLayerCount);
+        return static_cast<Error>(error);
+    } else {
+        *outLayerCount = 1;
+        return Error::NONE;
+    }
+}
+
 Error GrallocDevice::getProducerUsageMask(const native_handle_t* bufferHandle,
         uint64_t* outUsageMask)
 {
@@ -238,6 +286,7 @@
         .release = release,
         .getDimensions = getDimensions,
         .getFormat = getFormat,
+        .getLayerCount = getLayerCount,
         .getProducerUsageMask = getProducerUsageMask,
         .getConsumerUsageMask = getConsumerUsageMask,
         .getBackingStore = getBackingStore,
@@ -296,6 +345,12 @@
         return cast(device)->getFormat(bufferHandle, outFormat);
     }
 
+    static Error getLayerCount(Device* device,
+            const native_handle_t* bufferHandle, uint32_t* outLayerCount)
+    {
+        return cast(device)->getLayerCount(bufferHandle, outLayerCount);
+    }
+
     static Error getProducerUsageMask(Device* device,
             const native_handle_t* bufferHandle, uint64_t* outUsageMask)
     {
diff --git a/graphics/mapper/2.0/include/android/hardware/graphics/mapper/2.0/IMapper.h b/graphics/mapper/2.0/include/android/hardware/graphics/mapper/2.0/IMapper.h
index 23faa80..ac8ec45 100644
--- a/graphics/mapper/2.0/include/android/hardware/graphics/mapper/2.0/IMapper.h
+++ b/graphics/mapper/2.0/include/android/hardware/graphics/mapper/2.0/IMapper.h
@@ -128,6 +128,21 @@
                                PixelFormat* outFormat);
 
     /*
+     * Gets the number of layers of the buffer.
+     *
+     * See IAllocator::BufferDescriptorInfo for more information.
+     *
+     * @param device is the mapper device.
+     * @param bufferHandle is the buffer from which to get format.
+     * @return error is NONE upon success. Otherwise,
+     *                  BAD_BUFFER when the buffer handle is invalid.
+     * @return layerCount is the number of layers of the buffer.
+     */
+    typedef Error (*getLayerCount)(Device* device,
+                               const native_handle_t* bufferHandle,
+                               uint32_t* outLayerCount);
+
+    /*
      * Gets the producer usage flags which were used to allocate this buffer.
      *
      * See IAllocator::BufferDescriptorInfo for more information.
@@ -364,6 +379,7 @@
     Device::release release;
     Device::getDimensions getDimensions;
     Device::getFormat getFormat;
+    Device::getLayerCount getLayerCount;
     Device::getProducerUsageMask getProducerUsageMask;
     Device::getConsumerUsageMask getConsumerUsageMask;
     Device::getBackingStore getBackingStore;
diff --git a/graphics/mapper/2.0/include/android/hardware/graphics/mapper/2.0/types.h b/graphics/mapper/2.0/include/android/hardware/graphics/mapper/2.0/types.h
index 63a6b16..4054b82 100644
--- a/graphics/mapper/2.0/include/android/hardware/graphics/mapper/2.0/types.h
+++ b/graphics/mapper/2.0/include/android/hardware/graphics/mapper/2.0/types.h
@@ -20,6 +20,7 @@
 #include <type_traits>
 
 #include <android/hardware/graphics/allocator/2.0/types.h>
+#include <android/hardware/graphics/common/1.0/types.h>
 
 namespace android {
 namespace hardware {
@@ -28,9 +29,9 @@
 namespace V2_0 {
 
 using android::hardware::graphics::allocator::V2_0::Error;
-using android::hardware::graphics::allocator::V2_0::PixelFormat;
 using android::hardware::graphics::allocator::V2_0::ProducerUsage;
 using android::hardware::graphics::allocator::V2_0::ConsumerUsage;
+using android::hardware::graphics::common::V1_0::PixelFormat;
 
 /*
  * Structures for describing flexible YUVA/RGBA formats for consumption by
diff --git a/health/1.0/Android.bp b/health/1.0/Android.bp
index fb3d8c0..81793d5 100644
--- a/health/1.0/Android.bp
+++ b/health/1.0/Android.bp
@@ -38,13 +38,15 @@
     generated_headers: ["android.hardware.health@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.health@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/health/1.0/default/Android.mk b/health/1.0/default/Android.mk
index 3d9d58a..89d28cb 100644
--- a/health/1.0/default/Android.mk
+++ b/health/1.0/default/Android.mk
@@ -9,7 +9,8 @@
 
 LOCAL_SHARED_LIBRARIES := \
     libcutils \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     liblog \
     libutils \
@@ -28,7 +29,8 @@
 LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
 LOCAL_SHARED_LIBRARIES := \
     libcutils \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libutils \
     android.hardware.health@1.0 \
 
@@ -48,7 +50,8 @@
     libbase \
     libutils \
     libhwbinder \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     android.hardware.health@1.0 \
 
 include $(BUILD_EXECUTABLE)
diff --git a/light/2.0/Android.bp b/light/2.0/Android.bp
index b762cc1..23c7c9c 100644
--- a/light/2.0/Android.bp
+++ b/light/2.0/Android.bp
@@ -38,13 +38,15 @@
     generated_headers: ["android.hardware.light@2.0_genc++_headers"],
     export_generated_headers: ["android.hardware.light@2.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/light/2.0/default/Android.mk b/light/2.0/default/Android.mk
index 61f4cc9..d14d7c0 100644
--- a/light/2.0/default/Android.mk
+++ b/light/2.0/default/Android.mk
@@ -7,7 +7,8 @@
     Light.cpp \
 
 LOCAL_SHARED_LIBRARIES := \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     libutils \
     liblog \
@@ -37,7 +38,8 @@
 
 LOCAL_SHARED_LIBRARIES += \
     libhwbinder \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     android.hardware.light@2.0 \
 
 include $(BUILD_EXECUTABLE)
diff --git a/light/2.0/vts/Android.mk b/light/2.0/vts/Android.mk
new file mode 100644
index 0000000..59e8f35
--- /dev/null
+++ b/light/2.0/vts/Android.mk
@@ -0,0 +1,47 @@
+#
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+# build VTS driver for Light v2.0.
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libvts_driver_hidl_light@2.0
+
+LOCAL_SRC_FILES := \
+    Light.vts \
+    types.vts \
+
+LOCAL_SHARED_LIBRARIES += \
+    android.hardware.light@2.0 \
+    libbase \
+    libutils \
+    libcutils \
+    liblog \
+    libhidlbase \
+    libhidltransport \
+    libhwbinder \
+    libprotobuf-cpp-full \
+    libvts_common \
+    libvts_datatype \
+    libvts_measurement \
+    libvts_multidevice_proto
+
+LOCAL_PROTOC_OPTIMIZE_TYPE := full
+
+LOCAL_MULTILIB := both
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/light/2.0/vts/Light.vts b/light/2.0/vts/Light.vts
new file mode 100644
index 0000000..5d49822
--- /dev/null
+++ b/light/2.0/vts/Light.vts
@@ -0,0 +1,37 @@
+component_class: HAL_HIDL
+component_type_version: 2.0
+component_name: "ILight"
+
+package: "android.hardware.light"
+
+import: "android.hardware.light@2.0::types"
+
+interface: {
+    api: {
+        name: "setLight"
+        return_type_hidl: {
+            type: TYPE_ENUM
+            predefined_type: "::android::hardware::light::V2_0::Status"
+        }
+        arg: {
+            type: TYPE_ENUM
+            predefined_type: "::android::hardware::light::V2_0::Type"
+        }
+        arg: {
+            type: TYPE_STRUCT
+            predefined_type: "::android::hardware::light::V2_0::LightState"
+        }
+    }
+
+    api: {
+        name: "getSupportedTypes"
+        return_type_hidl: {
+            type: TYPE_VECTOR
+            vector_value: {
+                type: TYPE_ENUM
+                predefined_type: "::android::hardware::light::V2_0::Type"
+            }
+        }
+    }
+
+}
diff --git a/light/2.0/vts/types.vts b/light/2.0/vts/types.vts
new file mode 100644
index 0000000..a9c8cab
--- /dev/null
+++ b/light/2.0/vts/types.vts
@@ -0,0 +1,149 @@
+component_class: HAL_HIDL
+component_type_version: 2.0
+component_name: "types"
+
+package: "android.hardware.light"
+
+
+attribute: {
+    name: "::android::hardware::light::V2_0::Status"
+    type: TYPE_ENUM
+    enum_value: {
+        scalar_type: "int32_t"
+
+        enumerator: "SUCCESS"
+        scalar_value: {
+            int32_t: 0
+        }
+        enumerator: "LIGHT_NOT_SUPPORTED"
+        scalar_value: {
+            int32_t: 1
+        }
+        enumerator: "BRIGHTNESS_NOT_SUPPORTED"
+        scalar_value: {
+            int32_t: 2
+        }
+        enumerator: "UNKNOWN"
+        scalar_value: {
+            int32_t: 3
+        }
+    }
+}
+
+attribute: {
+    name: "::android::hardware::light::V2_0::Flash"
+    type: TYPE_ENUM
+    enum_value: {
+        scalar_type: "int32_t"
+
+        enumerator: "NONE"
+        scalar_value: {
+            int32_t: 0
+        }
+        enumerator: "TIMED"
+        scalar_value: {
+            int32_t: 1
+        }
+        enumerator: "HARDWARE"
+        scalar_value: {
+            int32_t: 2
+        }
+    }
+}
+
+attribute: {
+    name: "::android::hardware::light::V2_0::Brightness"
+    type: TYPE_ENUM
+    enum_value: {
+        scalar_type: "int32_t"
+
+        enumerator: "USER"
+        scalar_value: {
+            int32_t: 0
+        }
+        enumerator: "SENSOR"
+        scalar_value: {
+            int32_t: 1
+        }
+        enumerator: "LOW_PERSISTENCE"
+        scalar_value: {
+            int32_t: 2
+        }
+    }
+}
+
+attribute: {
+    name: "::android::hardware::light::V2_0::Type"
+    type: TYPE_ENUM
+    enum_value: {
+        scalar_type: "int32_t"
+
+        enumerator: "BACKLIGHT"
+        scalar_value: {
+            int32_t: 0
+        }
+        enumerator: "KEYBOARD"
+        scalar_value: {
+            int32_t: 1
+        }
+        enumerator: "BUTTONS"
+        scalar_value: {
+            int32_t: 2
+        }
+        enumerator: "BATTERY"
+        scalar_value: {
+            int32_t: 3
+        }
+        enumerator: "NOTIFICATIONS"
+        scalar_value: {
+            int32_t: 4
+        }
+        enumerator: "ATTENTION"
+        scalar_value: {
+            int32_t: 5
+        }
+        enumerator: "BLUETOOTH"
+        scalar_value: {
+            int32_t: 6
+        }
+        enumerator: "WIFI"
+        scalar_value: {
+            int32_t: 7
+        }
+        enumerator: "COUNT"
+        scalar_value: {
+            int32_t: 8
+        }
+    }
+}
+
+attribute: {
+    name: "::android::hardware::light::V2_0::LightState"
+    type: TYPE_STRUCT
+    struct_value: {
+        name: "color"
+        type: TYPE_SCALAR
+        scalar_type: "uint32_t"
+    }
+    struct_value: {
+        name: "flashMode"
+        type: TYPE_ENUM
+        predefined_type: "::android::hardware::light::V2_0::Flash"
+    }
+    struct_value: {
+        name: "flashOnMs"
+        type: TYPE_SCALAR
+        scalar_type: "int32_t"
+    }
+    struct_value: {
+        name: "flashOffMs"
+        type: TYPE_SCALAR
+        scalar_type: "int32_t"
+    }
+    struct_value: {
+        name: "brightnessMode"
+        type: TYPE_ENUM
+        predefined_type: "::android::hardware::light::V2_0::Brightness"
+    }
+}
+
diff --git a/media/1.0/Android.bp b/media/1.0/Android.bp
new file mode 100644
index 0000000..5a63cac
--- /dev/null
+++ b/media/1.0/Android.bp
@@ -0,0 +1,47 @@
+// This file is autogenerated by hidl-gen. Do not edit manually.
+
+genrule {
+    name: "android.hardware.media@1.0_genc++",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces android.hardware.media@1.0",
+    srcs: [
+        "types.hal",
+    ],
+    out: [
+        "android/hardware/media/1.0/types.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.media@1.0_genc++_headers",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces android.hardware.media@1.0",
+    srcs: [
+        "types.hal",
+    ],
+    out: [
+        "android/hardware/media/1.0/types.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.media@1.0",
+    generated_sources: ["android.hardware.media@1.0_genc++"],
+    generated_headers: ["android.hardware.media@1.0_genc++_headers"],
+    export_generated_headers: ["android.hardware.media@1.0_genc++_headers"],
+    shared_libs: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "libcutils",
+        "android.hardware.graphics.common@1.0",
+    ],
+    export_shared_lib_headers: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "android.hardware.graphics.common@1.0",
+    ],
+}
diff --git a/media/1.0/types.hal b/media/1.0/types.hal
new file mode 100644
index 0000000..25931f8
--- /dev/null
+++ b/media/1.0/types.hal
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.media@1.0;
+
+import android.hardware.graphics.common@1.0::PixelFormat;
+
+/**
+ * Aliases
+ */
+typedef handle FileDescriptor; // This must have no more than one fd.
+typedef FileDescriptor Fence;
+typedef int32_t Status; // TODO: convert to an enum
+typedef vec<uint8_t> Bytes;
+
+/**
+ * Ref: frameworks/native/include/ui/GraphicBuffer.h
+ * Ref: system/core/include/system/window.h
+ */
+
+/**
+ * This struct contains attributes for a gralloc buffer that can be put into a
+ * union.
+ */
+struct GraphicBufferAttributes {
+    uint32_t width;
+    uint32_t height;
+    uint32_t stride;
+    PixelFormat format;
+    uint32_t usage; // TODO: convert to an enum
+    uint32_t generationNumber;
+};
+
+/**
+ * A GraphicBuffer is simply GraphicBufferAttributes plus a native handle.
+ */
+struct GraphicBuffer {
+    handle nativeHandle;
+    GraphicBufferAttributes attr;
+};
+
+/**
+ * Ref: frameworks/native/include/binder/IMemory.h
+ * Ref: frameworks/native/libs/binder/IMemory.cpp
+ */
+
+/**
+ * This struct contains attributes for a shared memory buffer that can be put
+ * into a union.
+ */
+struct SharedMemoryAttributes {
+    uint32_t size;
+    uint32_t flags; // TODO: convert to an enum
+    uint32_t offset;
+};
+
+/**
+ * A SharedMemory is simply SharedMemoryAttributes plus a native handle.
+ */
+struct SharedMemory {
+    handle nativeHandle;
+    SharedMemoryAttributes attr;
+};
+
diff --git a/media/Android.bp b/media/Android.bp
new file mode 100644
index 0000000..f2abc67
--- /dev/null
+++ b/media/Android.bp
@@ -0,0 +1,5 @@
+// This is an autogenerated file, do not edit.
+subdirs = [
+    "1.0",
+    "omx/1.0",
+]
diff --git a/media/omx/1.0/Android.bp b/media/omx/1.0/Android.bp
new file mode 100644
index 0000000..b8afb98
--- /dev/null
+++ b/media/omx/1.0/Android.bp
@@ -0,0 +1,89 @@
+// This file is autogenerated by hidl-gen. Do not edit manually.
+
+genrule {
+    name: "android.hardware.media.omx@1.0_genc++",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces android.hardware.media.omx@1.0",
+    srcs: [
+        "types.hal",
+        "IGraphicBufferSource.hal",
+        "IOmx.hal",
+        "IOmxBufferSource.hal",
+        "IOmxNode.hal",
+        "IOmxObserver.hal",
+    ],
+    out: [
+        "android/hardware/media/omx/1.0/types.cpp",
+        "android/hardware/media/omx/1.0/GraphicBufferSourceAll.cpp",
+        "android/hardware/media/omx/1.0/OmxAll.cpp",
+        "android/hardware/media/omx/1.0/OmxBufferSourceAll.cpp",
+        "android/hardware/media/omx/1.0/OmxNodeAll.cpp",
+        "android/hardware/media/omx/1.0/OmxObserverAll.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.media.omx@1.0_genc++_headers",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces android.hardware.media.omx@1.0",
+    srcs: [
+        "types.hal",
+        "IGraphicBufferSource.hal",
+        "IOmx.hal",
+        "IOmxBufferSource.hal",
+        "IOmxNode.hal",
+        "IOmxObserver.hal",
+    ],
+    out: [
+        "android/hardware/media/omx/1.0/types.h",
+        "android/hardware/media/omx/1.0/IGraphicBufferSource.h",
+        "android/hardware/media/omx/1.0/IHwGraphicBufferSource.h",
+        "android/hardware/media/omx/1.0/BnGraphicBufferSource.h",
+        "android/hardware/media/omx/1.0/BpGraphicBufferSource.h",
+        "android/hardware/media/omx/1.0/BsGraphicBufferSource.h",
+        "android/hardware/media/omx/1.0/IOmx.h",
+        "android/hardware/media/omx/1.0/IHwOmx.h",
+        "android/hardware/media/omx/1.0/BnOmx.h",
+        "android/hardware/media/omx/1.0/BpOmx.h",
+        "android/hardware/media/omx/1.0/BsOmx.h",
+        "android/hardware/media/omx/1.0/IOmxBufferSource.h",
+        "android/hardware/media/omx/1.0/IHwOmxBufferSource.h",
+        "android/hardware/media/omx/1.0/BnOmxBufferSource.h",
+        "android/hardware/media/omx/1.0/BpOmxBufferSource.h",
+        "android/hardware/media/omx/1.0/BsOmxBufferSource.h",
+        "android/hardware/media/omx/1.0/IOmxNode.h",
+        "android/hardware/media/omx/1.0/IHwOmxNode.h",
+        "android/hardware/media/omx/1.0/BnOmxNode.h",
+        "android/hardware/media/omx/1.0/BpOmxNode.h",
+        "android/hardware/media/omx/1.0/BsOmxNode.h",
+        "android/hardware/media/omx/1.0/IOmxObserver.h",
+        "android/hardware/media/omx/1.0/IHwOmxObserver.h",
+        "android/hardware/media/omx/1.0/BnOmxObserver.h",
+        "android/hardware/media/omx/1.0/BpOmxObserver.h",
+        "android/hardware/media/omx/1.0/BsOmxObserver.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.media.omx@1.0",
+    generated_sources: ["android.hardware.media.omx@1.0_genc++"],
+    generated_headers: ["android.hardware.media.omx@1.0_genc++_headers"],
+    export_generated_headers: ["android.hardware.media.omx@1.0_genc++_headers"],
+    shared_libs: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "libcutils",
+        "android.hardware.graphics.common@1.0",
+        "android.hardware.media@1.0",
+    ],
+    export_shared_lib_headers: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "android.hardware.graphics.common@1.0",
+        "android.hardware.media@1.0",
+    ],
+}
diff --git a/media/omx/1.0/IGraphicBufferSource.hal b/media/omx/1.0/IGraphicBufferSource.hal
new file mode 100644
index 0000000..bee57ac
--- /dev/null
+++ b/media/omx/1.0/IGraphicBufferSource.hal
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.media.omx@1.0;
+
+import android.hardware.graphics.common@1.0::Dataspace;
+
+import android.hardware.media@1.0::types;
+
+import IOmxNode;
+
+/**
+ * Ref: frameworks/av/media/libmedia/aidl/android/IGraphicBufferSource.aidl
+ *
+ * TODO: Add documentations.
+ */
+interface IGraphicBufferSource {
+
+    configure(IOmxNode omxNode, Dataspace dataspace)
+        generates (Status status);
+
+    setSuspend(bool suspend)
+        generates (Status status);
+
+    setRepeatPreviousFrameDelayUs(int64_t repeatAfterUs)
+        generates (Status status);
+
+    setMaxFps(float maxFps)
+        generates (Status status);
+
+    setTimeLapseConfig(int64_t timePerFrameUs, int64_t timePerCaptureUs)
+        generates (Status status);
+
+    setStartTimeUs(int64_t startTimeUs)
+        generates (Status status);
+
+    setColorAspects(uint32_t aspects) // TODO: Maybe break down aspects.
+        generates (Status status);
+
+    setTimeOffsetUs(int64_t timeOffsetUs)
+        generates (Status status);
+
+    signalEndOfInputStream()
+        generates (Status status);
+
+};
+
diff --git a/media/omx/1.0/IOmx.hal b/media/omx/1.0/IOmx.hal
new file mode 100644
index 0000000..e9f0b76
--- /dev/null
+++ b/media/omx/1.0/IOmx.hal
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.media.omx@1.0;
+
+import android.hardware.media@1.0::types;
+
+import IOmxNode;
+import IOmxObserver;
+
+/**
+ * Ref: frameworks/av/include/media/IOMX.h: IOMX
+ *
+ * IOmx is the main entry point for communicating with OMX components.
+ */
+interface IOmx {
+
+    /**
+     * Information for an IOmxNode component.
+     */
+    struct ComponentInfo {
+        string mName;       //< Name of the component.
+        vec<string> mRoles; //< Roles of the component.
+    };
+
+    /**
+     * List available components.
+     *
+     * @param[out] status will be the status of the call.
+     * @param[out] nodeList will be a list of ComponentInfo.
+     */
+    listNodes(
+        ) generates (
+            Status status,
+            vec<ComponentInfo> nodeList
+        );
+
+    /**
+     * Allocate an IOmxNode instance with the specified component name.
+     *
+     * @param[in] name is the name of the component to create.
+     * @param[in] observer is an observer object that will receive messages from
+     * the created instance.
+     * @param[out] status will be the status of the call.
+     * @param[out] omxNode will be the allocated instance of IOmxNode.
+     */
+    allocateNode(
+            string name,
+            IOmxObserver observer
+        ) generates (
+            Status status,
+            IOmxNode omxNode
+        );
+
+};
+
diff --git a/media/omx/1.0/IOmxBufferSource.hal b/media/omx/1.0/IOmxBufferSource.hal
new file mode 100644
index 0000000..94c43fc
--- /dev/null
+++ b/media/omx/1.0/IOmxBufferSource.hal
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.media.omx@1.0;
+
+import android.hardware.media@1.0::types;
+
+/**
+ * Ref: frameworks/av/media/libmedia/aidl/android/IOMXBufferSource.aidl
+ *
+ * IOmxBufferSource is an interface for a listener for certain events from an
+ * IOmxNode instance. Use IOmxNode::setInputSurface() to attach an
+ * IOmxBufferSource instance to an IOmxNode instance.
+ *
+ * @see OMX_STATETYPE in the OpenMax IL standard.
+ */
+interface IOmxBufferSource {
+
+    /**
+     * onOmxExecuting() is invoked when the node state changes to
+     * OMX_StateExecuting state.
+     */
+    oneway onOmxExecuting();
+
+    /**
+     * onOmxIdle() is invoked when the node transitions from OMX_StateExecuting
+     * to OMX_StateIdle.
+     */
+    oneway onOmxIdle();
+
+    /**
+     * onOmxLoaded() is invoked when the node transitions from OMX_StateIdle or
+     * OMX_StateExecuting to OMX_StateLoaded.
+     */
+    oneway onOmxLoaded();
+
+    /**
+     * onInputBufferAdded() is invoked after a new input buffer is added to the
+     * node. This may happen within IOmxNode::allocateSecureBuffer() or
+     * IOmxNode::useBuffer().
+     *
+     * @param[in] buffer is the id of the added buffer.
+     */
+    oneway onInputBufferAdded(BufferId buffer);
+
+    /**
+     * onInputBufferEmptied() is invoked after an input buffer is emptied. This
+     * may happen within IOmxNode::emptyBuffer().
+     *
+     * @param[in] buffer is the id of the emptied buffer.
+     * @param[in] fence is the fence associated with the buffer.
+     */
+    oneway onInputBufferEmptied(BufferId buffer, Fence fence);
+};
+
diff --git a/media/omx/1.0/IOmxNode.hal b/media/omx/1.0/IOmxNode.hal
new file mode 100644
index 0000000..9483be4
--- /dev/null
+++ b/media/omx/1.0/IOmxNode.hal
@@ -0,0 +1,358 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.media.omx@1.0;
+
+import IOmxBufferSource;
+
+import android.hardware.media@1.0::types;
+
+/**
+ * Ref: frameworks/av/include/media/IOMX.h: IOMXNode
+ * Ref: https://www.khronos.org/registry/omxil/specs/OpenMAX_IL_1_1_2_Specification.pdf
+ */
+
+/**
+ * IOmxNode is an interface for communicating with an OMX component (called
+ * "node" here) that has been previously obtained by calling
+ * IOmx::allocateNode().
+ */
+interface IOmxNode {
+
+    /**
+     * Free the node.
+     *
+     * @param[out] status will be the status of the call.
+     */
+    freeNode(
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Invoke a command on the node.
+     *
+     * @param[in] cmd indicates the type of the command.
+     * @param[in] info holds information about the command.
+     * @param[out] status will be the status of the call.
+     *
+     * @see OMX_SendCommand() in the OpenMax IL standard.
+     */
+    sendCommand(
+            uint32_t cmd,
+            Bytes info // TODO: describe structure better or point at standard
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Retrieve a parameter setting from the node.
+     *
+     * @param[in] index indicates the type of the parameter to retrieve.
+     * @param[in] inParams holds some information about the retrieval.
+     * @param[out] status will be the status of the call.
+     * @param[out] outParams will be the current parameter setting.
+     *
+     * @see OMX_GetParameter() in the OpenMax IL standard.
+     */
+    getParameter(
+            uint32_t index,
+            Bytes inParams // TODO: describe structure better or point at standard
+        ) generates (
+            Status status,
+            Bytes outParams // TODO: describe structure better or point at standard
+        );
+
+    /**
+     * Change a parameter setting of the node.
+     *
+     * @param[in] index indicates the type of the parameter to change.
+     * @param[in] params holds the new parameter setting.
+     * @param[out] status will be the status of the call.
+     *
+     * @see OMX_SetParameter() in the OpenMax IL standard.
+     */
+    setParameter(
+            uint32_t index,
+            Bytes params // TODO: describe structure better or point at standard
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Retrieve a configuration from the node.
+     *
+     * @param[in] index indicates the type of the configuration to retrieve.
+     * @param[in] inConfig holds some information about the retrieval.
+     * @param[out] status will be the status of the call.
+     * @param[out] outConfig will be the current configuration.
+     *
+     * @see OMX_GetConfig() in the OpenMax IL standard.
+     */
+    getConfig(
+            uint32_t index,
+            Bytes inConfig // TODO: describe structure better or point at standard
+        ) generates (
+            Status status,
+            Bytes outConfig // TODO: describe structure better or point at standard
+        );
+
+    /**
+     * Change a configuration of the node.
+     *
+     * @param[in] index indicates the type of the configuration to change.
+     * @param[in] config holds the new configuration.
+     * @param[out] status will be the status of the call.
+     *
+     * @see OMX_SetConfig() in the OpenMax IL standard.
+     */
+    setConfig(
+            uint32_t index,
+            Bytes config // TODO: describe structure better or point at standard
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Set the mode of a port on the node.
+     *
+     * @param[in] portIndex is the index of the port.
+     * @param[in] mode is the target mode on the specified port.
+     */
+    setPortMode(
+            uint32_t portIndex,
+            PortMode mode
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Prepare a port for adaptive playback. This is based on the extension
+     * "OMX.google.android.index.prepareForAdaptivePlayback".
+     *
+     * @param[in] portIndex is the index of the port.
+     * @param[in] enable indicates whether adaptive playback is enabled or not.
+     * @param[in] maxFrameWidth specifies the maximum frame width.
+     * @param[in] maxFrameHeight specifies the maximum frame height.
+     * @param[out] status status will be the status of the call.
+     */
+    prepareForAdaptivePlayback(
+            uint32_t portIndex,
+            bool enable,
+            uint32_t maxFrameWidth,
+            uint32_t maxFrameHeight
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Configure a port for a tunneled playback mode. This is based on the
+     * extension "OMX.google.android.index.configureVideoTunnelMode".
+     *
+     * @param[in] portIndex is the index of the port.
+     * @param[in] tunneled indicates whether the tunneled mode is used or not.
+     * @param[in] audioHwSync is the HW SYNC ID of the audio HAL output stream
+     * to sync the video with.
+     * @param[out] status will be the status of the call.
+     * @param[out] sidebandHandle will contain the codec-allocated sideband
+     * window handle.
+     */
+    configureVideoTunnelMode(
+            uint32_t portIndex,
+            bool tunneled,
+            uint32_t audioHwSync
+        ) generates (
+            Status status,
+            handle sidebandHandle
+        );
+
+    /**
+     * Retrieve the buffer usage on a port. This is based on the extension
+     * "OMX.google.android.index.getAndroidNativeBufferUsage".
+     *
+     * @param[in] portIndex is the index of the port.
+     * @param[out] status will be the status of the call.
+     * @param[out] usage will be the usage.
+     */
+    getGraphicBufferUsage(
+            uint32_t portIndex
+        ) generates (
+            Status status,
+            uint32_t usage // TODO: Ask graphics team to define an enum.
+        );
+
+    /**
+     * Set up a listener to events related to the input surface.
+     *
+     * @param[in] bufferSource is the listener object that implements
+     * IOmxBufferSource.
+     * @param[out] status will be the status of the call.
+     *
+     * @see IOmxBufferSource.
+     */
+    setInputSurface(
+            IOmxBufferSource bufferSource
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Allocate an opaque buffer on a port as a native handle.
+     *
+     * @param[in] portIndex is the index of the port.
+     * @param[in] size is the desired size of the buffer.
+     * @param[out] status will be the status of the call.
+     * @param[out] buffer will be the id of the allocated buffer, which will be
+     * needed in some other buffer-related function calls.
+     * @param[out] nativeHandle will be the native handle of the allocated
+     * buffer.
+     *
+     * @see OMX_AllocateBuffer() in the OpenMax IL standard.
+     */
+    allocateSecureBuffer(
+            uint32_t portIndex,
+            uint64_t size
+        ) generates (
+            Status status,
+            BufferId buffer,
+            handle nativeHandle
+        );
+
+    /**
+     * Assign a buffer to a port.
+     *
+     * @param[in] portIndex is the index of the port.
+     * @param[in] omxBuffer is the buffer to be assigned to the port.
+     * @param[out] status will be the status of the call.
+     * @param[out] buffer will be the id of the assigned buffer, which will be
+     * needed in some other buffer-related function calls.
+     *
+     * @see OMX_UseBuffer() in the OpenMax IL standard.
+     */
+    useBuffer(
+            uint32_t portIndex,
+            CodecBuffer omxBuffer
+        ) generates (
+            Status status,
+            BufferId buffer
+        );
+
+    /**
+     * Free a buffer previously assigned to a port by allocateSecureBuffer() or
+     * useBuffer().
+     *
+     * @param[in] portIndex is the index of the port.
+     * @param[in] buffer is the id of the buffer to be freed.
+     * @param[out] status will be the status of the call.
+     *
+     * @see OMX_FreeBuffer() in the OpenMax IL standard.
+     */
+    freeBuffer(
+            uint32_t portIndex,
+            BufferId buffer
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Pass \p fence to the node if it supports fences. Otherwise, it waits on
+     * \p fence before calling OMX_FillThisBuffer(). The node will take
+     * ownership of the fence even if this call fails.
+     *
+     * If the port is in metadata mode, the buffer will be updated to point to
+     * the new buffer passed in via \p omxBuffer before OMX_FillThisBuffer() is
+     * called. Otherwise, \p omxBuffer is not used.
+     *
+     * @param[in] buffer is the id of the buffer to fill.
+     * @param[in] omxBuffer points to the new buffer in metadata mode.
+     * @param[in] fence is the fence to wait for (if not null).
+     * @param[out] status is the status of the call.
+     *
+     * @see OMX_FillThisBuffer() in the OpenMax IL standard.
+     */
+    fillBuffer(
+            BufferId buffer,
+            CodecBuffer omxBuffer,
+            Fence fence
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Pass \p fence to the node if it supports fences. Otherwise, wait on
+     * \p fence before calling OMX_EmptyThisBuffer(). The node will take
+     * ownership of the fence even if this call fails.
+     *
+     * If the port is in metadata mode, the buffer will be updated to point to
+     * the new buffer passed in via \p omxBuffer before OMX_EmptyThisBuffer() is
+     * called. Otherwise, \p omxBuffer is not used.
+     *
+     * @param[in] buffer is the id of the buffer to fill.
+     * @param[in] omxBuffer points to the new buffer in metadata mode.
+     * @param[in] flags is put into the header information that is passed to
+     * OMX_EmptyBuffer().
+     * @param[in] timestampUs is put into the header information that is passed
+     * to OMX_EmptyBuffer().
+     * @param[in] fence is the fence to wait for (if not null).
+     * @param[out] status is the status of the call.
+     *
+     * @see OMX_EmptyThisBuffer() in the OpenMax IL standard.
+     */
+    emptyBuffer(
+            BufferId buffer,
+            CodecBuffer omxBuffer,
+            uint32_t flags, // TODO: describe structure better or point at standard
+            uint64_t timestampUs,
+            Fence fence
+        ) generates (
+            Status status
+        );
+
+    /**
+     * Request the node to translate an extension string to an index.
+     *
+     * @param[in] parameterName is the requested extension string.
+     * @param[out] status is the status of the call.
+     * @param[out] index is the translated index.
+     *
+     * @see OMX_GetExtensionIndex() in the OpenMax IL standard.
+     */
+    getExtensionIndex(
+            string parameterName
+        ) generates (
+            Status status,
+            uint32_t index
+        );
+
+    /**
+     * Add an OMX message on the node's message queue. The instance of
+     * IOmxObserver that was obtained during the creation of the node will
+     * receive the message in batches by the callback
+     * IOmxObserver::onMessages().
+     *
+     * @param[in] msg is the message to send.
+     * @param[out] status is the status of the call.
+     *
+     * @see IOmxObserver::onMessages().
+     */
+    dispatchMessage(
+            Message msg
+        ) generates (
+            Status status
+        );
+
+};
+
diff --git a/media/omx/1.0/IOmxObserver.hal b/media/omx/1.0/IOmxObserver.hal
new file mode 100644
index 0000000..c26a937
--- /dev/null
+++ b/media/omx/1.0/IOmxObserver.hal
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.media.omx@1.0;
+
+/**
+ * Ref: frameworks/av/include/media/IOMX.h: IOMXObserver
+ */
+
+/**
+ * IOmxObserver is a listener interface for OMX messages sent from an IOmxNode
+ * stance.
+ */
+interface IOmxObserver {
+
+    /**
+     * Invoked to process messages from an IOmxNode instance. Note that messages
+     * come in batches.
+     */
+    oneway onMessages(vec<Message> messages);
+};
+
diff --git a/media/omx/1.0/types.hal b/media/omx/1.0/types.hal
new file mode 100644
index 0000000..c0350de
--- /dev/null
+++ b/media/omx/1.0/types.hal
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.media.omx@1.0;
+
+import android.hardware.media@1.0::types;
+
+// Aliases
+typedef uint32_t BufferId;
+
+/**
+ * Ref: frameworks/av/include/media/IOMX.h: omx_message
+ *
+ * Data structure for an OMX message. This is essentially a union of different
+ * message types.
+ */
+struct Message {
+
+    /**
+     * There are four main types of messages.
+     */
+    enum Type : uint32_t {
+        EVENT,
+        EMPTY_BUFFER_DONE,
+        FILL_BUFFER_DONE,
+        FRAME_RENDERED,
+    };
+
+    /**
+     * @see OMX_EVENTTYPE in the OpenMax IL standard.
+     */
+    struct EventData {
+        uint32_t event; // TODO: if there are common core events, convert to an enum or point to std
+        uint32_t data1;
+        uint32_t data2;
+        uint32_t data3;
+        uint32_t data4;
+    };
+
+    struct BufferData {
+        BufferId buffer;
+    };
+
+    struct ExtendedBufferData {
+        BufferId buffer;
+        uint32_t rangeOffset;
+        uint32_t rangeLength;
+        uint32_t flags; // TODO: if common flags exist, define an enum of point to std
+        uint64_t timestampUs;
+    };
+
+    struct RenderData {
+        uint64_t timestampUs;
+        int64_t systemTimeNs;
+    };
+
+    union Data {
+        // if type == EVENT
+        EventData eventData;
+
+        // if type == EMPTY_BUFFER_DONE
+        BufferData bufferData;
+
+        // if type == FILL_BUFFER_DONE
+        ExtendedBufferData extendedBufferData;
+
+        // if type == FRAME_RENDERED
+        RenderData renderData;
+    };
+
+    /**
+     * The type of the message.
+     */
+    Type type;
+
+    /**
+     * The fence associated with the message.
+     */
+    Fence fence;
+
+    /**
+     * The union of data, discriminated by type.
+     */
+    Data data;
+};
+
+/**
+ * Ref: frameworks/native/include/ui/GraphicBuffer.h
+ * Ref: system/core/include/system/window.h
+ * Ref: frameworks/native/include/binder/IMemory.h
+ * Ref: frameworks/native/libs/binder/IMemory.cpp
+ * Ref: frameworks/av/include/media/OMXBuffer.h
+ *
+ * Data structure for buffer information. This is essentially a union of
+ * different buffer types.
+ */
+struct CodecBuffer {
+
+    /**
+     * There are four main types of buffers.
+     */
+    enum Type {
+        INVALID = 0,
+        PRESET,
+        SHARED_MEM,
+        ANW_BUFFER,
+        NATIVE_HANDLE
+    };
+
+    struct PresetAttributes {
+        uint32_t rangeLength;
+    };
+
+    union Attributes {
+        // if bufferType == PRESET
+        PresetAttributes preset;
+
+        // if bufferType == SHARED_MEM
+        SharedMemoryAttributes sharedMem;
+
+        // if bufferType == ANW_BUFFER
+        GraphicBufferAttributes anwBuffer;
+
+        // if bufferType == NATIVE_HANDLE
+        // No additional attributes.
+    };
+
+    /**
+     * Type of the buffer.
+     */
+    Type type;
+
+    /**
+     * Attributes that can be put into a union.
+     */
+    Attributes attr;
+
+    /**
+     * \p nativeHandle is used only for types SHARED_MEM, ANW_BUFFER and
+     * NATIVE_HANDLE.
+     *
+     * (A native handle cannot be put into a union as HIDL currently does not
+     * support discriminated unions.)
+     */
+    handle nativeHandle;
+
+};
+
+/**
+ * Ref: frameworks/av/include/media/IOMX.h
+ *
+ * Enumeration of port modes.
+ */
+enum PortMode {
+    PRESET_START = 0,
+    PRESET_BYTE_BUFFER,
+    PRESET_ANW_BUFFER,
+    PRESET_SECURE_BUFFER,
+    PRESET_END,
+    DYNAMIC_START = 100,
+    DYNAMIC_ANW_BUFFER,
+    DYNAMIC_NATIVE_HANDLE,
+    DYNAMIC_END
+};
+
diff --git a/memtrack/1.0/Android.bp b/memtrack/1.0/Android.bp
index 83c09cf..c5727c1 100644
--- a/memtrack/1.0/Android.bp
+++ b/memtrack/1.0/Android.bp
@@ -38,13 +38,15 @@
     generated_headers: ["android.hardware.memtrack@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.memtrack@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/memtrack/1.0/default/Android.bp b/memtrack/1.0/default/Android.bp
index 50d2318..91fa1ea 100644
--- a/memtrack/1.0/default/Android.bp
+++ b/memtrack/1.0/default/Android.bp
@@ -20,7 +20,8 @@
     shared_libs: [
         "libbase",
         "liblog",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhardware",
         "libhwbinder",
         "libutils",
@@ -41,7 +42,8 @@
         "libdl",
         "libutils",
         "libhardware",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "android.hardware.memtrack@1.0",
     ],
diff --git a/memtrack/1.0/vts/Android.mk b/memtrack/1.0/vts/Android.mk
index c0fe968..8a5ceb1 100644
--- a/memtrack/1.0/vts/Android.mk
+++ b/memtrack/1.0/vts/Android.mk
@@ -25,18 +25,14 @@
   Memtrack.vts \
   types.vts \
 
-LOCAL_C_INCLUDES := \
-  android.hardware.memtrack@1.0 \
-  system/core/base/include \
-  system/core/include \
-
 LOCAL_SHARED_LIBRARIES += \
   android.hardware.memtrack@1.0 \
   libbase \
   libutils \
   libcutils \
   liblog \
-  libhidl \
+  libhidlbase \
+  libhidltransport \
   libhwbinder \
   libprotobuf-cpp-full \
   libvts_common \
@@ -44,10 +40,6 @@
   libvts_measurement \
   libvts_multidevice_proto \
 
-LOCAL_CFLAGS += -DENABLE_TREBLE
-
-LOCAL_STATIC_LIBRARIES := \
-
 LOCAL_PROTOC_OPTIMIZE_TYPE := full
 
 LOCAL_MULTILIB := both
@@ -73,7 +65,8 @@
    libbase \
    libcutils \
    liblog \
-   libhidl \
+   libhidlbase \
+   libhidltransport \
    libhwbinder \
    libprotobuf-cpp-full \
    libvts_common \
diff --git a/nfc/1.0/Android.bp b/nfc/1.0/Android.bp
index b6e8d08..9584636 100644
--- a/nfc/1.0/Android.bp
+++ b/nfc/1.0/Android.bp
@@ -46,13 +46,15 @@
     generated_headers: ["android.hardware.nfc@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.nfc@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/nfc/1.0/default/Android.bp b/nfc/1.0/default/Android.bp
index a8c4c81..b484ba6 100644
--- a/nfc/1.0/default/Android.bp
+++ b/nfc/1.0/default/Android.bp
@@ -10,7 +10,8 @@
         "libbase",
         "libcutils",
         "libutils",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "android.hardware.nfc@1.0",
     ],
 }
diff --git a/nfc/1.0/default/Android.mk b/nfc/1.0/default/Android.mk
index d4e46f8..a6c7d5c 100644
--- a/nfc/1.0/default/Android.mk
+++ b/nfc/1.0/default/Android.mk
@@ -18,7 +18,8 @@
 
 LOCAL_SHARED_LIBRARIES += \
 	libhwbinder \
-	libhidl \
+	libhidlbase \
+	libhidltransport \
 	android.hardware.nfc@1.0 \
 
 include $(BUILD_EXECUTABLE)
diff --git a/nfc/1.0/vts/Android.mk b/nfc/1.0/vts/Android.mk
index 6f63e03..04884b7 100644
--- a/nfc/1.0/vts/Android.mk
+++ b/nfc/1.0/vts/Android.mk
@@ -26,18 +26,14 @@
   NfcClientCallback.vts \
   types.vts \
 
-LOCAL_C_INCLUDES := \
-  android.hardware.nfc@1.0 \
-  system/core/base/include \
-  system/core/include \
-
 LOCAL_SHARED_LIBRARIES += \
   android.hardware.nfc@1.0 \
   libbase \
   libutils \
   libcutils \
   liblog \
-  libhidl \
+  libhidlbase \
+  libhidltransport \
   libhwbinder \
   libprotobuf-cpp-full \
   libvts_common \
@@ -45,10 +41,6 @@
   libvts_measurement \
   libvts_multidevice_proto \
 
-LOCAL_CFLAGS += -DENABLE_TREBLE
-
-LOCAL_STATIC_LIBRARIES := \
-
 LOCAL_PROTOC_OPTIMIZE_TYPE := full
 
 LOCAL_MULTILIB := both
@@ -74,7 +66,8 @@
    libbase \
    libcutils \
    liblog \
-   libhidl \
+   libhidlbase \
+   libhidltransport \
    libhwbinder \
    libprotobuf-cpp-full \
    libvts_common \
@@ -105,7 +98,8 @@
    libbase \
    libcutils \
    liblog \
-   libhidl \
+   libhidlbase \
+   libhidltransport \
    libhwbinder \
    libprotobuf-cpp-full \
    libvts_common \
diff --git a/nfc/1.0/vts/Nfc.vts b/nfc/1.0/vts/Nfc.vts
index 1f50698..c2313d5 100644
--- a/nfc/1.0/vts/Nfc.vts
+++ b/nfc/1.0/vts/Nfc.vts
@@ -19,6 +19,16 @@
             predefined_type: "INfcClientCallback"
             is_callback: true
         }
+        callflow: {
+            entry: true
+        }
+        callflow: {
+            next: "write"
+            next: "coreInitialized"
+            next: "prediscover"
+            next: "powerCycle"
+            next: "controlGranted"
+        }
     }
 
     api: {
@@ -34,6 +44,14 @@
                 scalar_type: "uint8_t"
             }
         }
+        callflow: {
+            next: "write"
+            next: "prediscover"
+            next: "coreInitialized"
+            next: "close"
+            next: "powerCycle"
+            next: "controlGranted"
+        }
     }
 
     api: {
@@ -49,6 +67,11 @@
                 scalar_type: "uint8_t"
             }
         }
+        callflow: {
+            next: "write"
+            next: "prediscover"
+            next: "close"
+        }
     }
 
     api: {
@@ -57,6 +80,13 @@
             type: TYPE_SCALAR
             scalar_type: "int32_t"
         }
+        callflow: {
+            next: "write"
+            next: "close"
+            next: "coreInitialized"
+            next: "powerCycle"
+            next: "controlGranted"
+        }
     }
 
     api: {
@@ -65,6 +95,9 @@
             type: TYPE_SCALAR
             scalar_type: "int32_t"
         }
+        callflow: {
+            exit: true
+        }
     }
 
     api: {
@@ -73,6 +106,13 @@
             type: TYPE_SCALAR
             scalar_type: "int32_t"
         }
+        callflow: {
+            next: "write"
+            next: "close"
+            next: "prediscover"
+            next: "coreInitialized"
+            next: "powerCycle"
+        }
     }
 
     api: {
@@ -81,6 +121,13 @@
             type: TYPE_SCALAR
             scalar_type: "int32_t"
         }
+        callflow: {
+            next: "write"
+            next: "coreInitialized"
+            next: "prediscover"
+            next: "controlGranted"
+            next: "close"
+        }
     }
 
 }
diff --git a/nfc/1.0/vts/functional/Android.bp b/nfc/1.0/vts/functional/Android.bp
index 0f1afbd..021f7c1 100644
--- a/nfc/1.0/vts/functional/Android.bp
+++ b/nfc/1.0/vts/functional/Android.bp
@@ -22,7 +22,8 @@
         "libbase",
         "liblog",
         "libcutils",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libnativehelper",
         "libutils",
@@ -30,7 +31,11 @@
     ],
     static_libs: ["libgtest"],
     cflags: [
+        "--coverage",
         "-O0",
         "-g",
     ],
-}
\ No newline at end of file
+    ldflags: [
+        "--coverage"
+    ]
+}
diff --git a/power/1.0/Android.bp b/power/1.0/Android.bp
index a671474..777bb85 100644
--- a/power/1.0/Android.bp
+++ b/power/1.0/Android.bp
@@ -38,13 +38,15 @@
     generated_headers: ["android.hardware.power@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.power@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/power/1.0/default/Android.bp b/power/1.0/default/Android.bp
index e573186..1a5a897 100644
--- a/power/1.0/default/Android.bp
+++ b/power/1.0/default/Android.bp
@@ -20,7 +20,8 @@
     shared_libs: [
         "liblog",
         "libhardware",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "android.hardware.power@1.0",
@@ -39,7 +40,8 @@
         "libdl",
         "libutils",
         "libhardware",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "android.hardware.power@1.0",
     ],
diff --git a/power/1.0/vts/Android.mk b/power/1.0/vts/Android.mk
index 4d5117b..887b6bf 100644
--- a/power/1.0/vts/Android.mk
+++ b/power/1.0/vts/Android.mk
@@ -25,18 +25,14 @@
   Power.vts \
   types.vts \
 
-LOCAL_C_INCLUDES := \
-  android.hardware.power@1.0 \
-  system/core/base/include \
-  system/core/include \
-
 LOCAL_SHARED_LIBRARIES += \
   android.hardware.power@1.0 \
   libbase \
   libutils \
   libcutils \
   liblog \
-  libhidl \
+  libhidlbase \
+  libhidltransport \
   libhwbinder \
   libprotobuf-cpp-full \
   libvts_common \
@@ -44,10 +40,6 @@
   libvts_measurement \
   libvts_multidevice_proto \
 
-LOCAL_CFLAGS += -DENABLE_TREBLE
-
-LOCAL_STATIC_LIBRARIES := \
-
 LOCAL_PROTOC_OPTIMIZE_TYPE := full
 
 LOCAL_MULTILIB := both
@@ -73,7 +65,8 @@
    libbase \
    libcutils \
    liblog \
-   libhidl \
+   libhidlbase \
+   libhidltransport \
    libhwbinder \
    libprotobuf-cpp-full \
    libvts_common \
diff --git a/radio/1.0/Android.bp b/radio/1.0/Android.bp
index 0f89421..1bb8fe5 100644
--- a/radio/1.0/Android.bp
+++ b/radio/1.0/Android.bp
@@ -70,13 +70,15 @@
     generated_headers: ["android.hardware.radio@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.radio@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/radio/1.0/IRadio.hal b/radio/1.0/IRadio.hal
index d2ffa82..f29b916 100644
--- a/radio/1.0/IRadio.hal
+++ b/radio/1.0/IRadio.hal
@@ -1556,4 +1556,12 @@
      * Response callback is IRadioCallback.getAllowedCarriersResponse()
      */
     oneway getAllowedCarriers(int32_t serial);
+
+    /*
+     * When response type received from a radio indication or radio response is
+     * RadioIndicationType:UNSOLICITED_ACK_EXP or RadioResponseType:SOLICITED_ACK_EXP respectively,
+     * acknowledge the receipt of those messages by sending reseponeAcknowledgement().
+     *
+     */
+    oneway responseAcknowledgement();
 };
\ No newline at end of file
diff --git a/sensors/1.0/Android.bp b/sensors/1.0/Android.bp
index 2039613..7f25a62 100644
--- a/sensors/1.0/Android.bp
+++ b/sensors/1.0/Android.bp
@@ -38,13 +38,15 @@
     generated_headers: ["android.hardware.sensors@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.sensors@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/sensors/1.0/default/Android.bp b/sensors/1.0/default/Android.bp
index d8d0c82..7fbe117 100644
--- a/sensors/1.0/default/Android.bp
+++ b/sensors/1.0/default/Android.bp
@@ -10,7 +10,8 @@
         "libbase",
         "libcutils",
         "libutils",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "android.hardware.sensors@1.0",
     ],
     static_libs: [
@@ -31,7 +32,8 @@
         "libbase",
         "libcutils",
         "libutils",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "android.hardware.sensors@1.0",
     ],
     local_include_dirs: ["include/sensors"],
diff --git a/sensors/1.0/default/Android.mk b/sensors/1.0/default/Android.mk
index 4f418cb..b2b2c60 100644
--- a/sensors/1.0/default/Android.mk
+++ b/sensors/1.0/default/Android.mk
@@ -18,7 +18,8 @@
 
 LOCAL_SHARED_LIBRARIES += \
 	libhwbinder \
-	libhidl \
+	libhidlbase \
+	libhidltransport \
 	android.hardware.sensors@1.0 \
 
 include $(BUILD_EXECUTABLE)
diff --git a/soundtrigger/2.0/Android.bp b/soundtrigger/2.0/Android.bp
index 79ae797..4eab0bf 100644
--- a/soundtrigger/2.0/Android.bp
+++ b/soundtrigger/2.0/Android.bp
@@ -46,14 +46,16 @@
     generated_headers: ["android.hardware.soundtrigger@2.0_genc++_headers"],
     export_generated_headers: ["android.hardware.soundtrigger@2.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
         "android.hardware.audio.common@2.0",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "android.hardware.audio.common@2.0",
diff --git a/soundtrigger/2.0/default/Android.mk b/soundtrigger/2.0/default/Android.mk
index 4ec64de..498c54f 100644
--- a/soundtrigger/2.0/default/Android.mk
+++ b/soundtrigger/2.0/default/Android.mk
@@ -23,7 +23,8 @@
     SoundTriggerHalImpl.cpp
 
 LOCAL_SHARED_LIBRARIES := \
-        libhidl \
+        libhidlbase \
+        libhidltransport \
         liblog \
         libhwbinder \
         libutils \
diff --git a/tests/bar/1.0/Android.bp b/tests/bar/1.0/Android.bp
index 97693fb..08947ad 100644
--- a/tests/bar/1.0/Android.bp
+++ b/tests/bar/1.0/Android.bp
@@ -42,14 +42,16 @@
     generated_headers: ["android.hardware.tests.bar@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tests.bar@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
         "android.hardware.tests.foo@1.0",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "android.hardware.tests.foo@1.0",
diff --git a/tests/bar/1.0/default/Android.bp b/tests/bar/1.0/default/Android.bp
index c2c2309..7e349c2 100644
--- a/tests/bar/1.0/default/Android.bp
+++ b/tests/bar/1.0/default/Android.bp
@@ -11,7 +11,8 @@
     shared_libs: [
         "libbase",
         "libcutils",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "liblog",
         "libutils",
diff --git a/tests/bar/1.0/default/Bar.cpp b/tests/bar/1.0/default/Bar.cpp
index 4ff9e6b..2158cd8 100644
--- a/tests/bar/1.0/default/Bar.cpp
+++ b/tests/bar/1.0/default/Bar.cpp
@@ -154,7 +154,7 @@
 }
 
 Return<void> Bar::expectNullHandle(const native_handle_t* h, const Abc& xyz, expectNullHandle_cb _hidl_cb) {
-    ALOGI("SERVER(Bar) h = %p, xyz.z = %p", h, xyz.z);
+    ALOGI("SERVER(Bar) h = %p, xyz.z = %p", h, static_cast<void*>(xyz.z));
     _hidl_cb(h == nullptr, xyz.z == nullptr);
     return Void();
 }
diff --git a/tests/baz/1.0/Android.bp b/tests/baz/1.0/Android.bp
index 1a7c300..98d3e84 100644
--- a/tests/baz/1.0/Android.bp
+++ b/tests/baz/1.0/Android.bp
@@ -54,13 +54,15 @@
     generated_headers: ["android.hardware.tests.baz@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tests.baz@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/tests/expression/1.0/Android.bp b/tests/expression/1.0/Android.bp
index 6acb3f9..60754d3 100644
--- a/tests/expression/1.0/Android.bp
+++ b/tests/expression/1.0/Android.bp
@@ -42,13 +42,15 @@
     generated_headers: ["android.hardware.tests.expression@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tests.expression@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/tests/foo/1.0/Android.bp b/tests/foo/1.0/Android.bp
index 7e30fe3..4064e74 100644
--- a/tests/foo/1.0/Android.bp
+++ b/tests/foo/1.0/Android.bp
@@ -70,13 +70,15 @@
     generated_headers: ["android.hardware.tests.foo@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tests.foo@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/tests/foo/1.0/default/Android.bp b/tests/foo/1.0/default/Android.bp
index f2ee521..76a4656 100644
--- a/tests/foo/1.0/default/Android.bp
+++ b/tests/foo/1.0/default/Android.bp
@@ -11,7 +11,8 @@
     shared_libs: [
         "libbase",
         "libcutils",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libfootest",
         "libhwbinder",
         "liblog",
diff --git a/tests/foo/1.0/default/lib/Android.bp b/tests/foo/1.0/default/lib/Android.bp
index c7ad57e..7873203 100644
--- a/tests/foo/1.0/default/lib/Android.bp
+++ b/tests/foo/1.0/default/lib/Android.bp
@@ -5,7 +5,8 @@
     ],
 
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "android.hardware.tests.foo@1.0",
     ],
diff --git a/tests/inheritance/1.0/Android.bp b/tests/inheritance/1.0/Android.bp
index f522ac0..cfd10ac 100644
--- a/tests/inheritance/1.0/Android.bp
+++ b/tests/inheritance/1.0/Android.bp
@@ -58,13 +58,15 @@
     generated_headers: ["android.hardware.tests.inheritance@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tests.inheritance@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/tests/inheritance/1.0/default/Android.bp b/tests/inheritance/1.0/default/Android.bp
index d97bd83..638d3a4 100644
--- a/tests/inheritance/1.0/default/Android.bp
+++ b/tests/inheritance/1.0/default/Android.bp
@@ -11,7 +11,8 @@
 
     shared_libs: [
         "libbase",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "liblog",
         "libutils",
diff --git a/tests/libhwbinder/1.0/Android.bp b/tests/libhwbinder/1.0/Android.bp
index 2598f30..ca02cc7 100644
--- a/tests/libhwbinder/1.0/Android.bp
+++ b/tests/libhwbinder/1.0/Android.bp
@@ -34,13 +34,15 @@
     generated_headers: ["android.hardware.tests.libhwbinder@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tests.libhwbinder@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/tests/libhwbinder/1.0/default/Android.bp b/tests/libhwbinder/1.0/default/Android.bp
index 91149e8..73dcc61 100644
--- a/tests/libhwbinder/1.0/default/Android.bp
+++ b/tests/libhwbinder/1.0/default/Android.bp
@@ -7,10 +7,11 @@
 
     shared_libs: [
         "libbase",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "liblog",
         "libutils",
         "android.hardware.tests.libhwbinder@1.0",
     ],
-}
\ No newline at end of file
+}
diff --git a/tests/msgq/1.0/Android.bp b/tests/msgq/1.0/Android.bp
index e685bcc..914c93f 100644
--- a/tests/msgq/1.0/Android.bp
+++ b/tests/msgq/1.0/Android.bp
@@ -34,13 +34,15 @@
     generated_headers: ["android.hardware.tests.msgq@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tests.msgq@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/tests/pointer/1.0/Android.bp b/tests/pointer/1.0/Android.bp
index ad8d014..bbd0eaa 100644
--- a/tests/pointer/1.0/Android.bp
+++ b/tests/pointer/1.0/Android.bp
@@ -42,13 +42,15 @@
     generated_headers: ["android.hardware.tests.pointer@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tests.pointer@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/tests/pointer/1.0/default/Android.bp b/tests/pointer/1.0/default/Android.bp
index 081b7aa..f7180f1 100644
--- a/tests/pointer/1.0/default/Android.bp
+++ b/tests/pointer/1.0/default/Android.bp
@@ -10,7 +10,8 @@
 
     shared_libs: [
         "libbase",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libpointertest",
         "libhwbinder",
         "liblog",
diff --git a/tests/pointer/1.0/default/lib/Android.bp b/tests/pointer/1.0/default/lib/Android.bp
index efc61df..a7203c7 100644
--- a/tests/pointer/1.0/default/lib/Android.bp
+++ b/tests/pointer/1.0/default/lib/Android.bp
@@ -6,7 +6,8 @@
 
     shared_libs: [
         "libbase",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "liblog",
         "android.hardware.tests.pointer@1.0",
diff --git a/thermal/1.0/Android.bp b/thermal/1.0/Android.bp
index 60f2626..3b6ef06 100644
--- a/thermal/1.0/Android.bp
+++ b/thermal/1.0/Android.bp
@@ -38,13 +38,15 @@
     generated_headers: ["android.hardware.thermal@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.thermal@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/thermal/1.0/IThermal.hal b/thermal/1.0/IThermal.hal
index a60bc7d..e5f70cb 100644
--- a/thermal/1.0/IThermal.hal
+++ b/thermal/1.0/IThermal.hal
@@ -32,6 +32,9 @@
      *         always returns and never removes such temperatures.
      *
      */
+    @callflow(next={"*"})
+    @entry
+    @exit
     getTemperatures()
         generates (ThermalStatus status, vec<Temperature> temperatures);
 
@@ -47,6 +50,9 @@
      *         the same regardless the number of calls to this method.
      *
      */
+    @callflow(next={"*"})
+    @entry
+    @exit
     getCpuUsages() generates (ThermalStatus status, vec<CpuUsage> cpuUsages);
 
     /*
@@ -63,6 +69,9 @@
      *         the list such cooling devices.
      *
      */
+    @callflow(next={"*"})
+    @entry
+    @exit
     getCoolingDevices()
         generates (ThermalStatus status, vec<CoolingDevice> devices);
 
diff --git a/thermal/1.0/default/Android.bp b/thermal/1.0/default/Android.bp
index 626dcaf..819f0b1 100644
--- a/thermal/1.0/default/Android.bp
+++ b/thermal/1.0/default/Android.bp
@@ -10,7 +10,8 @@
         "libbase",
         "libcutils",
         "libutils",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "android.hardware.thermal@1.0",
     ],
 }
diff --git a/thermal/1.0/default/Android.mk b/thermal/1.0/default/Android.mk
index fa7414e..9039e9f 100644
--- a/thermal/1.0/default/Android.mk
+++ b/thermal/1.0/default/Android.mk
@@ -33,7 +33,8 @@
 
 LOCAL_SHARED_LIBRARIES += \
         libhwbinder \
-        libhidl \
+        libhidlbase \
+        libhidltransport \
         android.hardware.thermal@1.0 \
 
 include $(BUILD_EXECUTABLE)
diff --git a/thermal/1.0/default/Thermal.cpp b/thermal/1.0/default/Thermal.cpp
index 1b91687..6c2111f 100644
--- a/thermal/1.0/default/Thermal.cpp
+++ b/thermal/1.0/default/Thermal.cpp
@@ -20,6 +20,7 @@
 #include <errno.h>
 #include <hardware/hardware.h>
 #include <hardware/thermal.h>
+#include <vector>
 
 #include "Thermal.h"
 
@@ -29,173 +30,167 @@
 namespace V1_0 {
 namespace implementation {
 
-Thermal::Thermal(thermal_module_t* module) : mModule(module) {
-}
+Thermal::Thermal(thermal_module_t* module) : mModule(module) {}
 
 // Methods from ::android::hardware::thermal::V1_0::IThermal follow.
-Return<void> Thermal::getTemperatures(getTemperatures_cb _hidl_cb)  {
-    ThermalStatus status;
-    status.code = ThermalStatusCode::SUCCESS;
-    hidl_vec<Temperature> temperatures;
+Return<void> Thermal::getTemperatures(getTemperatures_cb _hidl_cb) {
+  ThermalStatus status;
+  status.code = ThermalStatusCode::SUCCESS;
+  hidl_vec<Temperature> temperatures;
 
-    if (!mModule || !mModule->getTemperatures) {
-        ALOGI("getTemperatures is not implemented in Thermal HAL.");
-        _hidl_cb(status, temperatures);
-        return Void();
-    }
-
-    ssize_t list_size = mModule->getTemperatures(mModule, nullptr, 0);
-    if (list_size >= 0) {
-       temperature_t *list = new temperature_t[list_size];
-       ssize_t size = mModule->getTemperatures(mModule, list, list_size);
-       if (size >= 0) {
-           if (list_size > size) {
-               list_size = size;
-           }
-
-           temperatures.resize(list_size);
-           for (ssize_t i = 0; i < list_size; ++i) {
-               switch (list[i].type) {
-                   case DEVICE_TEMPERATURE_UNKNOWN:
-                       temperatures[i].type = TemperatureType::UNKNOWN;
-                       break;
-                   case DEVICE_TEMPERATURE_CPU:
-                       temperatures[i].type = TemperatureType::CPU;
-                       break;
-                   case DEVICE_TEMPERATURE_GPU:
-                       temperatures[i].type = TemperatureType::GPU;
-                       break;
-                   case DEVICE_TEMPERATURE_BATTERY:
-                       temperatures[i].type = TemperatureType::BATTERY;
-                       break;
-                   case DEVICE_TEMPERATURE_SKIN:
-                       temperatures[i].type = TemperatureType::SKIN;
-                       break;
-                   default:
-                       ALOGE("Unknown temperature %s type", list[i].name);;
-               }
-               temperatures[i].name = list[i].name;
-               temperatures[i].currentValue = list[i].current_value;
-               temperatures[i].throttlingThreshold = list[i].throttling_threshold;
-               temperatures[i].shutdownThreshold = list[i].shutdown_threshold;
-               temperatures[i].vrThrottlingThreshold = list[i].vr_throttling_threshold;
-           }
-       } else {
-           status.code = ThermalStatusCode::FAILURE;
-           status.debugMessage = strerror(-size);
-       }
-       delete[] list;
-    } else {
-        status.code = ThermalStatusCode::FAILURE;
-        status.debugMessage = strerror(-list_size);
-    }
+  if (!mModule || !mModule->getTemperatures) {
+    ALOGI("getTemperatures is not implemented in Thermal HAL.");
     _hidl_cb(status, temperatures);
     return Void();
+  }
+
+  ssize_t size = mModule->getTemperatures(mModule, nullptr, 0);
+  if (size >= 0) {
+    std::vector<temperature_t> list;
+    list.resize(size);
+    size = mModule->getTemperatures(mModule, list.data(), list.size());
+    if (size >= 0) {
+      temperatures.resize(list.size());
+      for (size_t i = 0; i < list.size(); ++i) {
+        switch (list[i].type) {
+          case DEVICE_TEMPERATURE_UNKNOWN:
+            temperatures[i].type = TemperatureType::UNKNOWN;
+            break;
+          case DEVICE_TEMPERATURE_CPU:
+            temperatures[i].type = TemperatureType::CPU;
+            break;
+          case DEVICE_TEMPERATURE_GPU:
+            temperatures[i].type = TemperatureType::GPU;
+            break;
+          case DEVICE_TEMPERATURE_BATTERY:
+            temperatures[i].type = TemperatureType::BATTERY;
+            break;
+          case DEVICE_TEMPERATURE_SKIN:
+            temperatures[i].type = TemperatureType::SKIN;
+            break;
+          default:
+            ALOGE("Unknown temperature %s type", list[i].name);
+            ;
+        }
+        temperatures[i].name = list[i].name;
+        temperatures[i].currentValue = list[i].current_value;
+        temperatures[i].throttlingThreshold = list[i].throttling_threshold;
+        temperatures[i].shutdownThreshold = list[i].shutdown_threshold;
+        temperatures[i].vrThrottlingThreshold = list[i].vr_throttling_threshold;
+      }
+    }
+  }
+  if (size < 0) {
+    status.code = ThermalStatusCode::FAILURE;
+    status.debugMessage = strerror(-size);
+  }
+  _hidl_cb(status, temperatures);
+  return Void();
 }
 
-Return<void> Thermal::getCpuUsages(getCpuUsages_cb _hidl_cb)  {
-    ThermalStatus status;
-    hidl_vec<CpuUsage> cpuUsages;
-    status.code = ThermalStatusCode::SUCCESS;
+Return<void> Thermal::getCpuUsages(getCpuUsages_cb _hidl_cb) {
+  ThermalStatus status;
+  hidl_vec<CpuUsage> cpuUsages;
+  status.code = ThermalStatusCode::SUCCESS;
 
-    if (!mModule || !mModule->getCpuUsages) {
-        ALOGI("getCpuUsages is not implemented in Thermal HAL");
-        _hidl_cb(status, cpuUsages);
-        return Void();
-    }
-
-    ssize_t size = mModule->getCpuUsages(mModule, nullptr);
-    if (size >= 0) {
-        cpu_usage_t *list = new cpu_usage_t[size];
-        size = mModule->getCpuUsages(mModule, list);
-        if (size >= 0) {
-            cpuUsages.resize(size);
-            for (ssize_t i = 0; i < size; ++i) {
-                cpuUsages[i].name = list[i].name;
-                cpuUsages[i].active = list[i].active;
-                cpuUsages[i].total = list[i].total;
-                cpuUsages[i].isOnline = list[i].is_online;
-            }
-        } else {
-            status.code = ThermalStatusCode::FAILURE;
-            status.debugMessage = strerror(-size);
-        }
-        delete[] list;
-    } else {
-        status.code = ThermalStatusCode::FAILURE;
-        status.debugMessage = strerror(-size);
-    }
+  if (!mModule || !mModule->getCpuUsages) {
+    ALOGI("getCpuUsages is not implemented in Thermal HAL");
     _hidl_cb(status, cpuUsages);
     return Void();
+  }
+
+  ssize_t size = mModule->getCpuUsages(mModule, nullptr);
+  if (size >= 0) {
+    std::vector<cpu_usage_t> list;
+    list.resize(size);
+    size = mModule->getCpuUsages(mModule, list.data());
+    if (size >= 0) {
+      list.resize(size);
+      cpuUsages.resize(size);
+      for (size_t i = 0; i < list.size(); ++i) {
+        cpuUsages[i].name = list[i].name;
+        cpuUsages[i].active = list[i].active;
+        cpuUsages[i].total = list[i].total;
+        cpuUsages[i].isOnline = list[i].is_online;
+      }
+    } else {
+      status.code = ThermalStatusCode::FAILURE;
+      status.debugMessage = strerror(-size);
+    }
+  }
+  if (size < 0) {
+    status.code = ThermalStatusCode::FAILURE;
+    status.debugMessage = strerror(-size);
+  }
+  _hidl_cb(status, cpuUsages);
+  return Void();
 }
 
-Return<void> Thermal::getCoolingDevices(getCoolingDevices_cb _hidl_cb)  {
-    ThermalStatus status;
-    status.code = ThermalStatusCode::SUCCESS;
-    hidl_vec<CoolingDevice> coolingDevices;
+Return<void> Thermal::getCoolingDevices(getCoolingDevices_cb _hidl_cb) {
+  ThermalStatus status;
+  status.code = ThermalStatusCode::SUCCESS;
+  hidl_vec<CoolingDevice> coolingDevices;
 
-    if (!mModule || !mModule->getCoolingDevices) {
-        ALOGI("getCoolingDevices is not implemented in Thermal HAL.");
-        _hidl_cb(status, coolingDevices);
-        return Void();
-    }
-
-    ssize_t list_size = mModule->getCoolingDevices(mModule, nullptr, 0);
-    if (list_size >= 0) {
-        cooling_device_t *list = new cooling_device_t[list_size];
-        ssize_t size = mModule->getCoolingDevices(mModule, list, list_size);
-        if (size >= 0) {
-            if (list_size > size) {
-                list_size = size;
-            }
-            coolingDevices.resize(list_size);
-            for (ssize_t i = 0; i < list_size; ++i) {
-                switch (list[i].type) {
-                    case FAN_RPM:
-                        coolingDevices[i].type = CoolingType::FAN_RPM;
-                        break;
-                    default:
-                        ALOGE("Unknown cooling device %s type", list[i].name);
-                }
-                coolingDevices[i].name = list[i].name;
-                coolingDevices[i].currentValue = list[i].current_value;
-            }
-
-        } else {
-            status.code = ThermalStatusCode::FAILURE;
-            status.debugMessage = strerror(-size);
-        }
-        delete[] list;
-    } else {
-        status.code = ThermalStatusCode::FAILURE;
-        status.debugMessage = strerror(-list_size);
-    }
+  if (!mModule || !mModule->getCoolingDevices) {
+    ALOGI("getCoolingDevices is not implemented in Thermal HAL.");
     _hidl_cb(status, coolingDevices);
     return Void();
+  }
+
+  ssize_t size = mModule->getCoolingDevices(mModule, nullptr, 0);
+  if (size >= 0) {
+    std::vector<cooling_device_t> list;
+    list.resize(size);
+    size = mModule->getCoolingDevices(mModule, list.data(), list.size());
+    if (size >= 0) {
+      list.resize(size);
+      coolingDevices.resize(list.size());
+      for (size_t i = 0; i < list.size(); ++i) {
+        switch (list[i].type) {
+          case FAN_RPM:
+            coolingDevices[i].type = CoolingType::FAN_RPM;
+            break;
+          default:
+            ALOGE("Unknown cooling device %s type", list[i].name);
+        }
+        coolingDevices[i].name = list[i].name;
+        coolingDevices[i].currentValue = list[i].current_value;
+      }
+    }
+  }
+  if (size < 0) {
+    status.code = ThermalStatusCode::FAILURE;
+    status.debugMessage = strerror(-size);
+  }
+  _hidl_cb(status, coolingDevices);
+  return Void();
 }
 
 IThermal* HIDL_FETCH_IThermal(const char* /* name */) {
-    thermal_module_t* module;
-    status_t err = hw_get_module(THERMAL_HARDWARE_MODULE_ID,
-            const_cast<hw_module_t const**>(reinterpret_cast<hw_module_t**>(&module)));
-    if (err || !module) {
-        ALOGE("Couldn't load %s module (%s)", THERMAL_HARDWARE_MODULE_ID,
-              strerror(-err));
-    }
+  thermal_module_t* module;
+  status_t err = hw_get_module(THERMAL_HARDWARE_MODULE_ID,
+                               const_cast<hw_module_t const**>(
+                                   reinterpret_cast<hw_module_t**>(&module)));
+  if (err || !module) {
+    ALOGE("Couldn't load %s module (%s)", THERMAL_HARDWARE_MODULE_ID,
+          strerror(-err));
+  }
 
-    if (err == 0 && module->common.methods->open) {
-        struct hw_device_t* device;
-        err = module->common.methods->open(&module->common, THERMAL_HARDWARE_MODULE_ID, &device);
-        if (err) {
-            ALOGE("Couldn't open %s module (%s)", THERMAL_HARDWARE_MODULE_ID, strerror(-err));
-        } else {
-            return new Thermal(reinterpret_cast<thermal_module_t*>(device));
-        }
+  if (err == 0 && module->common.methods->open) {
+    struct hw_device_t* device;
+    err = module->common.methods->open(&module->common,
+                                       THERMAL_HARDWARE_MODULE_ID, &device);
+    if (err) {
+      ALOGE("Couldn't open %s module (%s)", THERMAL_HARDWARE_MODULE_ID,
+            strerror(-err));
+    } else {
+      return new Thermal(reinterpret_cast<thermal_module_t*>(device));
     }
-    return new Thermal(module);
+  }
+  return new Thermal(module);
 }
 
-} // namespace implementation
+}  // namespace implementation
 }  // namespace V1_0
 }  // namespace thermal
 }  // namespace hardware
diff --git a/thermal/1.0/types.hal b/thermal/1.0/types.hal
index 26a0f6f..8864f43 100644
--- a/thermal/1.0/types.hal
+++ b/thermal/1.0/types.hal
@@ -26,7 +26,7 @@
     SKIN = 3,
 };
 
-enum CoolingType : int32_t {
+enum CoolingType : uint32_t {
     /** Fan cooling device speed in RPM. */
     FAN_RPM = 0,
 };
@@ -118,9 +118,9 @@
 
 enum ThermalStatusCode : uint32_t {
     /** No errors. */
-    SUCCESS,
+    SUCCESS = 0,
     /** Unknown failure occured. */
-    FAILURE
+    FAILURE = 1
 };
 
 /**
diff --git a/thermal/1.0/vts/Android.mk b/thermal/1.0/vts/Android.mk
new file mode 100644
index 0000000..c4655b4
--- /dev/null
+++ b/thermal/1.0/vts/Android.mk
@@ -0,0 +1,86 @@
+#
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+# build VTS driver for Thermal v1.0.
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libvts_driver_hidl_thermal@1.0
+
+LOCAL_SRC_FILES := \
+  Thermal.vts \
+  types.vts \
+
+LOCAL_C_INCLUDES := \
+  android.hardware.thermal@1.0 \
+  system/core/base/include \
+  system/core/include \
+
+LOCAL_SHARED_LIBRARIES += \
+  android.hardware.thermal@1.0 \
+  libbase \
+  libutils \
+  libcutils \
+  liblog \
+  libhidlbase \
+  libhidltransport \
+  libhwbinder \
+  libprotobuf-cpp-full \
+  libvts_common \
+  libvts_datatype \
+  libvts_measurement \
+  libvts_multidevice_proto \
+
+LOCAL_STATIC_LIBRARIES := \
+
+LOCAL_PROTOC_OPTIMIZE_TYPE := full
+
+LOCAL_MULTILIB := both
+
+include $(BUILD_SHARED_LIBRARY)
+
+# build profiler for thermal.
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libvts_profiler_hidl_thermal@1.0
+
+LOCAL_SRC_FILES := \
+   Thermal.vts \
+   types.vts \
+
+LOCAL_C_INCLUDES += \
+  test/vts/drivers/libprofiling \
+
+LOCAL_VTS_MODE := PROFILER
+
+LOCAL_SHARED_LIBRARIES := \
+   android.hardware.thermal@1.0 \
+   libbase \
+   libcutils \
+   liblog \
+   libhidlbase \
+   libhidltransport \
+   libhwbinder \
+   libprotobuf-cpp-full \
+   libvts_common \
+   libvts_multidevice_proto \
+   libvts_profiling \
+   libutils \
+
+LOCAL_PROTOC_OPTIMIZE_TYPE := full
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/thermal/1.0/vts/Thermal.vts b/thermal/1.0/vts/Thermal.vts
new file mode 100644
index 0000000..e76d943
--- /dev/null
+++ b/thermal/1.0/vts/Thermal.vts
@@ -0,0 +1,82 @@
+component_class: HAL_HIDL
+component_type_version: 1.0
+component_name: "IThermal"
+
+package: "android.hardware.thermal"
+
+import: "android.hardware.thermal@1.0::types"
+
+interface: {
+    api: {
+        name: "getTemperatures"
+        return_type_hidl: {
+            type: TYPE_STRUCT
+            predefined_type: "::android::hardware::thermal::V1_0::ThermalStatus"
+        }
+        return_type_hidl: {
+            type: TYPE_VECTOR
+            vector_value: {
+                type: TYPE_STRUCT
+                predefined_type: "::android::hardware::thermal::V1_0::Temperature"
+            }
+        }
+        callflow: {
+            next: "*"
+        }
+        callflow: {
+            entry: true
+        }
+        callflow: {
+            exit: true
+        }
+    }
+
+    api: {
+        name: "getCpuUsages"
+        return_type_hidl: {
+            type: TYPE_STRUCT
+            predefined_type: "::android::hardware::thermal::V1_0::ThermalStatus"
+        }
+        return_type_hidl: {
+            type: TYPE_VECTOR
+            vector_value: {
+                type: TYPE_STRUCT
+                predefined_type: "::android::hardware::thermal::V1_0::CpuUsage"
+            }
+        }
+        callflow: {
+            next: "*"
+        }
+        callflow: {
+            entry: true
+        }
+        callflow: {
+            exit: true
+        }
+    }
+
+    api: {
+        name: "getCoolingDevices"
+        return_type_hidl: {
+            type: TYPE_STRUCT
+            predefined_type: "::android::hardware::thermal::V1_0::ThermalStatus"
+        }
+        return_type_hidl: {
+            type: TYPE_VECTOR
+            vector_value: {
+                type: TYPE_STRUCT
+                predefined_type: "::android::hardware::thermal::V1_0::CoolingDevice"
+            }
+        }
+        callflow: {
+            next: "*"
+        }
+        callflow: {
+            entry: true
+        }
+        callflow: {
+            exit: true
+        }
+    }
+
+}
diff --git a/thermal/1.0/vts/functional/Android.bp b/thermal/1.0/vts/functional/Android.bp
new file mode 100644
index 0000000..fedb760
--- /dev/null
+++ b/thermal/1.0/vts/functional/Android.bp
@@ -0,0 +1,38 @@
+//
+// 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: "thermal_hidl_hal_test",
+    gtest: true,
+    srcs: ["thermal_hidl_hal_test.cpp"],
+    shared_libs: [
+        "libbase",
+        "liblog",
+        "libcutils",
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libnativehelper",
+        "libutils",
+        "android.hardware.thermal@1.0",
+    ],
+    static_libs: ["libgtest"],
+    cflags: [
+        "-O0",
+        "-g",
+    ],
+}
+
diff --git a/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp b/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp
new file mode 100644
index 0000000..e3b00ab
--- /dev/null
+++ b/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp
@@ -0,0 +1,219 @@
+/*
+ * 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.
+ */
+
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <vector>
+
+#define LOG_TAG "thermal_hidl_hal_test"
+
+#include <android-base/logging.h>
+#include <android/hardware/thermal/1.0/IThermal.h>
+#include <android/hardware/thermal/1.0/types.h>
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::thermal::V1_0::CoolingDevice;
+using ::android::hardware::thermal::V1_0::CpuUsage;
+using ::android::hardware::thermal::V1_0::IThermal;
+using ::android::hardware::thermal::V1_0::Temperature;
+using ::android::hardware::thermal::V1_0::TemperatureType;
+using ::android::hardware::thermal::V1_0::ThermalStatus;
+using ::android::hardware::thermal::V1_0::ThermalStatusCode;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::sp;
+
+#define THERMAL_SERVICE_NAME "thermal"
+#define MONITORING_OPERATION_NUMBER 10
+
+#define UNDEFINED_TEMPERATURE (-FLT_MAX)
+
+#define MAX_DEVICE_TEMPERATURE 200
+#define MAX_FAN_SPEED 20000
+
+// The main test class for THERMAL HIDL HAL.
+class ThermalHidlTest : public ::testing::Test {
+ public:
+  virtual void SetUp() override {
+    thermal_ = IThermal::getService(THERMAL_SERVICE_NAME, false);
+    ASSERT_NE(thermal_, nullptr);
+    baseSize_ = 0;
+    names_.clear();
+  }
+
+  virtual void TearDown() override {}
+
+ protected:
+  // Check validity of temperatures returned by Thremal HAL.
+  void checkTemperatures(const hidl_vec<Temperature> temperatures) {
+    size_t size = temperatures.size();
+    EXPECT_LE(baseSize_, size);
+
+    for (size_t i = 0; i < size; ++i) {
+      checkDeviceTemperature(temperatures[i]);
+      if (i < baseSize_) {
+        EXPECT_EQ(names_[i], temperatures[i].name.c_str());
+      } else {
+        // Names must be unique.
+        EXPECT_EQ(names_.end(), std::find(names_.begin(), names_.end(),
+                                          temperatures[i].name.c_str()));
+        names_.push_back(temperatures[i].name);
+      }
+    }
+    baseSize_ = size;
+  }
+
+  // Check validity of CPU usages returned by Thermal HAL.
+  void checkCpuUsages(const hidl_vec<CpuUsage>& cpuUsages) {
+    size_t size = cpuUsages.size();
+    // A number of CPU's does not change.
+    if (baseSize_ != 0) EXPECT_EQ(baseSize_, size);
+
+    for (size_t i = 0; i < size; ++i) {
+      checkCpuUsage(cpuUsages[i]);
+      if (i < baseSize_) {
+        EXPECT_EQ(names_[i], cpuUsages[i].name.c_str());
+      } else {
+        // Names must be unique.
+        EXPECT_EQ(names_.end(), std::find(names_.begin(), names_.end(),
+                                          cpuUsages[i].name.c_str()));
+        names_.push_back(cpuUsages[i].name);
+      }
+    }
+    baseSize_ = size;
+  }
+
+  // Check validity of cooling devices information returned by Thermal HAL.
+  void checkCoolingDevices(const hidl_vec<CoolingDevice> coolingDevices) {
+    size_t size = coolingDevices.size();
+    EXPECT_LE(baseSize_, size);
+
+    for (size_t i = 0; i < size; ++i) {
+      checkCoolingDevice(coolingDevices[i]);
+      if (i < baseSize_) {
+        EXPECT_EQ(names_[i], coolingDevices[i].name.c_str());
+      } else {
+        // Names must be unique.
+        EXPECT_EQ(names_.end(), std::find(names_.begin(), names_.end(),
+                                          coolingDevices[i].name.c_str()));
+        names_.push_back(coolingDevices[i].name);
+      }
+    }
+    baseSize_ = size;
+  }
+
+  sp<IThermal> thermal_;
+
+ private:
+  // Check validity of temperature returned by Thermal HAL.
+  void checkDeviceTemperature(const Temperature& temperature) {
+    // .currentValue of known type is in Celsius and must be reasonable.
+    EXPECT_TRUE(temperature.type == TemperatureType::UNKNOWN ||
+                std::abs(temperature.currentValue) < MAX_DEVICE_TEMPERATURE ||
+                temperature.currentValue == UNDEFINED_TEMPERATURE);
+
+    // .name must not be empty.
+    EXPECT_LT(0u, temperature.name.size());
+
+    // .currentValue must not exceed .shutdwonThreshold if defined.
+    EXPECT_TRUE(temperature.currentValue < temperature.shutdownThreshold ||
+                temperature.currentValue == UNDEFINED_TEMPERATURE ||
+                temperature.shutdownThreshold == UNDEFINED_TEMPERATURE);
+
+    // .throttlingThreshold must not exceed .shutdownThreshold if defined.
+    EXPECT_TRUE(temperature.throttlingThreshold <
+                    temperature.shutdownThreshold ||
+                temperature.throttlingThreshold == UNDEFINED_TEMPERATURE ||
+                temperature.shutdownThreshold == UNDEFINED_TEMPERATURE);
+  }
+
+  // Check validity of CPU usage returned by Thermal HAL.
+  void checkCpuUsage(const CpuUsage& cpuUsage) {
+    // .active must be less than .total if CPU is online.
+    EXPECT_TRUE(!cpuUsage.isOnline ||
+                (cpuUsage.active >= 0 && cpuUsage.total >= 0 &&
+                 cpuUsage.total >= cpuUsage.active));
+
+    // .name must be not empty.
+    EXPECT_LT(0u, cpuUsage.name.size());
+  }
+
+  // Check validity of a cooling device information returned by Thermal HAL.
+  void checkCoolingDevice(const CoolingDevice& coolingDevice) {
+    EXPECT_LE(0, coolingDevice.currentValue);
+    EXPECT_GT(MAX_FAN_SPEED, coolingDevice.currentValue);
+    EXPECT_LT(0u, coolingDevice.name.size());
+  }
+
+  size_t baseSize_;
+  std::vector<hidl_string> names_;
+};
+
+// Sanity test for Thermal::getTemperatures().
+TEST_F(ThermalHidlTest, TemperatureTest) {
+  hidl_vec<Temperature> passed;
+  for (size_t i = 0; i < MONITORING_OPERATION_NUMBER; ++i) {
+    thermal_->getTemperatures(
+        [&passed](ThermalStatus status, hidl_vec<Temperature> temperatures) {
+          EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code);
+          passed = temperatures;
+        });
+
+    checkTemperatures(passed);
+    sleep(1);
+  }
+}
+
+// Sanity test for Thermal::getCpuUsages().
+TEST_F(ThermalHidlTest, CpuUsageTest) {
+  hidl_vec<CpuUsage> passed;
+  for (size_t i = 0; i < MONITORING_OPERATION_NUMBER; ++i) {
+    thermal_->getCpuUsages(
+        [&passed](ThermalStatus status, hidl_vec<CpuUsage> cpuUsages) {
+          EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code);
+          passed = cpuUsages;
+        });
+
+    checkCpuUsages(passed);
+    sleep(1);
+  }
+}
+
+// Sanity test for Thermal::getCoolingDevices().
+TEST_F(ThermalHidlTest, CoolingDeviceTest) {
+  hidl_vec<CoolingDevice> passed;
+  for (size_t i = 0; i < MONITORING_OPERATION_NUMBER; ++i) {
+    thermal_->getCoolingDevices([&passed](
+        ThermalStatus status, hidl_vec<CoolingDevice> coolingDevices) {
+      EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code);
+      passed = coolingDevices;
+    });
+
+    checkCoolingDevices(passed);
+    sleep(1);
+  }
+}
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  int status = RUN_ALL_TESTS();
+  ALOGI("Test result = %d", status);
+  return status;
+}
diff --git a/thermal/1.0/vts/types.vts b/thermal/1.0/vts/types.vts
new file mode 100644
index 0000000..1e60f48
--- /dev/null
+++ b/thermal/1.0/vts/types.vts
@@ -0,0 +1,157 @@
+component_class: HAL_HIDL
+component_type_version: 1.0
+component_name: "types"
+
+package: "android.hardware.thermal"
+
+
+attribute: {
+    name: "::android::hardware::thermal::V1_0::TemperatureType"
+    type: TYPE_ENUM
+    enum_value: {
+        scalar_type: "uint32_t"
+
+        enumerator: "UNKNOWN"
+        scalar_value: {
+            uint32_t: 1000
+        }
+        enumerator: "CPU"
+        scalar_value: {
+            uint32_t: 0
+        }
+        enumerator: "GPU"
+        scalar_value: {
+            uint32_t: 1
+        }
+        enumerator: "BATTERY"
+        scalar_value: {
+            uint32_t: 2
+        }
+        enumerator: "SKIN"
+        scalar_value: {
+            uint32_t: 3
+        }
+    }
+}
+
+attribute: {
+    name: "::android::hardware::thermal::V1_0::CoolingType"
+    type: TYPE_ENUM
+    enum_value: {
+        scalar_type: "uint32_t"
+
+        enumerator: "FAN_RPM"
+        scalar_value: {
+            uint32_t: 0
+        }
+    }
+}
+
+attribute: {
+    name: "::android::hardware::thermal::V1_0::Temperature"
+    type: TYPE_STRUCT
+    struct_value: {
+        name: "type"
+        type: TYPE_ENUM
+        predefined_type: "::android::hardware::thermal::V1_0::TemperatureType"
+    }
+    struct_value: {
+        name: "name"
+        type: TYPE_STRING
+    }
+    struct_value: {
+        name: "currentValue"
+        type: TYPE_SCALAR
+        scalar_type: "float_t"
+    }
+    struct_value: {
+        name: "throttlingThreshold"
+        type: TYPE_SCALAR
+        scalar_type: "float_t"
+    }
+    struct_value: {
+        name: "shutdownThreshold"
+        type: TYPE_SCALAR
+        scalar_type: "float_t"
+    }
+    struct_value: {
+        name: "vrThrottlingThreshold"
+        type: TYPE_SCALAR
+        scalar_type: "float_t"
+    }
+}
+
+attribute: {
+    name: "::android::hardware::thermal::V1_0::CoolingDevice"
+    type: TYPE_STRUCT
+    struct_value: {
+        name: "type"
+        type: TYPE_ENUM
+        predefined_type: "::android::hardware::thermal::V1_0::CoolingType"
+    }
+    struct_value: {
+        name: "name"
+        type: TYPE_STRING
+    }
+    struct_value: {
+        name: "currentValue"
+        type: TYPE_SCALAR
+        scalar_type: "float_t"
+    }
+}
+
+attribute: {
+    name: "::android::hardware::thermal::V1_0::CpuUsage"
+    type: TYPE_STRUCT
+    struct_value: {
+        name: "name"
+        type: TYPE_STRING
+    }
+    struct_value: {
+        name: "active"
+        type: TYPE_SCALAR
+        scalar_type: "uint64_t"
+    }
+    struct_value: {
+        name: "total"
+        type: TYPE_SCALAR
+        scalar_type: "uint64_t"
+    }
+    struct_value: {
+        name: "isOnline"
+        type: TYPE_SCALAR
+        scalar_type: "bool_t"
+    }
+}
+
+attribute: {
+    name: "::android::hardware::thermal::V1_0::ThermalStatusCode"
+    type: TYPE_ENUM
+    enum_value: {
+        scalar_type: "uint32_t"
+
+        enumerator: "SUCCESS"
+        scalar_value: {
+            uint32_t: 0
+        }
+        enumerator: "FAILURE"
+        scalar_value: {
+            uint32_t: 1
+        }
+    }
+}
+
+attribute: {
+    name: "::android::hardware::thermal::V1_0::ThermalStatus"
+    type: TYPE_STRUCT
+    struct_value: {
+        name: "code"
+        type: TYPE_ENUM
+        predefined_type: "::android::hardware::thermal::V1_0::ThermalStatusCode"
+    }
+    struct_value: {
+        name: "debugMessage"
+        type: TYPE_STRING
+    }
+}
+
diff --git a/thermal/Android.bp b/thermal/Android.bp
index ba90f2c..ed19a37 100644
--- a/thermal/Android.bp
+++ b/thermal/Android.bp
@@ -2,4 +2,5 @@
 subdirs = [
     "1.0",
     "1.0/default",
+    "1.0/vts/functional",
 ]
diff --git a/tv/cec/1.0/Android.bp b/tv/cec/1.0/Android.bp
index bb1ae82..02a4247 100644
--- a/tv/cec/1.0/Android.bp
+++ b/tv/cec/1.0/Android.bp
@@ -46,13 +46,15 @@
     generated_headers: ["android.hardware.tv.cec@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tv.cec@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/tv/cec/1.0/Android.mk b/tv/cec/1.0/Android.mk
index 8cc9c47..5d6f03f 100644
--- a/tv/cec/1.0/Android.mk
+++ b/tv/cec/1.0/Android.mk
@@ -149,6 +149,23 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build types.hal (MaxLength)
+#
+GEN := $(intermediates)/android/hardware/tv/cec/1.0/MaxLength.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 \
+        android.hardware.tv.cec@1.0::types.MaxLength
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build types.hal (OptionKey)
 #
 GEN := $(intermediates)/android/hardware/tv/cec/1.0/OptionKey.java
@@ -388,6 +405,23 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build types.hal (MaxLength)
+#
+GEN := $(intermediates)/android/hardware/tv/cec/1.0/MaxLength.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 \
+        android.hardware.tv.cec@1.0::types.MaxLength
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build types.hal (OptionKey)
 #
 GEN := $(intermediates)/android/hardware/tv/cec/1.0/OptionKey.java
diff --git a/tv/cec/1.0/default/Android.mk b/tv/cec/1.0/default/Android.mk
index 3971f6c..492fc8c 100644
--- a/tv/cec/1.0/default/Android.mk
+++ b/tv/cec/1.0/default/Android.mk
@@ -7,7 +7,8 @@
     HdmiCec.cpp
 
 LOCAL_SHARED_LIBRARIES := \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     liblog \
     libbase \
@@ -36,7 +37,8 @@
 
 LOCAL_SHARED_LIBRARIES += \
     libhwbinder \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     android.hardware.tv.cec@1.0 \
 
 include $(BUILD_EXECUTABLE)
diff --git a/tv/cec/1.0/default/HdmiCec.h b/tv/cec/1.0/default/HdmiCec.h
index 49237d5..a41a5f0 100644
--- a/tv/cec/1.0/default/HdmiCec.h
+++ b/tv/cec/1.0/default/HdmiCec.h
@@ -63,7 +63,7 @@
     Return<void> enableAudioReturnChannel(int32_t portId, bool enable)  override;
     Return<bool> isConnected(int32_t portId)  override;
 
-    static void eventCallback(const hdmi_event_t* event, void* arg) {
+    static void eventCallback(const hdmi_event_t* event, void* /* arg */) {
         if (mCallback != nullptr && event != nullptr) {
             if (event->type == HDMI_EVENT_CEC_MESSAGE) {
                 size_t length = std::min(event->cec.length,
diff --git a/tv/input/1.0/Android.bp b/tv/input/1.0/Android.bp
index 512634b..7f9bb7c 100644
--- a/tv/input/1.0/Android.bp
+++ b/tv/input/1.0/Android.bp
@@ -46,14 +46,16 @@
     generated_headers: ["android.hardware.tv.input@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.tv.input@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
         "android.hardware.audio.common@2.0",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "android.hardware.audio.common@2.0",
diff --git a/tv/input/1.0/default/Android.mk b/tv/input/1.0/default/Android.mk
index 520b0bf..9728015 100644
--- a/tv/input/1.0/default/Android.mk
+++ b/tv/input/1.0/default/Android.mk
@@ -10,7 +10,8 @@
     libbase \
     liblog \
     libhardware \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     libutils \
     android.hardware.audio.common@2.0 \
@@ -36,7 +37,8 @@
 
 LOCAL_SHARED_LIBRARIES += \
     libhwbinder \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     android.hardware.audio.common@2.0 \
     android.hardware.tv.input@1.0 \
 
diff --git a/vehicle/2.0/Android.bp b/vehicle/2.0/Android.bp
index d51fe25..09025b9 100644
--- a/vehicle/2.0/Android.bp
+++ b/vehicle/2.0/Android.bp
@@ -46,13 +46,15 @@
     generated_headers: ["android.hardware.vehicle@2.0_genc++_headers"],
     export_generated_headers: ["android.hardware.vehicle@2.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/vehicle/2.0/IVehicleCallback.hal b/vehicle/2.0/IVehicleCallback.hal
index 504f782..e7e05bf 100644
--- a/vehicle/2.0/IVehicleCallback.hal
+++ b/vehicle/2.0/IVehicleCallback.hal
@@ -32,7 +32,7 @@
     oneway onPropertyEvent(vec<VehiclePropValue> propValues);
 
     /*
-     * This method gets called if the client was susbscribed to a property using
+     * This method gets called if the client was subscribed to a property using
      * SubscribeFlags::SET_CALL flag and IVehicle#set(...) method was called.
      *
      * These events must be delivered to subscriber immediately without any
diff --git a/vehicle/2.0/default/Android.mk b/vehicle/2.0/default/Android.mk
index 90353ee..46733e5 100644
--- a/vehicle/2.0/default/Android.mk
+++ b/vehicle/2.0/default/Android.mk
@@ -28,7 +28,8 @@
 LOCAL_SHARED_LIBRARIES := \
     liblog \
     libbinder \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     libutils \
     $(module_prefix) \
@@ -47,7 +48,8 @@
 LOCAL_SHARED_LIBRARIES := \
     liblog \
     libbinder \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     libutils \
     $(module_prefix) \
@@ -73,7 +75,8 @@
 LOCAL_SHARED_LIBRARIES := \
     liblog \
     libbinder \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     libutils \
     $(module_prefix) \
@@ -89,8 +92,8 @@
 ###############################################################################
 include $(CLEAR_VARS)
 LOCAL_MODULE := $(module_prefix)-service
+LOCAL_INIT_RC := $(module_prefix)-service.rc
 LOCAL_MODULE_RELATIVE_PATH := hw
-# TODO(pavelm): add LOCAL_INIT_RC
 
 LOCAL_SRC_FILES := \
     VehicleService.cpp
@@ -102,7 +105,8 @@
 LOCAL_SHARED_LIBRARIES := \
     liblog \
     libbinder \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     libutils \
     android.hardware.vehicle@2.0
diff --git a/vehicle/2.0/default/android.hardware.vehicle@2.0-service.rc b/vehicle/2.0/default/android.hardware.vehicle@2.0-service.rc
new file mode 100644
index 0000000..7c96da6
--- /dev/null
+++ b/vehicle/2.0/default/android.hardware.vehicle@2.0-service.rc
@@ -0,0 +1,4 @@
+service vehicle-hal-2.0 /system/bin/hw/android.hardware.vehicle@2.0-service
+    class hal
+    user system
+    group system
diff --git a/vehicle/2.0/default/impl/DefaultConfig.h b/vehicle/2.0/default/impl/DefaultConfig.h
index e620c28..7985737 100644
--- a/vehicle/2.0/default/impl/DefaultConfig.h
+++ b/vehicle/2.0/default/impl/DefaultConfig.h
@@ -18,6 +18,7 @@
 #define android_hardware_vehicle_V2_0_impl_DefaultConfig_H_
 
 #include <android/hardware/vehicle/2.0/IVehicle.h>
+#include <vehicle_hal_manager/VehicleUtils.h>
 
 namespace android {
 namespace hardware {
@@ -35,23 +36,102 @@
     },
 
     {
+        .prop = VehicleProperty::HVAC_POWER_ON,
+        .access = VehiclePropertyAccess::READ_WRITE,
+        .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+        .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
+        .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+    },
+
+    {
+        .prop = VehicleProperty::HVAC_DEFROSTER,
+        .access = VehiclePropertyAccess::READ_WRITE,
+        .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+        .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
+        .supportedAreas =
+                VehicleAreaWindow::FRONT_WINDSHIELD
+                | VehicleAreaWindow::REAR_WINDSHIELD
+    },
+
+    {
+        .prop = VehicleProperty::HVAC_RECIRC_ON,
+        .access = VehiclePropertyAccess::READ_WRITE,
+        .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+        .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
+        .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+    },
+
+    {
+        .prop = VehicleProperty::HVAC_AC_ON,
+        .access = VehiclePropertyAccess::READ_WRITE,
+        .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+        .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
+        .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+    },
+
+    {
+        .prop = VehicleProperty::HVAC_AUTO_ON,
+        .access = VehiclePropertyAccess::READ_WRITE,
+        .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+        .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
+        .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+    },
+
+    {
         .prop = VehicleProperty::HVAC_FAN_SPEED,
         .access = VehiclePropertyAccess::READ_WRITE,
         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
         .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
-        .supportedAreas = static_cast<int32_t>(
-            VehicleAreaZone::ROW_1_LEFT | VehicleAreaZone::ROW_1_RIGHT),
+        .supportedAreas = toInt(VehicleAreaZone::ROW_1),
         .areaConfigs = init_hidl_vec({
-                 VehicleAreaConfig {
-                     .areaId = toInt(VehicleAreaZone::ROW_2_LEFT),
-                     .minInt32Value = 1,
-                     .maxInt32Value = 7},
-                 VehicleAreaConfig {
-                     .areaId = toInt(VehicleAreaZone::ROW_1_RIGHT),
-                     .minInt32Value = 1,
-                     .maxInt32Value = 5,
-                 }
-             }),
+                VehicleAreaConfig {
+                    .areaId = toInt(VehicleAreaZone::ROW_1),
+                    .minInt32Value = 1,
+                    .maxInt32Value = 7
+                }})
+    },
+
+    {
+        .prop = VehicleProperty::HVAC_FAN_DIRECTION,
+        .access = VehiclePropertyAccess::READ_WRITE,
+        .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+        .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
+        .supportedAreas = toInt(VehicleAreaZone::ROW_1),
+    },
+
+    {
+        .prop = VehicleProperty::HVAC_TEMPERATURE_SET,
+        .access = VehiclePropertyAccess::READ_WRITE,
+        .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+        .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
+        .supportedAreas =
+                VehicleAreaZone::ROW_1_LEFT
+                | VehicleAreaZone::ROW_1_RIGHT,
+        .areaConfigs = init_hidl_vec({
+            VehicleAreaConfig {
+                .areaId = toInt(VehicleAreaZone::ROW_1_LEFT),
+                .minFloatValue = 16,
+                .maxFloatValue = 32,
+            },
+            VehicleAreaConfig {
+                .areaId = toInt(VehicleAreaZone::ROW_1_RIGHT),
+                .minFloatValue = 16,
+                .maxFloatValue = 32,
+            }})
+    },
+
+    {
+        .prop = VehicleProperty::NIGHT_MODE,
+        .access = VehiclePropertyAccess::READ,
+        .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+        .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
+    },
+
+    {
+        .prop = VehicleProperty::GEAR_SELECTION,
+        .access = VehiclePropertyAccess::READ,
+        .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+        .permissionModel = VehiclePermissionModel::NO_RESTRICTION,
     },
 
     {
diff --git a/vehicle/2.0/default/impl/DefaultVehicleHal.cpp b/vehicle/2.0/default/impl/DefaultVehicleHal.cpp
index 24d438d..c56248b 100644
--- a/vehicle/2.0/default/impl/DefaultVehicleHal.cpp
+++ b/vehicle/2.0/default/impl/DefaultVehicleHal.cpp
@@ -30,23 +30,56 @@
     VehiclePropValuePtr v;
     VehicleProperty property = requestedPropValue.prop;
     int32_t areaId = requestedPropValue.areaId;
+    auto& pool = *getValuePool();
 
     switch (property) {
         case VehicleProperty::INFO_MAKE:
-            v = getValuePool()->obtainString("Default Car");
+            v = pool.obtainString("Default Car");
             break;
         case VehicleProperty::HVAC_FAN_SPEED:
-            int32_t value;
-            *outStatus = getHvacFanSpeed(areaId, &value);
+            v = pool.obtainInt32(mFanSpeed);
+            break;
+        case VehicleProperty::HVAC_POWER_ON:
+            v = pool.obtainBoolean(mHvacPowerOn);
+            break;
+        case VehicleProperty::HVAC_RECIRC_ON:
+            v = pool.obtainBoolean(mHvacRecircOn);
+            break;
+        case VehicleProperty::HVAC_AC_ON:
+            v = pool.obtainBoolean(mHvacAcOn);
+            break;
+        case VehicleProperty::HVAC_AUTO_ON:
+            v = pool.obtainBoolean(mHvacAutoOn);
+            break;
+        case VehicleProperty::HVAC_FAN_DIRECTION:
+            v = pool.obtainInt32(toInt(mFanDirection));
+            break;
+        case VehicleProperty::HVAC_DEFROSTER:
+            bool defroster;
+            *outStatus = getHvacDefroster(areaId, &defroster);
             if (StatusCode::OK == *outStatus) {
-                v = getValuePool()->obtainInt32(value);
+                v = pool.obtainBoolean(defroster);
+            }
+            break;
+        case VehicleProperty::HVAC_TEMPERATURE_SET:
+            float value;
+            *outStatus = getHvacTemperature(requestedPropValue.areaId,
+                                            &value);
+            if (StatusCode::OK == *outStatus) {
+                v = pool.obtainFloat(value);
             }
             break;
         case VehicleProperty::INFO_FUEL_CAPACITY:
-            v = getValuePool()->obtainFloat(0.75f);
+            v = pool.obtainFloat(0.75f);
             break;
         case VehicleProperty::DISPLAY_BRIGHTNESS:
-            v = getValuePool()->obtainInt32(brightness);
+            v = pool.obtainInt32(mBrightness);
+            break;
+        case VehicleProperty::NIGHT_MODE:
+            v = pool.obtainBoolean(false);
+            break;
+        case VehicleProperty::GEAR_SELECTION:
+            v = pool.obtainInt32(toInt(VehicleGear::GEAR_PARK));
             break;
         default:
             *outStatus = StatusCode::INVALID_ARG;
@@ -63,16 +96,38 @@
 
 StatusCode DefaultVehicleHal::set(const VehiclePropValue& propValue) {
     auto property = propValue.prop;
+    const auto& v = propValue.value;
 
     StatusCode status = StatusCode::OK;
 
     switch (property) {
+        case VehicleProperty::HVAC_POWER_ON:
+            mHvacPowerOn = v.int32Values[0] == 1;
+            break;
+        case VehicleProperty::HVAC_RECIRC_ON:
+            mHvacRecircOn = v.int32Values[0] == 1;
+            break;
+        case VehicleProperty::HVAC_AC_ON:
+            mHvacAcOn = v.int32Values[0] == 1;
+            break;
+        case VehicleProperty::HVAC_AUTO_ON:
+            mHvacAutoOn = v.int32Values[0] == 1;
+            break;
+        case VehicleProperty::HVAC_DEFROSTER:
+            status = setHvacDefroster(propValue.areaId, v.int32Values[0] == 1);
+            break;
+        case VehicleProperty::HVAC_FAN_DIRECTION:
+            mFanDirection =
+                    static_cast<VehicleHvacFanDirection>(v.int32Values[0]);
+            break;
         case VehicleProperty::HVAC_FAN_SPEED:
-            status = setHvacFanSpeed(propValue.areaId,
-                                     propValue.value.int32Values[0]);
+            mFanSpeed = v.int32Values[0];
+            break;
+        case VehicleProperty::HVAC_TEMPERATURE_SET:
+            status = setHvacTemperature(propValue.areaId, v.floatValues[0]);
             break;
         case VehicleProperty::DISPLAY_BRIGHTNESS:
-            brightness = propValue.value.int32Values[0];
+            mBrightness = v.int32Values[0];
             break;
         default:
             status = StatusCode::INVALID_ARG;
@@ -81,23 +136,52 @@
     return status;
 }
 
-StatusCode DefaultVehicleHal::getHvacFanSpeed(int32_t areaId,
-                                            int32_t* outValue)  {
+StatusCode DefaultVehicleHal::getHvacTemperature(int32_t areaId,
+                                                 float* outValue)  {
     if (areaId == toInt(VehicleAreaZone::ROW_1_LEFT)) {
-        *outValue = fanSpeedRow1Left;
-    } else if (areaId == toInt(VehicleAreaZone::ROW_2_RIGHT)) {
-        *outValue = fanSpeedRow1Right;
+        *outValue = mRow1LeftHvacTemperatureSet;
+    } else if (areaId == toInt(VehicleAreaZone::ROW_1_RIGHT)) {
+        *outValue = mRow1RightHvacTemperatureSet;
     } else {
         return StatusCode::INVALID_ARG;
     }
     return StatusCode::OK;
 }
 
-StatusCode DefaultVehicleHal::setHvacFanSpeed(int32_t areaId, int32_t value) {
+StatusCode DefaultVehicleHal::setHvacTemperature(
+    int32_t areaId, float value) {
     if (areaId == toInt(VehicleAreaZone::ROW_1_LEFT)) {
-        fanSpeedRow1Left = value;
-    } else if (areaId == toInt(VehicleAreaZone::ROW_2_RIGHT)) {
-        fanSpeedRow1Right = value;
+        mRow1LeftHvacTemperatureSet = value;
+    } else if (areaId == toInt(VehicleAreaZone::ROW_1_RIGHT)) {
+        mRow1RightHvacTemperatureSet = value;
+    } else {
+        return StatusCode::INVALID_ARG;
+    }
+    return StatusCode::OK;
+}
+
+StatusCode DefaultVehicleHal::getHvacDefroster(int32_t areaId,
+                                               bool* outValue) {
+    ALOGI("Getting Hvac defroster for area: 0x%x", areaId);
+
+    if (areaId == toInt(VehicleAreaWindow::FRONT_WINDSHIELD)) {
+        *outValue = mFrontDefroster;
+    } else if (areaId == toInt(VehicleAreaWindow::REAR_WINDSHIELD)) {
+        *outValue = mRearDefroster;
+    } else {
+        ALOGE("Unable to get hvac defroster for area: 0x%x", areaId);
+        return StatusCode::INVALID_ARG;
+    }
+
+    ALOGI("Getting Hvac defroster for area: 0x%x, OK", areaId);
+    return StatusCode::OK;
+}
+
+StatusCode DefaultVehicleHal::setHvacDefroster(int32_t areaId, bool value) {
+    if (areaId == toInt(VehicleAreaWindow::FRONT_WINDSHIELD)) {
+        mFrontDefroster = value;
+    } else if (areaId == toInt(VehicleAreaWindow::REAR_WINDSHIELD)) {
+        mRearDefroster = value;
     } else {
         return StatusCode::INVALID_ARG;
     }
diff --git a/vehicle/2.0/default/impl/DefaultVehicleHal.h b/vehicle/2.0/default/impl/DefaultVehicleHal.h
index 4a81da3..231f2b2 100644
--- a/vehicle/2.0/default/impl/DefaultVehicleHal.h
+++ b/vehicle/2.0/default/impl/DefaultVehicleHal.h
@@ -53,12 +53,22 @@
     }
 
 private:
-    StatusCode getHvacFanSpeed(int32_t areaId, int32_t* outValue);
-    StatusCode setHvacFanSpeed(int32_t areaId, int32_t value);
+    StatusCode getHvacTemperature(int32_t areaId, float* outValue);
+    StatusCode setHvacTemperature(int32_t areaId, float value);
+    StatusCode getHvacDefroster(int32_t areaId, bool* outValue);
+    StatusCode setHvacDefroster(int32_t areaId, bool value);
 private:
-    int32_t fanSpeedRow1Left = 3;
-    int32_t fanSpeedRow1Right = 5;
-    int32_t brightness = 7;
+    int32_t mFanSpeed = 3;
+    int32_t mBrightness = 7;
+    float mRow1LeftHvacTemperatureSet = 16;
+    float mRow1RightHvacTemperatureSet = 22;
+    bool mFrontDefroster = false;
+    bool mRearDefroster = false;
+    bool mHvacPowerOn = true;
+    bool mHvacRecircOn = true;
+    bool mHvacAcOn = true;
+    bool mHvacAutoOn = true;
+    VehicleHvacFanDirection mFanDirection = VehicleHvacFanDirection::FACE;
 };
 
 }  // impl
diff --git a/vibrator/1.0/Android.bp b/vibrator/1.0/Android.bp
index faf4341..bd88241 100644
--- a/vibrator/1.0/Android.bp
+++ b/vibrator/1.0/Android.bp
@@ -38,13 +38,15 @@
     generated_headers: ["android.hardware.vibrator@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.vibrator@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/vibrator/1.0/default/Android.bp b/vibrator/1.0/default/Android.bp
index 4dd00dd..5e488e6 100644
--- a/vibrator/1.0/default/Android.bp
+++ b/vibrator/1.0/default/Android.bp
@@ -17,7 +17,8 @@
     relative_install_path: "hw",
     srcs: ["Vibrator.cpp"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "liblog",
         "libhwbinder",
         "libutils",
diff --git a/vibrator/1.0/default/Android.mk b/vibrator/1.0/default/Android.mk
index 2b168bb..5ba334b 100644
--- a/vibrator/1.0/default/Android.mk
+++ b/vibrator/1.0/default/Android.mk
@@ -24,7 +24,8 @@
   service.cpp \
 
 LOCAL_SHARED_LIBRARIES := \
-  libhidl \
+  libhidlbase \
+  libhidltransport \
   liblog \
   libhwbinder \
   libutils \
diff --git a/vibrator/1.0/vts/Android.mk b/vibrator/1.0/vts/Android.mk
index bdecb85..2f612d5 100644
--- a/vibrator/1.0/vts/Android.mk
+++ b/vibrator/1.0/vts/Android.mk
@@ -25,18 +25,14 @@
   Vibrator.vts \
   types.vts \
 
-LOCAL_C_INCLUDES := \
-  android.hardware.vibrator@1.0 \
-  system/core/base/include \
-  system/core/include \
-
 LOCAL_SHARED_LIBRARIES += \
   android.hardware.vibrator@1.0 \
   libbase \
   libutils \
   libcutils \
   liblog \
-  libhidl \
+  libhidlbase \
+  libhidltransport \
   libhwbinder \
   libprotobuf-cpp-full \
   libvts_common \
@@ -44,10 +40,6 @@
   libvts_measurement \
   libvts_multidevice_proto \
 
-LOCAL_CFLAGS += -DENABLE_TREBLE
-
-LOCAL_STATIC_LIBRARIES := \
-
 LOCAL_PROTOC_OPTIMIZE_TYPE := full
 
 LOCAL_MULTILIB := both
@@ -73,7 +65,8 @@
    libbase \
    libcutils \
    liblog \
-   libhidl \
+   libhidlbase \
+   libhidltransport \
    libhwbinder \
    libprotobuf-cpp-full \
    libvts_common \
diff --git a/vr/1.0/Android.bp b/vr/1.0/Android.bp
index fc4619f..5cbd333 100644
--- a/vr/1.0/Android.bp
+++ b/vr/1.0/Android.bp
@@ -34,13 +34,15 @@
     generated_headers: ["android.hardware.vr@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.vr@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/vr/1.0/default/Android.bp b/vr/1.0/default/Android.bp
index 09b0002..d100570 100644
--- a/vr/1.0/default/Android.bp
+++ b/vr/1.0/default/Android.bp
@@ -10,7 +10,8 @@
         "libbase",
         "libcutils",
         "libutils",
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "android.hardware.vr@1.0",
     ],
 }
diff --git a/vr/1.0/vts/Android.mk b/vr/1.0/vts/Android.mk
index 3c45652..12f0175 100644
--- a/vr/1.0/vts/Android.mk
+++ b/vr/1.0/vts/Android.mk
@@ -24,18 +24,14 @@
 LOCAL_SRC_FILES := \
   Vr.vts \
 
-LOCAL_C_INCLUDES := \
-  android.hardware.vr@1.0 \
-  system/core/base/include \
-  system/core/include \
-
 LOCAL_SHARED_LIBRARIES += \
   android.hardware.vr@1.0 \
   libbase \
   libutils \
   libcutils \
   liblog \
-  libhidl \
+  libhidlbase \
+  libhidltransport \
   libhwbinder \
   libprotobuf-cpp-full \
   libvts_common \
@@ -43,10 +39,6 @@
   libvts_measurement \
   libvts_multidevice_proto \
 
-LOCAL_CFLAGS += -DENABLE_TREBLE
-
-LOCAL_STATIC_LIBRARIES := \
-
 LOCAL_PROTOC_OPTIMIZE_TYPE := full
 
 LOCAL_MULTILIB := both
@@ -71,7 +63,8 @@
    libbase \
    libcutils \
    liblog \
-   libhidl \
+   libhidlbase \
+   libhidltransport \
    libhwbinder \
    libprotobuf-cpp-full \
    libvts_common \
diff --git a/wifi/1.0/Android.bp b/wifi/1.0/Android.bp
index b730931..d353e4b 100644
--- a/wifi/1.0/Android.bp
+++ b/wifi/1.0/Android.bp
@@ -13,9 +13,12 @@
         "IWifiEventCallback.hal",
         "IWifiIface.hal",
         "IWifiNanIface.hal",
+        "IWifiNanIfaceEventCallback.hal",
         "IWifiP2pIface.hal",
         "IWifiRttController.hal",
+        "IWifiRttControllerEventCallback.hal",
         "IWifiStaIface.hal",
+        "IWifiStaIfaceEventCallback.hal",
     ],
     out: [
         "android/hardware/wifi/1.0/types.cpp",
@@ -26,9 +29,12 @@
         "android/hardware/wifi/1.0/WifiEventCallbackAll.cpp",
         "android/hardware/wifi/1.0/WifiIfaceAll.cpp",
         "android/hardware/wifi/1.0/WifiNanIfaceAll.cpp",
+        "android/hardware/wifi/1.0/WifiNanIfaceEventCallbackAll.cpp",
         "android/hardware/wifi/1.0/WifiP2pIfaceAll.cpp",
         "android/hardware/wifi/1.0/WifiRttControllerAll.cpp",
+        "android/hardware/wifi/1.0/WifiRttControllerEventCallbackAll.cpp",
         "android/hardware/wifi/1.0/WifiStaIfaceAll.cpp",
+        "android/hardware/wifi/1.0/WifiStaIfaceEventCallbackAll.cpp",
     ],
 }
 
@@ -45,9 +51,12 @@
         "IWifiEventCallback.hal",
         "IWifiIface.hal",
         "IWifiNanIface.hal",
+        "IWifiNanIfaceEventCallback.hal",
         "IWifiP2pIface.hal",
         "IWifiRttController.hal",
+        "IWifiRttControllerEventCallback.hal",
         "IWifiStaIface.hal",
+        "IWifiStaIfaceEventCallback.hal",
     ],
     out: [
         "android/hardware/wifi/1.0/types.h",
@@ -86,6 +95,11 @@
         "android/hardware/wifi/1.0/BnWifiNanIface.h",
         "android/hardware/wifi/1.0/BpWifiNanIface.h",
         "android/hardware/wifi/1.0/BsWifiNanIface.h",
+        "android/hardware/wifi/1.0/IWifiNanIfaceEventCallback.h",
+        "android/hardware/wifi/1.0/IHwWifiNanIfaceEventCallback.h",
+        "android/hardware/wifi/1.0/BnWifiNanIfaceEventCallback.h",
+        "android/hardware/wifi/1.0/BpWifiNanIfaceEventCallback.h",
+        "android/hardware/wifi/1.0/BsWifiNanIfaceEventCallback.h",
         "android/hardware/wifi/1.0/IWifiP2pIface.h",
         "android/hardware/wifi/1.0/IHwWifiP2pIface.h",
         "android/hardware/wifi/1.0/BnWifiP2pIface.h",
@@ -96,11 +110,21 @@
         "android/hardware/wifi/1.0/BnWifiRttController.h",
         "android/hardware/wifi/1.0/BpWifiRttController.h",
         "android/hardware/wifi/1.0/BsWifiRttController.h",
+        "android/hardware/wifi/1.0/IWifiRttControllerEventCallback.h",
+        "android/hardware/wifi/1.0/IHwWifiRttControllerEventCallback.h",
+        "android/hardware/wifi/1.0/BnWifiRttControllerEventCallback.h",
+        "android/hardware/wifi/1.0/BpWifiRttControllerEventCallback.h",
+        "android/hardware/wifi/1.0/BsWifiRttControllerEventCallback.h",
         "android/hardware/wifi/1.0/IWifiStaIface.h",
         "android/hardware/wifi/1.0/IHwWifiStaIface.h",
         "android/hardware/wifi/1.0/BnWifiStaIface.h",
         "android/hardware/wifi/1.0/BpWifiStaIface.h",
         "android/hardware/wifi/1.0/BsWifiStaIface.h",
+        "android/hardware/wifi/1.0/IWifiStaIfaceEventCallback.h",
+        "android/hardware/wifi/1.0/IHwWifiStaIfaceEventCallback.h",
+        "android/hardware/wifi/1.0/BnWifiStaIfaceEventCallback.h",
+        "android/hardware/wifi/1.0/BpWifiStaIfaceEventCallback.h",
+        "android/hardware/wifi/1.0/BsWifiStaIfaceEventCallback.h",
     ],
 }
 
@@ -110,13 +134,15 @@
     generated_headers: ["android.hardware.wifi@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.wifi@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/wifi/1.0/Android.mk b/wifi/1.0/Android.mk
index 58c487b..3a27ed8 100644
--- a/wifi/1.0/Android.mk
+++ b/wifi/1.0/Android.mk
@@ -13,40 +13,6 @@
 HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
 
 #
-# Build types.hal (CommandFailureReason)
-#
-GEN := $(intermediates)/android/hardware/wifi/1.0/CommandFailureReason.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 \
-        android.hardware.wifi@1.0::types.CommandFailureReason
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
-# Build types.hal (FailureReason)
-#
-GEN := $(intermediates)/android/hardware/wifi/1.0/FailureReason.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 \
-        android.hardware.wifi@1.0::types.FailureReason
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
 # Build types.hal (IfaceType)
 #
 GEN := $(intermediates)/android/hardware/wifi/1.0/IfaceType.java
@@ -64,6 +30,1995 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build types.hal (NanAvailDuration)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanAvailDuration.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 \
+        android.hardware.wifi@1.0::types.NanAvailDuration
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanBeaconSdfPayloadInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanBeaconSdfPayloadInd.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 \
+        android.hardware.wifi@1.0::types.NanBeaconSdfPayloadInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanBeaconSdfPayloadReceive)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanBeaconSdfPayloadReceive.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 \
+        android.hardware.wifi@1.0::types.NanBeaconSdfPayloadReceive
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanBeaconSdfPayloadRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanBeaconSdfPayloadRequest.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 \
+        android.hardware.wifi@1.0::types.NanBeaconSdfPayloadRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanCapabilitiesResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanCapabilitiesResponse.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 \
+        android.hardware.wifi@1.0::types.NanCapabilitiesResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanCapabilitiesResponseMsg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanCapabilitiesResponseMsg.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 \
+        android.hardware.wifi@1.0::types.NanCapabilitiesResponseMsg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanChannelIndex)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanChannelIndex.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 \
+        android.hardware.wifi@1.0::types.NanChannelIndex
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanConfigRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanConfigRequest.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 \
+        android.hardware.wifi@1.0::types.NanConfigRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanConnectionType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanConnectionType.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 \
+        android.hardware.wifi@1.0::types.NanConnectionType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathAppInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathAppInfo.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 \
+        android.hardware.wifi@1.0::types.NanDataPathAppInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathCfg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathCfg.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 \
+        android.hardware.wifi@1.0::types.NanDataPathCfg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathChannelCfg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathChannelCfg.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 \
+        android.hardware.wifi@1.0::types.NanDataPathChannelCfg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathConfirmInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathConfirmInd.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 \
+        android.hardware.wifi@1.0::types.NanDataPathConfirmInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathEndInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathEndInd.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 \
+        android.hardware.wifi@1.0::types.NanDataPathEndInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathEndRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathEndRequest.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 \
+        android.hardware.wifi@1.0::types.NanDataPathEndRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathIndicationResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathIndicationResponse.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 \
+        android.hardware.wifi@1.0::types.NanDataPathIndicationResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathInitiatorRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathInitiatorRequest.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 \
+        android.hardware.wifi@1.0::types.NanDataPathInitiatorRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathRequestInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathRequestInd.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 \
+        android.hardware.wifi@1.0::types.NanDataPathRequestInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathResponse.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 \
+        android.hardware.wifi@1.0::types.NanDataPathResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathResponseCode)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathResponseCode.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 \
+        android.hardware.wifi@1.0::types.NanDataPathResponseCode
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathResponseMsg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathResponseMsg.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 \
+        android.hardware.wifi@1.0::types.NanDataPathResponseMsg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDeviceRole)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDeviceRole.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 \
+        android.hardware.wifi@1.0::types.NanDeviceRole
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDisabledInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDisabledInd.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 \
+        android.hardware.wifi@1.0::types.NanDisabledInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDiscEngEventInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDiscEngEventInd.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 \
+        android.hardware.wifi@1.0::types.NanDiscEngEventInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDiscEngEventType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDiscEngEventType.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 \
+        android.hardware.wifi@1.0::types.NanDiscEngEventType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanEnableRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanEnableRequest.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 \
+        android.hardware.wifi@1.0::types.NanEnableRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanFollowupInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanFollowupInd.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 \
+        android.hardware.wifi@1.0::types.NanFollowupInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanFurtherAvailabilityChannel)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanFurtherAvailabilityChannel.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 \
+        android.hardware.wifi@1.0::types.NanFurtherAvailabilityChannel
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanMatchAlg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanMatchAlg.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 \
+        android.hardware.wifi@1.0::types.NanMatchAlg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanMatchExpiredInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanMatchExpiredInd.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 \
+        android.hardware.wifi@1.0::types.NanMatchExpiredInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanMatchInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanMatchInd.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 \
+        android.hardware.wifi@1.0::types.NanMatchInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanMaxSize)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanMaxSize.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 \
+        android.hardware.wifi@1.0::types.NanMaxSize
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishCancelRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishCancelRequest.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 \
+        android.hardware.wifi@1.0::types.NanPublishCancelRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishRequest.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 \
+        android.hardware.wifi@1.0::types.NanPublishRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishResponse.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 \
+        android.hardware.wifi@1.0::types.NanPublishResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishResponseMsg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishResponseMsg.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 \
+        android.hardware.wifi@1.0::types.NanPublishResponseMsg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishTerminatedInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishTerminatedInd.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 \
+        android.hardware.wifi@1.0::types.NanPublishTerminatedInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishType.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 \
+        android.hardware.wifi@1.0::types.NanPublishType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanReceiveVendorSpecificAttribute)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanReceiveVendorSpecificAttribute.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 \
+        android.hardware.wifi@1.0::types.NanReceiveVendorSpecificAttribute
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanResponseMsgHeader)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanResponseMsgHeader.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 \
+        android.hardware.wifi@1.0::types.NanResponseMsgHeader
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanResponseType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanResponseType.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 \
+        android.hardware.wifi@1.0::types.NanResponseType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSocialChannelScanParams)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSocialChannelScanParams.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 \
+        android.hardware.wifi@1.0::types.NanSocialChannelScanParams
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSrfIncludeType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSrfIncludeType.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 \
+        android.hardware.wifi@1.0::types.NanSrfIncludeType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSrfType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSrfType.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 \
+        android.hardware.wifi@1.0::types.NanSrfType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanStatusType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanStatusType.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 \
+        android.hardware.wifi@1.0::types.NanStatusType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeCancelRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeCancelRequest.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeCancelRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeRequest.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeResponse.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeResponseMsg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeResponseMsg.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeResponseMsg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeTerminatedInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeTerminatedInd.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeTerminatedInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeType.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTransmitFollowupInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTransmitFollowupInd.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 \
+        android.hardware.wifi@1.0::types.NanTransmitFollowupInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTransmitFollowupRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTransmitFollowupRequest.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 \
+        android.hardware.wifi@1.0::types.NanTransmitFollowupRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTransmitVendorSpecificAttribute)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTransmitVendorSpecificAttribute.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 \
+        android.hardware.wifi@1.0::types.NanTransmitVendorSpecificAttribute
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTransmitWindowType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTransmitWindowType.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 \
+        android.hardware.wifi@1.0::types.NanTransmitWindowType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTxPriority)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTxPriority.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 \
+        android.hardware.wifi@1.0::types.NanTxPriority
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTxType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTxType.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 \
+        android.hardware.wifi@1.0::types.NanTxType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanVsaRxFrameMask)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanVsaRxFrameMask.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 \
+        android.hardware.wifi@1.0::types.NanVsaRxFrameMask
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttBw)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttBw.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 \
+        android.hardware.wifi@1.0::types.RttBw
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttCapabilities)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttCapabilities.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 \
+        android.hardware.wifi@1.0::types.RttCapabilities
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttChannelMap)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttChannelMap.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 \
+        android.hardware.wifi@1.0::types.RttChannelMap
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttConfig)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttConfig.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 \
+        android.hardware.wifi@1.0::types.RttConfig
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttDebugFormat)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttDebugFormat.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 \
+        android.hardware.wifi@1.0::types.RttDebugFormat
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttDebugInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttDebugInfo.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 \
+        android.hardware.wifi@1.0::types.RttDebugInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttDebugType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttDebugType.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 \
+        android.hardware.wifi@1.0::types.RttDebugType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttLciInformation)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttLciInformation.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 \
+        android.hardware.wifi@1.0::types.RttLciInformation
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttLcrInformation)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttLcrInformation.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 \
+        android.hardware.wifi@1.0::types.RttLcrInformation
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttMotionPattern)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttMotionPattern.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 \
+        android.hardware.wifi@1.0::types.RttMotionPattern
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttPeerType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttPeerType.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 \
+        android.hardware.wifi@1.0::types.RttPeerType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttPreamble)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttPreamble.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 \
+        android.hardware.wifi@1.0::types.RttPreamble
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttResponder)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttResponder.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 \
+        android.hardware.wifi@1.0::types.RttResponder
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttResult)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttResult.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 \
+        android.hardware.wifi@1.0::types.RttResult
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttStatus)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttStatus.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 \
+        android.hardware.wifi@1.0::types.RttStatus
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttType.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 \
+        android.hardware.wifi@1.0::types.RttType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaApfPacketFilterCapabilities)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaApfPacketFilterCapabilities.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 \
+        android.hardware.wifi@1.0::types.StaApfPacketFilterCapabilities
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanBand)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanBand.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanBand
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanBucketEventReportSchemeMask)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanBucketEventReportSchemeMask.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanBucketEventReportSchemeMask
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanBucketParameters)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanBucketParameters.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanBucketParameters
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanCapabilities)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanCapabilities.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanCapabilities
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanParameters)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanParameters.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanParameters
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaLinkLayerIfacePacketStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaLinkLayerIfacePacketStats.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 \
+        android.hardware.wifi@1.0::types.StaLinkLayerIfacePacketStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaLinkLayerIfaceStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaLinkLayerIfaceStats.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 \
+        android.hardware.wifi@1.0::types.StaLinkLayerIfaceStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaLinkLayerRadioStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaLinkLayerRadioStats.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 \
+        android.hardware.wifi@1.0::types.StaLinkLayerRadioStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaLinkLayerStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaLinkLayerStats.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 \
+        android.hardware.wifi@1.0::types.StaLinkLayerStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaScanData)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaScanData.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 \
+        android.hardware.wifi@1.0::types.StaScanData
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaScanDataFlagMask)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaScanDataFlagMask.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 \
+        android.hardware.wifi@1.0::types.StaScanDataFlagMask
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaScanResult)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaScanResult.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 \
+        android.hardware.wifi@1.0::types.StaScanResult
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiChannelInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiChannelInfo.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 \
+        android.hardware.wifi@1.0::types.WifiChannelInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiChannelWidthInMhz)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiChannelWidthInMhz.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 \
+        android.hardware.wifi@1.0::types.WifiChannelWidthInMhz
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugHostWakeReasonRxIcmpPacketDetails)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugHostWakeReasonRxIcmpPacketDetails.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 \
+        android.hardware.wifi@1.0::types.WifiDebugHostWakeReasonRxIcmpPacketDetails
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugHostWakeReasonRxMulticastPacketDetails)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugHostWakeReasonRxMulticastPacketDetails.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 \
+        android.hardware.wifi@1.0::types.WifiDebugHostWakeReasonRxMulticastPacketDetails
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugHostWakeReasonRxPacketDetails)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugHostWakeReasonRxPacketDetails.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 \
+        android.hardware.wifi@1.0::types.WifiDebugHostWakeReasonRxPacketDetails
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugHostWakeReasonStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugHostWakeReasonStats.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 \
+        android.hardware.wifi@1.0::types.WifiDebugHostWakeReasonStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugPacketFateFrameInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugPacketFateFrameInfo.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 \
+        android.hardware.wifi@1.0::types.WifiDebugPacketFateFrameInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugPacketFateFrameType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugPacketFateFrameType.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 \
+        android.hardware.wifi@1.0::types.WifiDebugPacketFateFrameType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingBufferFlags)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingBufferFlags.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingBufferFlags
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingBufferStatus)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingBufferStatus.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingBufferStatus
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingBufferVerboseLevel)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingBufferVerboseLevel.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingBufferVerboseLevel
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryConnectivityEvent)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryConnectivityEvent.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryConnectivityEvent
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryEventTlv)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryEventTlv.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryEventTlv
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryEventTlvType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryEventTlvType.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryEventTlvType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryEventType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryEventType.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryEventType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryFlags)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryFlags.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryFlags
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryHeader)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryHeader.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryHeader
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryPowerEvent)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryPowerEvent.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryPowerEvent
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryVendorData)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryVendorData.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryVendorData
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryWakelockEvent)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryWakelockEvent.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryWakelockEvent
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRxPacketFate)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRxPacketFate.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRxPacketFate
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRxPacketFateReport)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRxPacketFateReport.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRxPacketFateReport
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugTxPacketFate)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugTxPacketFate.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 \
+        android.hardware.wifi@1.0::types.WifiDebugTxPacketFate
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugTxPacketFateReport)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugTxPacketFateReport.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 \
+        android.hardware.wifi@1.0::types.WifiDebugTxPacketFateReport
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiInformationElement)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiInformationElement.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 \
+        android.hardware.wifi@1.0::types.WifiInformationElement
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiRateInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiRateInfo.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 \
+        android.hardware.wifi@1.0::types.WifiRateInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiRateNss)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiRateNss.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 \
+        android.hardware.wifi@1.0::types.WifiRateNss
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiRatePreamble)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiRatePreamble.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 \
+        android.hardware.wifi@1.0::types.WifiRatePreamble
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiStatus)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiStatus.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 \
+        android.hardware.wifi@1.0::types.WifiStatus
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiStatusCode)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiStatusCode.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 \
+        android.hardware.wifi@1.0::types.WifiStatusCode
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build IWifi.hal
 #
 GEN := $(intermediates)/android/hardware/wifi/1.0/IWifi.java
@@ -204,6 +2159,10 @@
 $(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiNanIface.hal
 $(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiIface.hal
 $(GEN): $(LOCAL_PATH)/IWifiIface.hal
+$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiNanIfaceEventCallback.hal
+$(GEN): $(LOCAL_PATH)/IWifiNanIfaceEventCallback.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) \
@@ -215,6 +2174,25 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build IWifiNanIfaceEventCallback.hal
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiNanIfaceEventCallback.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiNanIfaceEventCallback.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 \
+        android.hardware.wifi@1.0::IWifiNanIfaceEventCallback
+
+$(GEN): $(LOCAL_PATH)/IWifiNanIfaceEventCallback.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build IWifiP2pIface.hal
 #
 GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiP2pIface.java
@@ -242,6 +2220,10 @@
 $(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiRttController.hal
 $(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiIface.hal
 $(GEN): $(LOCAL_PATH)/IWifiIface.hal
+$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiRttControllerEventCallback.hal
+$(GEN): $(LOCAL_PATH)/IWifiRttControllerEventCallback.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) \
@@ -253,6 +2235,25 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build IWifiRttControllerEventCallback.hal
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiRttControllerEventCallback.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiRttControllerEventCallback.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 \
+        android.hardware.wifi@1.0::IWifiRttControllerEventCallback
+
+$(GEN): $(LOCAL_PATH)/IWifiRttControllerEventCallback.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build IWifiStaIface.hal
 #
 GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiStaIface.java
@@ -261,6 +2262,10 @@
 $(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiStaIface.hal
 $(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiIface.hal
 $(GEN): $(LOCAL_PATH)/IWifiIface.hal
+$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiStaIfaceEventCallback.hal
+$(GEN): $(LOCAL_PATH)/IWifiStaIfaceEventCallback.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) \
@@ -270,6 +2275,25 @@
 $(GEN): $(LOCAL_PATH)/IWifiStaIface.hal
 	$(transform-generated-source)
 LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build IWifiStaIfaceEventCallback.hal
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiStaIfaceEventCallback.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiStaIfaceEventCallback.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 \
+        android.hardware.wifi@1.0::IWifiStaIfaceEventCallback
+
+$(GEN): $(LOCAL_PATH)/IWifiStaIfaceEventCallback.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
 include $(BUILD_JAVA_LIBRARY)
 
 
@@ -284,40 +2308,6 @@
 HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
 
 #
-# Build types.hal (CommandFailureReason)
-#
-GEN := $(intermediates)/android/hardware/wifi/1.0/CommandFailureReason.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 \
-        android.hardware.wifi@1.0::types.CommandFailureReason
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
-# Build types.hal (FailureReason)
-#
-GEN := $(intermediates)/android/hardware/wifi/1.0/FailureReason.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 \
-        android.hardware.wifi@1.0::types.FailureReason
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
 # Build types.hal (IfaceType)
 #
 GEN := $(intermediates)/android/hardware/wifi/1.0/IfaceType.java
@@ -335,6 +2325,1995 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build types.hal (NanAvailDuration)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanAvailDuration.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 \
+        android.hardware.wifi@1.0::types.NanAvailDuration
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanBeaconSdfPayloadInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanBeaconSdfPayloadInd.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 \
+        android.hardware.wifi@1.0::types.NanBeaconSdfPayloadInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanBeaconSdfPayloadReceive)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanBeaconSdfPayloadReceive.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 \
+        android.hardware.wifi@1.0::types.NanBeaconSdfPayloadReceive
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanBeaconSdfPayloadRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanBeaconSdfPayloadRequest.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 \
+        android.hardware.wifi@1.0::types.NanBeaconSdfPayloadRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanCapabilitiesResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanCapabilitiesResponse.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 \
+        android.hardware.wifi@1.0::types.NanCapabilitiesResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanCapabilitiesResponseMsg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanCapabilitiesResponseMsg.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 \
+        android.hardware.wifi@1.0::types.NanCapabilitiesResponseMsg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanChannelIndex)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanChannelIndex.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 \
+        android.hardware.wifi@1.0::types.NanChannelIndex
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanConfigRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanConfigRequest.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 \
+        android.hardware.wifi@1.0::types.NanConfigRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanConnectionType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanConnectionType.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 \
+        android.hardware.wifi@1.0::types.NanConnectionType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathAppInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathAppInfo.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 \
+        android.hardware.wifi@1.0::types.NanDataPathAppInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathCfg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathCfg.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 \
+        android.hardware.wifi@1.0::types.NanDataPathCfg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathChannelCfg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathChannelCfg.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 \
+        android.hardware.wifi@1.0::types.NanDataPathChannelCfg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathConfirmInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathConfirmInd.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 \
+        android.hardware.wifi@1.0::types.NanDataPathConfirmInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathEndInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathEndInd.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 \
+        android.hardware.wifi@1.0::types.NanDataPathEndInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathEndRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathEndRequest.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 \
+        android.hardware.wifi@1.0::types.NanDataPathEndRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathIndicationResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathIndicationResponse.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 \
+        android.hardware.wifi@1.0::types.NanDataPathIndicationResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathInitiatorRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathInitiatorRequest.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 \
+        android.hardware.wifi@1.0::types.NanDataPathInitiatorRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathRequestInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathRequestInd.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 \
+        android.hardware.wifi@1.0::types.NanDataPathRequestInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathResponse.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 \
+        android.hardware.wifi@1.0::types.NanDataPathResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathResponseCode)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathResponseCode.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 \
+        android.hardware.wifi@1.0::types.NanDataPathResponseCode
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDataPathResponseMsg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDataPathResponseMsg.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 \
+        android.hardware.wifi@1.0::types.NanDataPathResponseMsg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDeviceRole)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDeviceRole.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 \
+        android.hardware.wifi@1.0::types.NanDeviceRole
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDisabledInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDisabledInd.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 \
+        android.hardware.wifi@1.0::types.NanDisabledInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDiscEngEventInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDiscEngEventInd.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 \
+        android.hardware.wifi@1.0::types.NanDiscEngEventInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanDiscEngEventType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanDiscEngEventType.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 \
+        android.hardware.wifi@1.0::types.NanDiscEngEventType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanEnableRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanEnableRequest.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 \
+        android.hardware.wifi@1.0::types.NanEnableRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanFollowupInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanFollowupInd.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 \
+        android.hardware.wifi@1.0::types.NanFollowupInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanFurtherAvailabilityChannel)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanFurtherAvailabilityChannel.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 \
+        android.hardware.wifi@1.0::types.NanFurtherAvailabilityChannel
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanMatchAlg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanMatchAlg.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 \
+        android.hardware.wifi@1.0::types.NanMatchAlg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanMatchExpiredInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanMatchExpiredInd.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 \
+        android.hardware.wifi@1.0::types.NanMatchExpiredInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanMatchInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanMatchInd.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 \
+        android.hardware.wifi@1.0::types.NanMatchInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanMaxSize)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanMaxSize.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 \
+        android.hardware.wifi@1.0::types.NanMaxSize
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishCancelRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishCancelRequest.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 \
+        android.hardware.wifi@1.0::types.NanPublishCancelRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishRequest.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 \
+        android.hardware.wifi@1.0::types.NanPublishRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishResponse.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 \
+        android.hardware.wifi@1.0::types.NanPublishResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishResponseMsg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishResponseMsg.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 \
+        android.hardware.wifi@1.0::types.NanPublishResponseMsg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishTerminatedInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishTerminatedInd.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 \
+        android.hardware.wifi@1.0::types.NanPublishTerminatedInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanPublishType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanPublishType.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 \
+        android.hardware.wifi@1.0::types.NanPublishType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanReceiveVendorSpecificAttribute)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanReceiveVendorSpecificAttribute.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 \
+        android.hardware.wifi@1.0::types.NanReceiveVendorSpecificAttribute
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanResponseMsgHeader)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanResponseMsgHeader.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 \
+        android.hardware.wifi@1.0::types.NanResponseMsgHeader
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanResponseType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanResponseType.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 \
+        android.hardware.wifi@1.0::types.NanResponseType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSocialChannelScanParams)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSocialChannelScanParams.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 \
+        android.hardware.wifi@1.0::types.NanSocialChannelScanParams
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSrfIncludeType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSrfIncludeType.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 \
+        android.hardware.wifi@1.0::types.NanSrfIncludeType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSrfType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSrfType.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 \
+        android.hardware.wifi@1.0::types.NanSrfType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanStatusType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanStatusType.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 \
+        android.hardware.wifi@1.0::types.NanStatusType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeCancelRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeCancelRequest.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeCancelRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeRequest.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeResponse)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeResponse.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeResponse
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeResponseMsg)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeResponseMsg.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeResponseMsg
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeTerminatedInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeTerminatedInd.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeTerminatedInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanSubscribeType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanSubscribeType.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 \
+        android.hardware.wifi@1.0::types.NanSubscribeType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTransmitFollowupInd)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTransmitFollowupInd.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 \
+        android.hardware.wifi@1.0::types.NanTransmitFollowupInd
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTransmitFollowupRequest)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTransmitFollowupRequest.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 \
+        android.hardware.wifi@1.0::types.NanTransmitFollowupRequest
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTransmitVendorSpecificAttribute)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTransmitVendorSpecificAttribute.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 \
+        android.hardware.wifi@1.0::types.NanTransmitVendorSpecificAttribute
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTransmitWindowType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTransmitWindowType.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 \
+        android.hardware.wifi@1.0::types.NanTransmitWindowType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTxPriority)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTxPriority.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 \
+        android.hardware.wifi@1.0::types.NanTxPriority
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanTxType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanTxType.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 \
+        android.hardware.wifi@1.0::types.NanTxType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (NanVsaRxFrameMask)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/NanVsaRxFrameMask.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 \
+        android.hardware.wifi@1.0::types.NanVsaRxFrameMask
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttBw)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttBw.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 \
+        android.hardware.wifi@1.0::types.RttBw
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttCapabilities)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttCapabilities.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 \
+        android.hardware.wifi@1.0::types.RttCapabilities
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttChannelMap)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttChannelMap.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 \
+        android.hardware.wifi@1.0::types.RttChannelMap
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttConfig)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttConfig.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 \
+        android.hardware.wifi@1.0::types.RttConfig
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttDebugFormat)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttDebugFormat.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 \
+        android.hardware.wifi@1.0::types.RttDebugFormat
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttDebugInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttDebugInfo.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 \
+        android.hardware.wifi@1.0::types.RttDebugInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttDebugType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttDebugType.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 \
+        android.hardware.wifi@1.0::types.RttDebugType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttLciInformation)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttLciInformation.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 \
+        android.hardware.wifi@1.0::types.RttLciInformation
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttLcrInformation)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttLcrInformation.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 \
+        android.hardware.wifi@1.0::types.RttLcrInformation
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttMotionPattern)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttMotionPattern.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 \
+        android.hardware.wifi@1.0::types.RttMotionPattern
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttPeerType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttPeerType.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 \
+        android.hardware.wifi@1.0::types.RttPeerType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttPreamble)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttPreamble.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 \
+        android.hardware.wifi@1.0::types.RttPreamble
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttResponder)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttResponder.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 \
+        android.hardware.wifi@1.0::types.RttResponder
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttResult)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttResult.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 \
+        android.hardware.wifi@1.0::types.RttResult
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttStatus)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttStatus.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 \
+        android.hardware.wifi@1.0::types.RttStatus
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (RttType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/RttType.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 \
+        android.hardware.wifi@1.0::types.RttType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaApfPacketFilterCapabilities)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaApfPacketFilterCapabilities.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 \
+        android.hardware.wifi@1.0::types.StaApfPacketFilterCapabilities
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanBand)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanBand.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanBand
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanBucketEventReportSchemeMask)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanBucketEventReportSchemeMask.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanBucketEventReportSchemeMask
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanBucketParameters)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanBucketParameters.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanBucketParameters
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanCapabilities)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanCapabilities.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanCapabilities
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaBackgroundScanParameters)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaBackgroundScanParameters.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 \
+        android.hardware.wifi@1.0::types.StaBackgroundScanParameters
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaLinkLayerIfacePacketStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaLinkLayerIfacePacketStats.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 \
+        android.hardware.wifi@1.0::types.StaLinkLayerIfacePacketStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaLinkLayerIfaceStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaLinkLayerIfaceStats.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 \
+        android.hardware.wifi@1.0::types.StaLinkLayerIfaceStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaLinkLayerRadioStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaLinkLayerRadioStats.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 \
+        android.hardware.wifi@1.0::types.StaLinkLayerRadioStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaLinkLayerStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaLinkLayerStats.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 \
+        android.hardware.wifi@1.0::types.StaLinkLayerStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaScanData)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaScanData.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 \
+        android.hardware.wifi@1.0::types.StaScanData
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaScanDataFlagMask)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaScanDataFlagMask.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 \
+        android.hardware.wifi@1.0::types.StaScanDataFlagMask
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (StaScanResult)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/StaScanResult.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 \
+        android.hardware.wifi@1.0::types.StaScanResult
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiChannelInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiChannelInfo.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 \
+        android.hardware.wifi@1.0::types.WifiChannelInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiChannelWidthInMhz)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiChannelWidthInMhz.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 \
+        android.hardware.wifi@1.0::types.WifiChannelWidthInMhz
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugHostWakeReasonRxIcmpPacketDetails)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugHostWakeReasonRxIcmpPacketDetails.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 \
+        android.hardware.wifi@1.0::types.WifiDebugHostWakeReasonRxIcmpPacketDetails
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugHostWakeReasonRxMulticastPacketDetails)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugHostWakeReasonRxMulticastPacketDetails.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 \
+        android.hardware.wifi@1.0::types.WifiDebugHostWakeReasonRxMulticastPacketDetails
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugHostWakeReasonRxPacketDetails)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugHostWakeReasonRxPacketDetails.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 \
+        android.hardware.wifi@1.0::types.WifiDebugHostWakeReasonRxPacketDetails
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugHostWakeReasonStats)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugHostWakeReasonStats.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 \
+        android.hardware.wifi@1.0::types.WifiDebugHostWakeReasonStats
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugPacketFateFrameInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugPacketFateFrameInfo.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 \
+        android.hardware.wifi@1.0::types.WifiDebugPacketFateFrameInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugPacketFateFrameType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugPacketFateFrameType.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 \
+        android.hardware.wifi@1.0::types.WifiDebugPacketFateFrameType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingBufferFlags)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingBufferFlags.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingBufferFlags
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingBufferStatus)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingBufferStatus.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingBufferStatus
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingBufferVerboseLevel)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingBufferVerboseLevel.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingBufferVerboseLevel
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryConnectivityEvent)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryConnectivityEvent.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryConnectivityEvent
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryEventTlv)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryEventTlv.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryEventTlv
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryEventTlvType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryEventTlvType.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryEventTlvType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryEventType)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryEventType.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryEventType
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryFlags)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryFlags.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryFlags
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryHeader)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryHeader.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryHeader
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryPowerEvent)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryPowerEvent.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryPowerEvent
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryVendorData)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryVendorData.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryVendorData
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRingEntryWakelockEvent)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRingEntryWakelockEvent.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRingEntryWakelockEvent
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRxPacketFate)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRxPacketFate.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRxPacketFate
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugRxPacketFateReport)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugRxPacketFateReport.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 \
+        android.hardware.wifi@1.0::types.WifiDebugRxPacketFateReport
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugTxPacketFate)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugTxPacketFate.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 \
+        android.hardware.wifi@1.0::types.WifiDebugTxPacketFate
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiDebugTxPacketFateReport)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiDebugTxPacketFateReport.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 \
+        android.hardware.wifi@1.0::types.WifiDebugTxPacketFateReport
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiInformationElement)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiInformationElement.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 \
+        android.hardware.wifi@1.0::types.WifiInformationElement
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiRateInfo)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiRateInfo.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 \
+        android.hardware.wifi@1.0::types.WifiRateInfo
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiRateNss)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiRateNss.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 \
+        android.hardware.wifi@1.0::types.WifiRateNss
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiRatePreamble)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiRatePreamble.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 \
+        android.hardware.wifi@1.0::types.WifiRatePreamble
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiStatus)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiStatus.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 \
+        android.hardware.wifi@1.0::types.WifiStatus
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build types.hal (WifiStatusCode)
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/WifiStatusCode.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 \
+        android.hardware.wifi@1.0::types.WifiStatusCode
+
+$(GEN): $(LOCAL_PATH)/types.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build IWifi.hal
 #
 GEN := $(intermediates)/android/hardware/wifi/1.0/IWifi.java
@@ -475,6 +4454,10 @@
 $(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiNanIface.hal
 $(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiIface.hal
 $(GEN): $(LOCAL_PATH)/IWifiIface.hal
+$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiNanIfaceEventCallback.hal
+$(GEN): $(LOCAL_PATH)/IWifiNanIfaceEventCallback.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) \
@@ -486,6 +4469,25 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build IWifiNanIfaceEventCallback.hal
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiNanIfaceEventCallback.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiNanIfaceEventCallback.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 \
+        android.hardware.wifi@1.0::IWifiNanIfaceEventCallback
+
+$(GEN): $(LOCAL_PATH)/IWifiNanIfaceEventCallback.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build IWifiP2pIface.hal
 #
 GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiP2pIface.java
@@ -513,6 +4515,10 @@
 $(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiRttController.hal
 $(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiIface.hal
 $(GEN): $(LOCAL_PATH)/IWifiIface.hal
+$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiRttControllerEventCallback.hal
+$(GEN): $(LOCAL_PATH)/IWifiRttControllerEventCallback.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) \
@@ -524,6 +4530,25 @@
 LOCAL_GENERATED_SOURCES += $(GEN)
 
 #
+# Build IWifiRttControllerEventCallback.hal
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiRttControllerEventCallback.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiRttControllerEventCallback.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 \
+        android.hardware.wifi@1.0::IWifiRttControllerEventCallback
+
+$(GEN): $(LOCAL_PATH)/IWifiRttControllerEventCallback.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
 # Build IWifiStaIface.hal
 #
 GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiStaIface.java
@@ -532,6 +4557,10 @@
 $(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiStaIface.hal
 $(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiIface.hal
 $(GEN): $(LOCAL_PATH)/IWifiIface.hal
+$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/IWifiStaIfaceEventCallback.hal
+$(GEN): $(LOCAL_PATH)/IWifiStaIfaceEventCallback.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) \
@@ -541,6 +4570,25 @@
 $(GEN): $(LOCAL_PATH)/IWifiStaIface.hal
 	$(transform-generated-source)
 LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build IWifiStaIfaceEventCallback.hal
+#
+GEN := $(intermediates)/android/hardware/wifi/1.0/IWifiStaIfaceEventCallback.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IWifiStaIfaceEventCallback.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 \
+        android.hardware.wifi@1.0::IWifiStaIfaceEventCallback
+
+$(GEN): $(LOCAL_PATH)/IWifiStaIfaceEventCallback.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
 include $(BUILD_STATIC_JAVA_LIBRARY)
 
 
diff --git a/wifi/1.0/IWifi.hal b/wifi/1.0/IWifi.hal
index 9e09348..a632920 100644
--- a/wifi/1.0/IWifi.hal
+++ b/wifi/1.0/IWifi.hal
@@ -34,10 +34,15 @@
    *
    * @param callback An instance of the |IWifiEventCallback| HIDL interface
    *        object.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.UNKNOWN|
    */
   @entry
   @callflow(next={"*"})
-  oneway registerEventCallback(IWifiEventCallback callback);
+  registerEventCallback(IWifiEventCallback callback)
+      generates (WifiStatus status);
 
   /**
    * Get the current state of the HAL.
@@ -48,44 +53,66 @@
 
   /**
    * Perform any setup that is required to make use of the module. If the module
-   * is already started then this must be a noop. The onStart callback must be
-   * called when the setup completes or if the HAL is already started. If the
-   * setup fails then onStartFailure must be called.
+   * is already started then this must be a noop.
+   * Must trigger |IWifiEventCallback.onStart| on success.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.NOT_AVAILABLE|,
+   *         |WifiStatusCode.UNKNOWN|
    */
   @entry
   @callflow(next={"registerEventCallback", "start", "stop", "getChip"})
-  oneway start();
+  start() generates (WifiStatus status);
 
   /**
    * Tear down any state, ongoing commands, etc. If the module is already
    * stopped then this must be a noop. If the HAL is already stopped or it
-   * succeeds then onStop must be called. If the teardown fails onFailure must
-   * be called. After calling this all IWifiChip objects will be considered
-   * invalid.
+   * succeeds then onStop must be called. After calling this all IWifiChip
+   * objects will be considered invalid.
+   * Must trigger |IWifiEventCallback.onStop| on success.
+   * Must trigger |IWifiEventCallback.onFailure| on failure.
    *
    * Calling stop then start is a valid way of resetting state in the HAL,
    * driver, firmware.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.NOT_STARTED|,
+   *         |WifiStatusCode.UNKNOWN|
    */
   @exit
   @callflow(next={"registerEventCallback", "start", "stop"})
-  oneway stop();
+  stop() generates (WifiStatus status);
 
   /**
    * Retrieve the list of all chip Id's on the device.
    * The corresponding |IWifiChip| object for any chip can be
    * retrieved using |getChip| method.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.NOT_STARTED|,
+   *         |WifiStatusCode.UNKNOWN|
    * @return chipIds List of all chip Id's on the device.
    */
   @callflow(next={"*"})
-  getChipIds() generates (vec<ChipId> chipIds);
+  getChipIds() generates (WifiStatus status, vec<ChipId> chipIds);
 
   /**
    * Gets a HIDL interface object for the chip corresponding to the
    * provided chipId.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.NOT_STARTED|,
+   *         |WifiStatusCode.UNKNOWN|
    * @return chip HIDL interface object representing the chip.
    */
   @callflow(next={"*"})
-  getChip(ChipId chipId) generates (IWifiChip chip);
+  getChip(ChipId chipId) generates (WifiStatus status, IWifiChip chip);
 };
diff --git a/wifi/1.0/IWifiChip.hal b/wifi/1.0/IWifiChip.hal
index cd4b219..3c085c3 100644
--- a/wifi/1.0/IWifiChip.hal
+++ b/wifi/1.0/IWifiChip.hal
@@ -36,7 +36,7 @@
    * ChipIfaceCombination for examples.
    */
   struct ChipIfaceCombinationLimit {
-    vec<IfaceType> types; // Each IfaceType may occur at most once
+    vec<IfaceType> types; // Each IfaceType must occur at most once.
     uint32_t maxIfaces;
   };
 
@@ -85,11 +85,11 @@
    * [{STA} <=1, {AP} <= 1].
    *
    * When switching between two available combinations it is expected that
-   * interfaces only supported by the initial combination will be removed until
+   * interfaces only supported by the initial combination must be removed until
    * the target combination is also satisfied. At that point new interfaces
    * satisfying only the target combination can be added (meaning the initial
    * combination limits will no longer satisfied). The addition of these new
-   * interfaces should not impact the existence of interfaces that satisfy both
+   * interfaces must not impact the existence of interfaces that satisfy both
    * combinations.
    *
    * For example, a chip with available combinations:
@@ -98,12 +98,12 @@
    * AP interface in place of one of the STAs then first one of the STA
    * interfaces must be removed and then the AP interface can be created after
    * the STA had been torn down. During this process the remaining STA and NAN
-   * interfaces should not be removed/recreated.
+   * interfaces must not be removed/recreated.
    *
    * If a chip does not support this kind of reconfiguration in this mode then
-   * the combinations should be separated into two separate modes. Before
-   * switching modes all interfaces will be torn down, the mode switch will be
-   * enacted and when it completes the new interfaces will be brought up.
+   * the combinations must be separated into two separate modes. Before
+   * switching modes all interfaces must be torn down, the mode switch must be
+   * enacted and when it completes the new interfaces must be brought up.
    */
   struct ChipMode {
     /**
@@ -119,191 +119,350 @@
   };
 
   /**
+   * Information about the version of the driver and firmware running this chip.
+   *
+   * The information in these ASCII strings are vendor specific and does not
+   * need to follow any particular format. It may be dumped as part of the bug
+   * report.
+   */
+  struct ChipDebugInfo {
+    string driverDescription;
+    string firmwareDescription;
+  };
+
+  /**
+   * Capabilities exposed by this chip.
+   */
+  enum ChipCapabilityMask : uint32_t {
+    /**
+     * Memory dump of Firmware.
+     */
+    DEBUG_MEMORY_FIRMWARE_DUMP_SUPPORTED = 1 << 0,
+    /**
+     * Memory dump of Driver.
+     */
+    DEBUG_MEMORY_DRIVER_DUMP_SUPPORTED = 1 << 1,
+    /**
+     * Connectivity events reported via debug ring buffer.
+     */
+    DEBUG_RING_BUFFER_CONNECT_EVENT_SUPPORTED = 1 << 2,
+    /**
+     * Power events reported via debug ring buffer.
+     */
+    DEBUG_RING_BUFFER_POWER_EVENT_SUPPORTED = 1 << 3,
+    /**
+     * Wakelock events reported via debug ring buffer.
+     */
+    DEBUG_RING_BUFFER_WAKELOCK_EVENT_SUPPORTED = 1 << 4,
+    /**
+     * Vendor data reported via debug ring buffer.
+     * This mostly contains firmware event logs.
+     */
+    DEBUG_RING_BUFFER_VENDOR_DATA_SUPPORTED = 1 << 5,
+    /**
+     * Host wake reasons stats collection.
+     */
+    DEBUG_HOST_WAKE_REASON_STATS = 1 << 6,
+  };
+
+  /**
    * Get the id assigned to this chip.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return id Assigned chip Id.
    */
-  getId() generates (ChipId id);
+  getId() generates (WifiStatus status, ChipId id);
 
   /**
    * Requests notifications of significant events on this chip. Multiple calls
-   * to this will register multiple callbacks each of which will receive all
+   * to this must register multiple callbacks each of which must receive all
    * events.
    *
    * @param callback An instance of the |IWifiChipEventCallback| HIDL interface
    *        object.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    */
-  oneway registerEventCallback(IWifiChipEventCallback callback);
+  registerEventCallback(IWifiChipEventCallback callback) generates (WifiStatus status);
+
+  /**
+   * Get the capabilities supported by this chip.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return capabilities Bitset of |ChipCapabilityMask| values.
+   */
+  getCapabilities() generates (WifiStatus status, uint32_t capabilities);
 
   /**
    * Get the set of operation modes that the chip supports.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return modes List of modes supported by the device.
    */
-  getAvailableModes() generates (vec<ChipMode> modes);
+  getAvailableModes() generates (WifiStatus status, vec<ChipMode> modes);
 
   /**
    * Reconfigure the Chip.
-   * Must trigger |IWifiChipEventCallback.onChipReconfigured| on sucess,
-   * or |IWifiChipEventCallback.onChipReconfigureFailure| on failure.
+   * Any existing |IWifiIface| objects must be marked invalid after this call.
+   * If this fails then the chips is now in an undefined state and
+   * configureChip must be called again.
+   * Must trigger |IWifiChipEventCallback.onChipReconfigured| on success.
+   * Must trigger |IWifiEventCallback.onFailure| on failure.
    *
-   * @param modeId The mode that the chip should switch to, corresponding to the
+   * @param modeId The mode that the chip must switch to, corresponding to the
    *        id property of the target ChipMode.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
    */
-  oneway configureChip(ChipModeId modeId);
+  configureChip(ChipModeId modeId) generates (WifiStatus status);
 
   /**
    * Get the current mode that the chip is in.
    *
    * @return modeId The mode that the chip is currently configured to,
    *         corresponding to the id property of the target ChipMode.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    */
-  getMode() generates (ChipModeId modeId);
+  getMode() generates (WifiStatus status, ChipModeId modeId);
 
   /**
    * Request information about the chip.
-   * Must trigger |IWifiChipEventCallback.onChipDebugInfoAvailable| on sucess,
-   * or |IWifiChipEventCallback.onChipDebugInfoFailure| on failure.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return chipDebugInfo Instance of |ChipDebugInfo|.
    */
-  oneway requestChipDebugInfo();
+  requestChipDebugInfo() generates (WifiStatus status, ChipDebugInfo chipDebugInfo);
 
   /**
    * Request vendor debug info from the driver.
-   * Must trigger |IWifiChipEventCallback.onDriverDebugDumpAvailable| on success,
-   * or |IWifiChipEventCallback.onDriverDebugDumpFailure| on failure.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @param blob Vector of bytes retrieved from the driver.
    */
-  oneway requestDriverDebugDump();
+  requestDriverDebugDump() generates (WifiStatus status, vec<uint8_t> blob);
 
   /**
    * Request vendor debug info from the firmware.
-   * Must trigger |IWifiChipEventCallback.onFirmwareDebugDumpAvailable| on
-   * success, or |IWifiChipEventCallback.onFirmwareDebugDumpFailure| on failure.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @param blob Vector of bytes retrieved from the driver.
    */
-  oneway requestFirmwareDebugDump();
+  requestFirmwareDebugDump() generates (WifiStatus status, vec<uint8_t> blob);
 
   /**
    * Create an AP iface on the chip.
    *
    * Depending on the mode the chip is configured in, the interface creation
-   * may fail if we've already reached the maximum allowed
-   * (specified in |ChipIfaceCombination|) number of ifaces of the AP type.
+   * may fail (code: |ERROR_NOT_SUPPORTED|) if we've already reached the maximum
+   * allowed (specified in |ChipIfaceCombination|) number of ifaces of the AP
+   * type.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|
    * @return iface HIDL interface object representing the iface if
    *         successful, null otherwise.
    */
-  createApIface() generates (IWifiApIface iface);
+  createApIface() generates (WifiStatus status, IWifiApIface iface);
 
   /**
    * List all the AP iface names configured on the chip.
    * The corresponding |IWifiApIface| object for any iface are
    * retrieved using |getApIface| method.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return ifnames List of all AP iface names on the chip.
    */
-  getApIfaceNames() generates (vec<string> ifnames);
+  getApIfaceNames() generates (WifiStatus status, vec<string> ifnames);
 
   /**
    * Gets a HIDL interface object for the AP Iface corresponding
    * to the provided ifname.
    *
    * @param ifname Name of the iface.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return iface HIDL interface object representing the iface if
    *         it exists, null otherwise.
    */
-  getApIface(string ifname) generates (IWifiApIface iface);
+  getApIface(string ifname) generates (WifiStatus status, IWifiApIface iface);
 
   /**
    * Create a NAN iface on the chip.
    *
    * Depending on the mode the chip is configured in, the interface creation
-   * may fail if we've already reached the maximum allowed
-   * (specified in |ChipIfaceCombination|) number of ifaces of the NAN type.
+   * may fail (code: |ERROR_NOT_SUPPORTED|) if we've already reached the maximum
+   * allowed (specified in |ChipIfaceCombination|) number of ifaces of the NAN
+   * type.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|
    * @return iface HIDL interface object representing the iface if
    *         successful, null otherwise.
    */
-  createNanIface() generates (IWifiNanIface iface);
+  createNanIface() generates (WifiStatus status, IWifiNanIface iface);
 
   /**
    * List all the NAN iface names configured on the chip.
    * The corresponding |IWifiNanIface| object for any iface are
    * retrieved using |getNanIface| method.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return ifnames List of all NAN iface names on the chip.
    */
-  getNanIfaceNames() generates (vec<string> ifnames);
+  getNanIfaceNames() generates (WifiStatus status, vec<string> ifnames);
 
   /**
    * Gets a HIDL interface object for the NAN Iface corresponding
    * to the provided ifname.
    *
    * @param ifname Name of the iface.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return iface HIDL interface object representing the iface if
    *         it exists, null otherwise.
    */
-  getNanIface(string ifname) generates (IWifiNanIface iface);
+  getNanIface(string ifname) generates (WifiStatus status, IWifiNanIface iface);
 
   /**
    * Create a P2P iface on the chip.
    *
    * Depending on the mode the chip is configured in, the interface creation
-   * may fail if we've already reached the maximum allowed
-   * (specified in |ChipIfaceCombination|) number of ifaces of the P2P type.
+   * may fail (code: |ERROR_NOT_SUPPORTED|) if we've already reached the maximum
+   * allowed (specified in |ChipIfaceCombination|) number of ifaces of the P2P
+   * type.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|
    * @return iface HIDL interface object representing the iface if
    *         successful, null otherwise.
    */
-  createP2pIface() generates (IWifiP2pIface iface);
+  createP2pIface() generates (WifiStatus status, IWifiP2pIface iface);
 
   /**
    * List all the P2P iface names configured on the chip.
    * The corresponding |IWifiP2pIface| object for any iface are
    * retrieved using |getP2pIface| method.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return ifnames List of all P2P iface names on the chip.
    */
-  getP2pIfaceNames() generates (vec<string> ifnames);
+  getP2pIfaceNames() generates (WifiStatus status, vec<string> ifnames);
 
   /**
    * Gets a HIDL interface object for the P2P Iface corresponding
    * to the provided ifname.
    *
    * @param ifname Name of the iface.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return iface HIDL interface object representing the iface if
    *         it exists, null otherwise.
    */
-  getP2pIface(string ifname) generates (IWifiP2pIface iface);
+  getP2pIface(string ifname) generates (WifiStatus status, IWifiP2pIface iface);
 
   /**
    * Create an STA iface on the chip.
    *
    * Depending on the mode the chip is configured in, the interface creation
-   * may fail if we've already reached the maximum allowed
-   * (specified in |ChipIfaceCombination|) number of ifaces of the STA type.
+   * may fail (code: |ERROR_NOT_SUPPORTED|) if we've already reached the maximum
+   * allowed (specified in |ChipIfaceCombination|) number of ifaces of the STA
+   * type.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|
    * @return iface HIDL interface object representing the iface if
    *         successful, null otherwise.
    */
-  createStaIface() generates (IWifiStaIface iface);
+  createStaIface() generates (WifiStatus status, IWifiStaIface iface);
 
   /**
    * List all the STA iface names configured on the chip.
    * The corresponding |IWifiStaIface| object for any iface are
    * retrieved using |getStaIface| method.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return ifnames List of all STA iface names on the chip.
    */
-  getStaIfaceNames() generates (vec<string> ifnames);
+  getStaIfaceNames() generates (WifiStatus status, vec<string> ifnames);
 
   /**
    * Gets a HIDL interface object for the STA Iface corresponding
    * to the provided ifname.
    *
    * @param ifname Name of the iface.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    * @return iface HIDL interface object representing the iface if
    *         it exists, null otherwise.
    */
-  getStaIface(string ifname) generates (IWifiStaIface iface);
+  getStaIface(string ifname) generates (WifiStatus status, IWifiStaIface iface);
 
   /**
    * Create a RTTController instance.
@@ -316,6 +475,109 @@
    *
    * @param boundIface HIDL interface object representing the iface if
    *        the responder must be bound to a specific iface, null otherwise.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
    */
-  createRttController(IWifiIface boundIface) generates (IWifiRttController rtt);
+  createRttController(IWifiIface boundIface)
+      generates (WifiStatus status, IWifiRttController rtt);
+
+  /**
+   * WiFi debug ring buffer life cycle is as follow:
+   * - At initialization time, framework must call |getDebugRingBuffersStatus|.
+   *   to obtain the names and list of supported ring buffers.
+   *   The driver may expose several different rings each holding a different
+   *   type of data (connection events, power events, etc).
+   * - When WiFi operations start framework must call
+   *   |startLoggingToDebugRingBuffer| to trigger log collection for a specific
+   *   ring. The vebose level for each ring buffer can be specified in this API.
+   * - During wifi operations, driver must periodically report per ring data to
+   *   framework by invoking the
+   *   |IWifiChipEventCallback.onDebugRingBuffer<Type>EntriesAvailable| callback.
+   * - When capturing a bug report, framework must indicate to driver that all
+   *   the data has to be uploaded urgently by calling
+   *   |forceDumpToDebugRingBuffer|.
+   *
+   * The data uploaded by driver must be stored by framework in separate files,
+   * with one stream of file per ring. Framework must store the files in pcapng
+   * format, allowing for easy merging and parsing with network analyzer tools.
+   * TODO: Since we're not longer dumping out the raw data, storing in separate
+   * pcapng files for parsing later must not work anymore.
+   */
+  /**
+   * API to get the status of all ring buffers supported by driver.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.NOT_AVAILABLE|,
+   *         |WifiStatusCode.UNKNOWN|
+   * @return ringBuffers Vector of |WifiDebugRingBufferStatus| corresponding to the
+   *         status of each ring bufffer on the device.
+   */
+  getDebugRingBuffersStatus() generates (WifiStatus status,
+                                         vec<WifiDebugRingBufferStatus> ringBuffers);
+
+  /**
+   * API to trigger the debug data collection.
+   *
+   * @param ringName represent the name of the ring for which data collection
+   *        shall start. This can be retrieved via the corresponding
+   *        |WifiDebugRingBufferStatus|.
+   * @parm maxIntervalInSec Maximum interval in seconds for driver to invoke
+   *       |onDebugRingBufferData|, ignore if zero.
+   * @parm minDataSizeInBytes: Minimum data size in buffer for driver to invoke
+   *       |onDebugRingBufferData|, ignore if zero.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.NOT_AVAILABLE|,
+   *         |WifiStatusCode.UNKNOWN|
+   */
+  startLoggingToDebugRingBuffer(string ringName,
+                                WifiDebugRingBufferVerboseLevel verboseLevel,
+                                uint32_t maxIntervalInSec,
+                                uint32_t minDataSizeInBytes)
+      generates (WifiStatus status);
+
+  /**
+   * API to force dump data into the corresponding ring buffer.
+   * This is to be invoked during bugreport collection.
+   *
+   * @param ringName represent the name of the ring for which data collection
+   *        shall be forced. This can be retrieved via the corresponding
+   *        |WifiDebugRingBufferStatus|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_STARTED|,
+   *         |WifiStatusCode.NOT_AVAILABLE|,
+   *         |WifiStatusCode.UNKNOWN|
+   */
+  forceDumpToDebugRingBuffer(string ringName) generates (WifiStatus status);
+
+  /**
+   * API to retrieve the wifi wake up reason stats for debugging.
+   * The driver is expected to start maintaining these stats once the chip
+   * is configured using |configureChip|. These stats must be reset whenever
+   * the chip is reconfigured or the HAL is stopped.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.NOT_AVAILABLE|,
+   *         |WifiStatusCode.UNKNOWN|
+   * @return stats Instance of |WifiDebugHostWakeReasonStats|.
+   */
+  getDebugHostWakeReasonStats()
+      generates (WifiStatus status, WifiDebugHostWakeReasonStats stats);
 };
diff --git a/wifi/1.0/IWifiChipEventCallback.hal b/wifi/1.0/IWifiChipEventCallback.hal
index 2161c5d..292b10f 100644
--- a/wifi/1.0/IWifiChipEventCallback.hal
+++ b/wifi/1.0/IWifiChipEventCallback.hal
@@ -29,68 +29,45 @@
   oneway onChipReconfigured(ChipModeId modeId);
 
   /**
-   * If this happens then the chips is now in an undefined state and
-   * configureChip must be called again. Any interface indexes will be
-   * assumed to be invalid.
+   * Callbacks for reporting debug ring buffer data.
    *
-   * @param modeId The mode that the chip failed switched to, corresponding to
-   *        the id property of the target ChipMode.
-   * @param reason Failure reason code.
+   * The ring buffer data collection is event based:
+   * - Driver calls this callback when new records are available, the
+   *   |WifiDebugRingBufferStatus| passed up to framework in the callback
+   *   indicates to framework if more data is available in the ring buffer.
+   *   It is not expected that driver will necessarily always empty the ring
+   *   immediately as data is available, instead driver will report data
+   *   every X seconds or if N bytes are available based on the parameters
+   *   set via |startLoggingToDebugRingBuffer|.
+   * - In the case where a bug report has to be captured, framework will
+   *   require driver to upload all data immediately. This is indicated to
+   *   driver when framework calls |forceDumpToDebugRingBuffer|.  The driver
+   *   will start sending all available data in the indicated ring by repeatedly
+   *   invoking this callback.
+   *
+   * @return status Status of the corresponding ring buffer. This should
+   *         contain the name of the ring buffer on which the data is
+   *         available.
+   * @return entries Vector of debug ring buffer data entries. These
+   *         should be parsed based on the type of entry.
    */
-  oneway onChipReconfigureFailure(ChipModeId modeId, FailureReason reason);
+  /** Connectivity event data callback */
+  oneway onDebugRingBufferConnectivityEventEntriesAvailable(
+      WifiDebugRingBufferStatus status,
+      vec<WifiDebugRingEntryConnectivityEvent> entries);
 
-  /**
-   * Information about the version of the driver and firmware running this chip.
-   *
-   * This information is vendor specific and does not need to take any
-   * particular format. It will be dumped as part of the bug report.
-   */
-  struct ChipDebugInfo {
-    string driverDescription;
-    string firmwareDescription;
-  };
+  /** Power event data callback */
+  oneway onDebugRingBufferPowerEventEntriesAvailable(
+      WifiDebugRingBufferStatus status,
+      vec<WifiDebugRingEntryPowerEvent> entries);
 
-  /**
-   * Callback with debug information about this chip
-   *
-   * @param info Instance of |ChipDebugInfo|.
-   */
-  oneway onChipDebugInfoAvailable(ChipDebugInfo info);
+  /** Wakelock event data callback */
+  oneway onDebugRingBufferWakelockEventEntriesAvailable(
+      WifiDebugRingBufferStatus status,
+      vec<WifiDebugRingEntryWakelockEvent> entries);
 
-  /**
-   * Callback to be invoked on failure to fetch debug info about this chip.
-   *
-   * @param reason Failure reason code.
-   */
-  oneway onChipDebugInfoFailure(FailureReason reason);
-
-  /**
-   * Callback with a vendor specific debug blob from the driver.
-   * This blob will be dumped as part of the bug report.
-   *
-   * @param blob Vector of bytes retrieved from the driver.
-   */
-  oneway onDriverDebugDumpAvailable(vec<uint8_t> blob);
-
-  /**
-   * Callback to be invoked on failure to fetch debug blob from driver.
-   *
-   * @param reason Failure reason code.
-   */
-  oneway onDriverDebugDumpFailure(FailureReason reason);
-
-  /**
-   * Callback with a vendor specific debug blob from the driver.
-   * This blob will be dumped as part of the bug report.
-   *
-   * @param blob Vector of bytes retrieved from the driver.
-   */
-  oneway onFirmwareDebugDumpAvailable(vec<uint8_t> blob);
-
-  /**
-   * Callback to be invoked on failure to fetch debug blob from driver.
-   *
-   * @param reason Failure reason code.
-   */
-  oneway onFirmwareDebugDumpFailure(FailureReason reason);
+  /** Vendor data event data callback */
+  oneway onDebugRingBufferVendorDataEntriesAvailable(
+      WifiDebugRingBufferStatus status,
+      vec<WifiDebugRingEntryVendorData> entries);
 };
diff --git a/wifi/1.0/IWifiEventCallback.hal b/wifi/1.0/IWifiEventCallback.hal
index 33accff..718f36c 100644
--- a/wifi/1.0/IWifiEventCallback.hal
+++ b/wifi/1.0/IWifiEventCallback.hal
@@ -24,16 +24,6 @@
   oneway onStart();
 
   /**
-   * Called in response to a call to start indicating that the operation
-   * failed. After this callback the HAL will be considered stopped. Another
-   * call to start will attempt to reinitialize the HAL; however, there is a
-   * chance it may fail again.
-   *
-   * @param reason Failure reason code.
-   */
-  oneway onStartFailure(FailureReason reason);
-
-  /**
    * Called in response to a call to stop indicating that the operation
    * completed. When this event is received all IWifiChip objects retrieved
    * after the last call to start will be considered invalid.
@@ -43,10 +33,10 @@
   /**
    * Called when the Wi-Fi system failed in a way that caused it be disabled.
    * Calling start again must restart Wi-Fi as if stop then start was called
-   * (full state reset). When this event is received all IWifiChip objects
-   * retrieved after the last call to start will be considered invalid.
+   * (full state reset). When this event is received all IWifiChip & IWifiIface
+   * objects retrieved after the last call to start will be considered invalid.
    *
-   * @param reason Failure reason code.
+   * @param status Failure reason code.
    */
-  oneway onFailure(FailureReason reason);
+  oneway onFailure(WifiStatus status);
 };
diff --git a/wifi/1.0/IWifiIface.hal b/wifi/1.0/IWifiIface.hal
index f4150e7..444e095 100644
--- a/wifi/1.0/IWifiIface.hal
+++ b/wifi/1.0/IWifiIface.hal
@@ -23,14 +23,22 @@
   /**
    * Get the type of this iface.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|
    * @return type One of the supported iface types.
    */
-  getType() generates (IfaceType type);
+  getType() generates (WifiStatus status, IfaceType type);
 
   /**
    * Get the name of this iface.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|
    * @return name Name of the iface.
    */
-  getName() generates (string name);
+  getName() generates (WifiStatus status, string name);
 };
diff --git a/wifi/1.0/IWifiNanIface.hal b/wifi/1.0/IWifiNanIface.hal
index dade94c..2926c4f 100644
--- a/wifi/1.0/IWifiNanIface.hal
+++ b/wifi/1.0/IWifiNanIface.hal
@@ -17,10 +17,259 @@
 package android.hardware.wifi@1.0;
 
 import IWifiIface;
+import IWifiNanIfaceEventCallback;
 
 /**
- * Interface used to represent a single NAN iface.
+ * Interface used to represent a single NAN(Neighbour Aware Network) iface.
  */
 interface IWifiNanIface extends IWifiIface {
-  /** TODO(rpius): Add methods to the interface. */
+  /**
+   * Requests notifications of significant events on this iface. Multiple calls
+   * to this must register multiple callbacks each of which must receive all
+   * events.
+   *
+   * @param callback An instance of the |IWifiNanIfaceEventCallback| HIDL interface
+   *        object.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|
+   */
+  registerEventCallback(IWifiNanIfaceEventCallback callback)
+      generates (WifiStatus status);
+
+  /**
+   * Enable NAN functionality.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanEnableRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  enableRequest(CommandId cmdId, NanEnableRequest msg)
+      generates (WifiStatus status);
+
+  /**
+   * Disable NAN functionality.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  disableRequest(CommandId cmdId) generates (WifiStatus status);
+
+  /**
+   * Publish request to advertize a service.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanPublishRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  publishRequest(CommandId cmdId, NanPublishRequest msg)
+      generates (WifiStatus status);
+
+  /**
+   * Cancel previous publish requests.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanPublishCancelRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  publishCancelRequest(CommandId cmdId, NanPublishCancelRequest msg)
+      generates (WifiStatus status);
+
+  /**
+   * Subscribe request to search for a service.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanSubscribeRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  subscribeRequest(CommandId cmdId, NanSubscribeRequest msg)
+      generates (WifiStatus status);
+
+  /**
+   * Cancel previous subscribe requests.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanSubscribeCancelRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  subscribeCancelRequest(CommandId cmdId, NanSubscribeCancelRequest msg)
+      generates (WifiStatus status);
+
+  /**
+   * NAN transmit follow up request.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanTransmitFollowupRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  transmitFollowupRequest(CommandId cmdId, NanTransmitFollowupRequest msg)
+      generates (WifiStatus status);
+
+  /**
+   * NAN configuration request.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanConfigRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  configRequest(CommandId cmdId, NanConfigRequest msg)
+      generates (WifiStatus status);
+
+  /**
+   * Set NAN Beacon or sdf payload to discovery engine.
+   * This instructs the Discovery Engine to begin publishing the
+   * received payload in any Beacon or Service Discovery Frame transmitted
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanBeaconSdfPayloadRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  beaconSdfPayloadRequest(CommandId cmdId, NanBeaconSdfPayloadRequest msg)
+      generates (WifiStatus status);
+
+  /**
+   * Get NAN HAL version.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @return version Instance of |NanVersion|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  getVersion() generates (WifiStatus status, NanVersion version);
+
+  /**
+   * Get NAN capabilities.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  getCapabilities(CommandId cmdId) generates (WifiStatus status);
+
+  /**
+   * Create NAN Data Interface
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  dataInterfaceCreate(CommandId cmdId, string ifaceName)
+      generates (WifiStatus status);
+
+  /**
+   * Delete NAN Data Interface.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  dataInterfaceDelete(CommandId cmdId, string ifaceName)
+      generates (WifiStatus status);
+
+  /**
+   * Initiate a NDP session: Initiator
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanDataPathInitiatorRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  dataRequestInitiator(CommandId cmdId, NanDataPathInitiatorRequest msg)
+      generates (WifiStatus status);
+
+  /**
+   * Response to a data indication received corresponding to a NDP session. An indication
+   * is received with a data request and the responder will send a data response.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanDataPathIndicationResponse|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  dataIndicationResponse(CommandId cmdId, NanDataPathIndicationResponse msg)
+      generates (WifiStatus status);
+
+  /**
+   * NDL termination request: from either Initiator/Responder.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param msg Instance of |NanDataPathEndRequest|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  dataEnd(CommandId cmdId, NanDataPathEndRequest msg)
+      generates (WifiStatus status);
 };
diff --git a/wifi/1.0/IWifiNanIfaceEventCallback.hal b/wifi/1.0/IWifiNanIfaceEventCallback.hal
new file mode 100644
index 0000000..2b90cba
--- /dev/null
+++ b/wifi/1.0/IWifiNanIfaceEventCallback.hal
@@ -0,0 +1,81 @@
+/*
+ * Copyright 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.wifi@1.0;
+
+/**
+ * NAN Response and Event Callbacks.
+ */
+interface IWifiNanIfaceEventCallback {
+  /**
+   * Callback invoked to notify the status of the Publish Request.
+   *
+   * @param cmdId command Id corresponding to the original request.
+   * @param rspData Message Data.
+   */
+  oneway notifyPublishResponse(CommandId id, NanPublishResponseMsg rspData);
+
+  /**
+   * Callback invoked to notify the status of the Subscribe Request.
+   *
+   * @param cmdId command Id corresponding to the original request.
+   * @param rspData Message Data.
+   */
+  oneway notifySubscribeResponse(CommandId id, NanSubscribeResponseMsg rspData);
+
+  /**
+   * Callback invoked to notify the status of the Data Path Request.
+   *
+   * @param cmdId command Id corresponding to the original request.
+   * @param rspData Message Data.
+   */
+  oneway notifyDataPathResponse(CommandId id, NanDataPathResponseMsg rspData);
+
+  /**
+   * Callback invoked to notify the status of the Capability Request.
+   *
+   * @param cmdId command Id corresponding to the original request.
+   * @param rspData Message Data.
+   */
+  oneway notifyCapabilitiesResponse(CommandId id, NanCapabilitiesResponseMsg rspData);
+
+  /**
+   * Callbacks for the various asynchornous NAN Events.
+   */
+  oneway eventPublishTerminated(NanPublishTerminatedInd event);
+
+  oneway eventMatch(NanMatchInd event);
+
+  oneway eventMatchExpired(NanMatchExpiredInd event);
+
+  oneway eventSubscribeTerminated(NanSubscribeTerminatedInd event);
+
+  oneway eventFollowup(NanFollowupInd event);
+
+  oneway eventDiscEngEvent(NanDiscEngEventInd event);
+
+  oneway eventDisabled(NanDisabledInd event);
+
+  oneway eventBeaconSdfPayload(NanBeaconSdfPayloadInd event);
+
+  oneway eventDataRequest(NanDataPathRequestInd event);
+
+  oneway eventDataConfirm(NanDataPathConfirmInd event);
+
+  oneway eventDataEnd(NanDataPathEndInd event);
+
+  oneway eventTransmitFollowup(NanTransmitFollowupInd event);
+};
diff --git a/wifi/1.0/IWifiRttController.hal b/wifi/1.0/IWifiRttController.hal
index d735da7..93b3d92 100644
--- a/wifi/1.0/IWifiRttController.hal
+++ b/wifi/1.0/IWifiRttController.hal
@@ -17,16 +17,225 @@
 package android.hardware.wifi@1.0;
 
 import IWifiIface;
+import IWifiRttControllerEventCallback;
 
 /**
- * Interface used to perform RTT operations.
+ * Interface used to perform RTT(Round trip time) operations.
  */
 interface IWifiRttController {
   /**
-   * Get the iface on which the RTT operations will be performed.
+   * Get the iface on which the RTT operations must be performed.
    *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|
    * @return boundIface HIDL interface object representing the iface if bound
    *         to a specific iface, null otherwise
    */
-  getBoundIface() generates (IWifiIface boundIface);
+  getBoundIface() generates (WifiStatus status, IWifiIface boundIface);
+
+  /**
+   * Requests notifications of significant events on this rtt controller.
+   * Multiple calls to this must register multiple callbacks each of which must
+   * receive all events.
+   *
+   * @param callback An instance of the |IWifiRttControllerEventCallback| HIDL
+   *        interface object.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|
+   */
+  registerEventCallback(IWifiRttControllerEventCallback callback)
+      generates (WifiStatus status);
+
+  /**
+   * API to request RTT measurement.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param rttConfigs Vector of |RttConfig| parameters.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  rangeRequest(CommandId cmdId, vec<RttConfig> rttConfigs)
+      generates (WifiStatus status);
+
+  /**
+   * API to cancel RTT measurements.
+   *
+   * @param cmdId command Id corresponding to the original request.
+   * @param addrs Vector of addresses for which to cancel.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  rangeCancel(CommandId cmdId, vec<MacAddress> addrs)
+      generates (WifiStatus status);
+
+  /**
+   * API to start publishing the channel map on responder device in an NBD
+   * cluster.
+   * Responder device must take this request and schedule broadcasting the
+   * channel map in a NBD ranging attribute in a Service Discovery Frame.
+   * DE must automatically remove the ranging attribute from the OTA queue
+   * after number of Discovery Window specified by numDw where each
+   * Discovery Window is 512 TUs apart.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param params Instance of |RttChannelMap|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  setChannelMap(CommandId cmdId, RttChannelMap params, uint32_t numDw)
+      generates (WifiStatus status);
+
+  /**
+   * API to clear the channel map on the responder device in an NBD cluster.
+   * Responder device must cancel future ranging channel request, starting from
+   * next Discovery Window interval and must also stop broadcasting NBD
+   * ranging attribute in Service Discovery Frame.
+   *
+   * @param cmdId command Id corresponding to the original request.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  clearChannelMap(CommandId cmdId) generates (WifiStatus status);
+
+  /**
+   * RTT capabilities of the device.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return capabilities Instance of |RttCapabilities|.
+   */
+  getCapabilities() generates (WifiStatus status, RttCapabilities capabilities);
+
+  /**
+   * Set configuration for debug.
+   *
+   * @param type debug level to be set.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  setDebugCfg(RttDebugType Type) generates (WifiStatus status);
+
+  /**
+   * Get the debug information.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return info Instance of |RttDebugInfo|.
+   */
+  getDebugInfo() generates (WifiStatus status, RttDebugInfo info);
+
+  /**
+   * API to configure the LCI(Location civic information).
+   * Used in RTT Responder mode only.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param lci Instance of |RttLciInformation|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  setLci(CommandId cmdId, RttLciInformation lci) generates (WifiStatus status);
+
+  /**
+   * API to configure the LCR(Location civic records).
+   * Used in RTT Responder mode only.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param lcr Instance of |RttLcrInformation|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  setLcr(CommandId cmdId, RttLcrInformation lcr) generates (WifiStatus status);
+
+  /**
+   * Get RTT responder information e.g. WiFi channel to enable responder on.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return info Instance of |RttResponderInfo|.
+   */
+  getResponderInfo() generates (WifiStatus status, RttResponder info);
+
+  /**
+   * Enable RTT responder mode.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @parm channelHint Hint of the channel information where RTT responder must
+   *       be enabled on.
+   * @param maxDurationInSeconds Timeout of responder mode.
+   * @param info Instance of |RttResponderInfo|.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  enableResponder(CommandId cmdId,
+                  WifiChannelInfo channelHint,
+                  uint32_t maxDurationSeconds,
+                  RttResponder info)
+      generates (WifiStatus status);
+
+  /**
+   * Disable RTT responder mode.
+   *
+   * @param cmdId command Id corresponding to the original request.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_RTT_CONTROLLER_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  disableResponder(CommandId cmdId) generates (WifiStatus status);
 };
diff --git a/wifi/1.0/IWifiRttControllerEventCallback.hal b/wifi/1.0/IWifiRttControllerEventCallback.hal
new file mode 100644
index 0000000..e23e395
--- /dev/null
+++ b/wifi/1.0/IWifiRttControllerEventCallback.hal
@@ -0,0 +1,30 @@
+/*
+ * Copyright 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.wifi@1.0;
+
+/**
+ * RTT Response and Event Callbacks.
+ */
+interface IWifiRttControllerEventCallback {
+  /**
+   * Invoked when an RTT result is available.
+   *
+   * @param cmdId command Id corresponding to the original request.
+   * @param results Vector of |RttResult| instances.
+   */
+  oneway onResults(CommandId cmdId, vec<RttResult> results);
+};
diff --git a/wifi/1.0/IWifiStaIface.hal b/wifi/1.0/IWifiStaIface.hal
index 5234c71..41b2bad 100644
--- a/wifi/1.0/IWifiStaIface.hal
+++ b/wifi/1.0/IWifiStaIface.hal
@@ -17,10 +17,331 @@
 package android.hardware.wifi@1.0;
 
 import IWifiIface;
+import IWifiStaIfaceEventCallback;
 
 /**
  * Interface used to represent a single STA iface.
  */
 interface IWifiStaIface extends IWifiIface {
-  /** TODO(rpius): Add methods to the interface. */
+  /**
+   * Mask of capabilities suported by this Iface.
+   */
+  enum StaIfaceCapabilityMask : uint32_t {
+    /**
+     * If set indicates that the APF APIs are supported.
+     * APF (Android Packet Filter) is a BPF like packet filtering
+     * bytecode executed by the firmware.
+     */
+    APF = 1 << 0,
+    /**
+     * If set indicates that the Background Scan APIs are supported.
+     * Background scan allow the host to send a number of buckets down to the
+     * firmware. Each bucket contains a set of channels, a period, and some
+     * parameters about how and when to report results.
+     */
+    BACKGROUND_SCAN = 1 << 1,
+    /**
+     * If set indicates that the link layer stats APIs are supported.
+     */
+    LINK_LAYER_STATS = 1 << 2,
+    /**
+     * Tracks connection packets' fate.
+     */
+    DEBUG_PACKET_FATE_SUPPORTED = 1 << 3
+  };
+
+  /**
+   * Requests notifications of significant events on this iface. Multiple calls
+   * to this must register multiple callbacks each of which must receive all
+   * events.
+   *
+   * @param callback An instance of the |IWifiStaIfaceEventCallback| HIDL interface
+   *        object.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|
+   */
+  registerEventCallback(IWifiStaIfaceEventCallback callback)
+      generates (WifiStatus status);
+
+  /**
+   * Get the capabilities supported by this STA iface.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return capabilities Bitset of |StaIfaceCapabilityMask| values.
+   */
+  getCapabilities() generates (WifiStatus status, uint32_t capabilities);
+
+  /**
+   * Used to query additional information about the chip's APF capabilities.
+   * Must fail if |StaIfaceCapabilityMask.APF| is not set.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return capabilities Instance of |StaApfPacketFilterCapabilities|.
+   */
+  getApfPacketFilterCapabilities()
+      generates (WifiStatus status, StaApfPacketFilterCapabilities capabilities);
+
+  /**
+   * Installs an APF program on this iface, replacing an existing
+   * program if present.
+   * Must fail if |StaIfaceCapabilityMask.APF| is not set.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @param APF Program to be set.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  installApfPacketFilter(CommandId cmdId, vec<uint8_t> program)
+      generates (WifiStatus status);
+
+  /**
+   * Used to query additional information about the chip's Background Scan capabilities.
+   * Must fail if |StaIfaceCapabilityMask.BACKGROUND_SCAN| is not set.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return capabilities Instance of |StaBackgroundScanCapabilities|.
+   */
+  getBackgroundScanCapabilities()
+      generates (WifiStatus status, StaBackgroundScanCapabilities capabilities);
+
+  /**
+   * Used to query the list of valid frequencies (depending on country code set)
+   * for the provided band. These channels may be specifed in the
+   * |BackgroundScanBucketParameters.frequenciesInMhz| for a background scan
+   * request.
+   * Must fail if |StaIfaceCapabilityMask.BACKGROUND_SCAN| is not set.
+   *
+   * @param band Band for which the frequency list is being generated.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return frequencies vector of valid frequencies for the provided band.
+   */
+  getValidFrequenciesForBackgroundScan(StaBackgroundScanBand band)
+      generates (WifiStatus status, vec<WifiChannelInMhz> frequencies);
+
+  /**
+   * Start a background scan using the given cmdId as an identifier. Only one
+   * active background scan need be supported.
+   * Must fail if |StaIfaceCapabilityMask.BACKGROUND_SCAN| is not set.
+   *
+   * When this is called all requested buckets must be scanned, starting the
+   * beginning of the cycle.
+   *
+   * For example:
+   * If there are two buckets specified
+   *  - Bucket 1: period=10s
+   *  - Bucket 2: period=20s
+   *  - Bucket 3: period=30s
+   * Then the following scans must occur
+   *  - t=0  buckets 1, 2, and 3 are scanned
+   *  - t=10 bucket 1 is scanned
+   *  - t=20 bucket 1 and 2 are scanned
+   *  - t=30 bucket 1 and 3 are scanned
+   *  - t=40 bucket 1 and 2 are scanned
+   *  - t=50 bucket 1 is scanned
+   *  - t=60 buckets 1, 2, and 3 are scanned
+   *  - and the patter repeats
+   *
+   * If any scan does not occur or is incomplete (error, interrupted, etc) then
+   * a cached scan result must still be recorded with the
+   * WIFI_SCAN_FLAG_INTERRUPTED flag set.
+   *
+   * @param cmdId command Id to use for this invocation.
+   * @params Background scan parameters.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_INVALID_ARGS|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  startBackgroundScan(CommandId cmdId, StaBackgroundScanParameters params)
+      generates (WifiStatus status);
+
+  /**
+   * Stop the background scan started.
+   * Must fail if |StaIfaceCapabilityMask.BACKGROUND_SCAN| is not set.
+   *
+   * @param cmdId command Id corresponding to the request.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_STARTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  stopBackgroundScan(CommandId cmdId) generates (WifiStatus status);
+
+  /**
+   * Enable link layer stats collection.
+   * Must fail if |StaIfaceCapabilityMask.LINK_LAYER_STATS| is not set.
+   *
+   * Radio statistics (once started) must not stop until disabled.
+   * Iface statistics (once started) reset and start afresh after each
+   * connection until disabled.
+   *
+   * @param debug Set for field debug mode. Driver must collect all
+   *        statistics regardless of performance impact.
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  enableLinkLayerStatsCollection(bool debug)
+      generates (WifiStatus status);
+
+  /**
+   * Disable link layer stats collection.
+   * Must fail if |StaIfaceCapabilityMask.LINK_LAYER_STATS| is not set.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_STARTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  disableLinkLayerStatsCollection() generates (WifiStatus status);
+
+  /**
+   * Retrieve the latest link layer stats.
+   * Must fail if |StaIfaceCapabilityMask.LINK_LAYER_STATS| is not set or if
+   * link layer stats collection hasn't been explicitly enabled.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_STARTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return stats Instance of |LinkLayerStats|.
+   */
+  getLinkLayerStats() generates (WifiStatus status, StaLinkLayerStats stats);
+
+  /**
+   * API to start packet fate monitoring.
+   * - Once stared, monitoring must remain active until HAL is unloaded.
+   * - When HAL is unloaded, all packet fate buffers must be cleared.
+   * - The packet fates are used to monitor the state of packets transmitted/
+   *   received during association.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  startDebugPacketFateMonitoring() generates (WifiStatus status);
+
+  /**
+   * API to stop packet fate monitoring.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_STARTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   */
+  stopDebugPacketFateMonitoring() generates (WifiStatus status);
+
+  /**
+   * API to retrieve fates of outbound packets.
+   * - HAL implementation must return the fates of
+   *   all the frames transmitted for the most recent association.
+   *   The fate reports must follow the same order as their respective
+   *   packets.
+   * - HAL implementation may choose (but is not required) to include
+   *   reports for management frames.
+   * - Packets reported by firmware, but not recognized by driver,
+   *   must be included. However, the ordering of the corresponding
+   *   reports is at the discretion of HAL implementation.
+   * - Framework must be able to call this API multiple times for the same
+   *   association.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_STARTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return fates Vector of |WifiDebugTxPacketFateReport| instances corresponding
+   *         to the packet fates.
+   */
+  getDebugTxPacketFates()
+      generates (WifiStatus status, vec<WifiDebugTxPacketFateReport> fates);
+
+  /**
+   * API to retrieve fates of inbound packets.
+   * - HAL implementation must return the fates of
+   *   all the frames received for the most recent association.
+   *   The fate reports must follow the same order as their respective
+   *   packets.
+   * - HAL implementation may choose (but is not required) to include
+   *   reports for management frames.
+   * - Packets reported by firmware, but not recognized by driver,
+   *   must be included. However, the ordering of the corresponding
+   *   reports is at the discretion of HAL implementation.
+   * - Framework must be able to call this API multiple times for the same
+   *   association.
+   *
+   * @return status WifiStatus of the operation.
+   *         Possible status codes:
+   *         |WifiStatusCode.SUCCESS|,
+   *         |WifiStatusCode.ERROR_WIFI_IFACE_INVALID|,
+   *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+   *         |WifiStatusCode.ERROR_NOT_STARTED|,
+   *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
+   *         |WifiStatusCode.ERROR_UNKNOWN|
+   * @return fates Vector of |WifiDebugRxPacketFateReport| instances corresponding
+   *         to the packet fates.
+   */
+  getDebugRxPacketFates()
+      generates (WifiStatus status, vec<WifiDebugRxPacketFateReport> fates);
 };
diff --git a/wifi/1.0/IWifiStaIfaceEventCallback.hal b/wifi/1.0/IWifiStaIfaceEventCallback.hal
new file mode 100644
index 0000000..d47d40c
--- /dev/null
+++ b/wifi/1.0/IWifiStaIfaceEventCallback.hal
@@ -0,0 +1,46 @@
+/*
+ * Copyright 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.wifi@1.0;
+
+interface IWifiStaIfaceEventCallback {
+  /**
+   * Callback indicating that an ongoing background scan request has failed.
+   * The background scan needs to be restarted to continue scanning.
+   */
+  oneway onBackgroundScanFailure(CommandId cmdId);
+
+  /**
+   * Called for each received beacon/probe response for a scan with the
+   * |REPORT_EVENTS_FULL_RESULTS| flag set in
+   * |StaBackgroundScanBucketParameters.eventReportScheme|.
+   *
+   * @param cmdId command Id corresponding to the request.
+   * @parm result Full scan result for an AP.
+   */
+  oneway onBackgroundFullScanResult(CommandId cmdId, StaScanResult result);
+
+  /**
+   * Called when the |StaBackgroundScanBucketParameters.eventReportScheme| flags
+   * for at least one bucket that was just scanned was
+   * |REPORT_EVENTS_EACH_SCAN| or one of the configured thresholds was
+   * breached.
+   *
+   * @param cmdId command Id corresponding to the request.
+   * @parm scanDatas List of scan result for all AP's seen since last callback.
+   */
+  oneway onBackgroundScanResults(CommandId cmdId, vec<StaScanData> scanDatas);
+};
diff --git a/wifi/1.0/default/Android.mk b/wifi/1.0/default/Android.mk
index 3fd5fba..646613b 100644
--- a/wifi/1.0/default/Android.mk
+++ b/wifi/1.0/default/Android.mk
@@ -14,11 +14,11 @@
 LOCAL_PATH := $(call my-dir)
 
 include $(CLEAR_VARS)
-LOCAL_MODULE := android.hardware.wifi@1.0-impl
+LOCAL_MODULE := android.hardware.wifi@1.0-service
 LOCAL_MODULE_RELATIVE_PATH := hw
 LOCAL_CPPFLAGS := -std=c++11 -Wall -Wno-unused-parameter -Werror -Wextra
 LOCAL_SRC_FILES := \
-    failure_reason_util.cpp \
+    service.cpp \
     wifi.cpp \
     wifi_ap_iface.cpp \
     wifi_chip.cpp \
@@ -26,32 +26,14 @@
     wifi_nan_iface.cpp \
     wifi_p2p_iface.cpp \
     wifi_rtt_controller.cpp \
-    wifi_sta_iface.cpp
+    wifi_sta_iface.cpp \
+    wifi_status_util.cpp
 LOCAL_SHARED_LIBRARIES := \
     android.hardware.wifi@1.0 \
     libbase \
     libcutils \
-    libhidl \
-    libhwbinder \
-    liblog \
-    libnl \
-    libutils \
-    libwifi-system
-LOCAL_WHOLE_STATIC_LIBRARIES := $(LIB_WIFI_HAL)
-include $(BUILD_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := android.hardware.wifi@1.0-service
-LOCAL_MODULE_RELATIVE_PATH := hw
-LOCAL_CPPFLAGS := -std=c++11 -Wall -Wno-unused-parameter -Werror -Wextra
-LOCAL_SRC_FILES := \
-    service.cpp
-LOCAL_SHARED_LIBRARIES := \
-    android.hardware.wifi@1.0 \
-    android.hardware.wifi@1.0-impl \
-    libbase \
-    libcutils \
-    libhidl \
+    libhidlbase \
+    libhidltransport \
     libhwbinder \
     liblog \
     libnl \
diff --git a/wifi/1.0/default/failure_reason_util.cpp b/wifi/1.0/default/failure_reason_util.cpp
deleted file mode 100644
index f703ebe..0000000
--- a/wifi/1.0/default/failure_reason_util.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * 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.
- */
-
-#include "failure_reason_util.h"
-
-namespace android {
-namespace hardware {
-namespace wifi {
-namespace V1_0 {
-namespace implementation {
-
-std::string LegacyErrorToString(wifi_error error) {
-  switch (error) {
-    case WIFI_SUCCESS:
-      return "SUCCESS";
-    case WIFI_ERROR_UNINITIALIZED:
-      return "UNINITIALIZED";
-    case WIFI_ERROR_NOT_AVAILABLE:
-      return "NOT_AVAILABLE";
-    case WIFI_ERROR_NOT_SUPPORTED:
-      return "NOT_SUPPORTED";
-    case WIFI_ERROR_INVALID_ARGS:
-      return "INVALID_ARGS";
-    case WIFI_ERROR_INVALID_REQUEST_ID:
-      return "INVALID_REQUEST_ID";
-    case WIFI_ERROR_TIMED_OUT:
-      return "TIMED_OUT";
-    case WIFI_ERROR_TOO_MANY_REQUESTS:
-      return "TOO_MANY_REQUESTS";
-    case WIFI_ERROR_OUT_OF_MEMORY:
-      return "OUT_OF_MEMORY";
-    case WIFI_ERROR_UNKNOWN:
-    default:
-      return "UNKNOWN";
-  }
-}
-
-FailureReason CreateFailureReason(CommandFailureReason reason,
-                                  const std::string& description) {
-  FailureReason result;
-  result.reason = reason;
-  result.description = description.data();
-  return result;
-}
-
-FailureReason CreateFailureReasonLegacyError(wifi_error error,
-                                             const std::string& desc) {
-  switch (error) {
-    case WIFI_ERROR_UNINITIALIZED:
-    case WIFI_ERROR_NOT_AVAILABLE:
-      return CreateFailureReason(CommandFailureReason::NOT_AVAILABLE, desc);
-
-    case WIFI_ERROR_NOT_SUPPORTED:
-      return CreateFailureReason(CommandFailureReason::NOT_SUPPORTED, desc);
-
-    case WIFI_ERROR_INVALID_ARGS:
-    case WIFI_ERROR_INVALID_REQUEST_ID:
-      return CreateFailureReason(CommandFailureReason::INVALID_ARGS, desc);
-
-    case WIFI_ERROR_TIMED_OUT:
-      return CreateFailureReason(CommandFailureReason::UNKNOWN,
-                                 desc + ", timed out");
-
-    case WIFI_ERROR_TOO_MANY_REQUESTS:
-      return CreateFailureReason(CommandFailureReason::UNKNOWN,
-                                 desc + ", too many requests");
-
-    case WIFI_ERROR_OUT_OF_MEMORY:
-      return CreateFailureReason(CommandFailureReason::UNKNOWN,
-                                 desc + ", out of memory");
-
-    case WIFI_ERROR_NONE:
-    case WIFI_ERROR_UNKNOWN:
-    default:
-      return CreateFailureReason(CommandFailureReason::UNKNOWN, "unknown");
-  }
-}
-
-}  // namespace implementation
-}  // namespace V1_0
-}  // namespace wifi
-}  // namespace hardware
-}  // namespace android
diff --git a/wifi/1.0/default/hidl_return_util.h b/wifi/1.0/default/hidl_return_util.h
new file mode 100644
index 0000000..2986165
--- /dev/null
+++ b/wifi/1.0/default/hidl_return_util.h
@@ -0,0 +1,109 @@
+/*
+ * 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 HIDL_RETURN_UTIL_H_
+#define HIDL_RETURN_UTIL_H_
+
+#include "wifi_status_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_0 {
+namespace implementation {
+namespace hidl_return_util {
+
+/**
+ * These utility functions are used to invoke a method on the provided
+ * HIDL interface object.
+ * These functions checks if the provided HIDL interface object is valid.
+ * a) if valid, Invokes the corresponding internal implementation function of
+ * the HIDL method. It then invokes the HIDL continuation callback with
+ * the status and any returned values.
+ * b) if invalid, invokes the HIDL continuation callback with the
+ * provided error status and default values.
+ */
+// Use for HIDL methods which return only an instance of WifiStatus.
+template <typename ObjT, typename WorkFuncT, typename... Args>
+Return<void> validateAndCall(
+    ObjT* obj,
+    WifiStatusCode status_code_if_invalid,
+    WorkFuncT&& work,
+    const std::function<void(const WifiStatus&)>& hidl_cb,
+    Args&&... args) {
+  if (obj->isValid()) {
+    hidl_cb((obj->*work)(std::forward<Args>(args)...));
+  } else {
+    hidl_cb(createWifiStatus(status_code_if_invalid));
+  }
+  return Void();
+}
+
+// Use for HIDL methods which return instance of WifiStatus and a single return
+// value.
+template <typename ObjT, typename WorkFuncT, typename ReturnT, typename... Args>
+Return<void> validateAndCall(
+    ObjT* obj,
+    WifiStatusCode status_code_if_invalid,
+    WorkFuncT&& work,
+    const std::function<void(const WifiStatus&, ReturnT)>& hidl_cb,
+    Args&&... args) {
+  if (obj->isValid()) {
+    const auto& ret_pair = (obj->*work)(std::forward<Args>(args)...);
+    const WifiStatus& status = std::get<0>(ret_pair);
+    const auto& ret_value = std::get<1>(ret_pair);
+    hidl_cb(status, ret_value);
+  } else {
+    hidl_cb(createWifiStatus(status_code_if_invalid),
+            typename std::remove_reference<ReturnT>::type());
+  }
+  return Void();
+}
+
+// Use for HIDL methods which return instance of WifiStatus and 2 return
+// values.
+template <typename ObjT,
+          typename WorkFuncT,
+          typename ReturnT1,
+          typename ReturnT2,
+          typename... Args>
+Return<void> validateAndCall(
+    ObjT* obj,
+    WifiStatusCode status_code_if_invalid,
+    WorkFuncT&& work,
+    const std::function<void(const WifiStatus&, ReturnT1, ReturnT2)>& hidl_cb,
+    Args&&... args) {
+  if (obj->isValid()) {
+    const auto& ret_tuple = (obj->*work)(std::forward<Args>(args)...);
+    const WifiStatus& status = std::get<0>(ret_tuple);
+    const auto& ret_value1 = std::get<1>(ret_tuple);
+    const auto& ret_value2 = std::get<2>(ret_tuple);
+    hidl_cb(status, ret_value1, ret_value2);
+  } else {
+    hidl_cb(createWifiStatus(status_code_if_invalid),
+            typename std::remove_reference<ReturnT1>::type(),
+            typename std::remove_reference<ReturnT2>::type());
+  }
+  return Void();
+}
+
+}  // namespace hidl_util
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+#endif  // HIDL_RETURN_UTIL_H_
diff --git a/wifi/1.0/default/wifi.cpp b/wifi/1.0/default/wifi.cpp
index ff2eb4c..3475c46 100644
--- a/wifi/1.0/default/wifi.cpp
+++ b/wifi/1.0/default/wifi.cpp
@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-#include "wifi.h"
-
 #include <android-base/logging.h>
 
-#include "failure_reason_util.h"
-#include "wifi_chip.h"
+#include "hidl_return_util.h"
+#include "wifi.h"
+#include "wifi_status_util.h"
 
 namespace {
 // Chip ID to use for the only supported chip.
@@ -31,63 +30,99 @@
 namespace wifi {
 namespace V1_0 {
 namespace implementation {
+using hidl_return_util::validateAndCall;
 
 Wifi::Wifi()
-    : legacy_hal_(new WifiLegacyHal()), run_state_(RunState::STOPPED) {}
+    : legacy_hal_(new legacy_hal::WifiLegacyHal()),
+      run_state_(RunState::STOPPED) {}
+
+bool Wifi::isValid() {
+  // This object is always valid.
+  return true;
+}
 
 Return<void> Wifi::registerEventCallback(
-    const sp<IWifiEventCallback>& callback) {
-  // TODO(b/31632518): remove the callback when the client is destroyed
-  callbacks_.emplace_back(callback);
-  return Void();
+    const sp<IWifiEventCallback>& event_callback,
+    registerEventCallback_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_UNKNOWN,
+                         &Wifi::registerEventCallbackInternal,
+                         hidl_status_cb,
+                         event_callback);
 }
 
 Return<bool> Wifi::isStarted() {
   return run_state_ != RunState::STOPPED;
 }
 
-Return<void> Wifi::start() {
+Return<void> Wifi::start(start_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_UNKNOWN,
+                         &Wifi::startInternal,
+                         hidl_status_cb);
+}
+
+Return<void> Wifi::stop(stop_cb hidl_status_cb) {
+  return validateAndCall(
+      this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::stopInternal, hidl_status_cb);
+}
+
+Return<void> Wifi::getChipIds(getChipIds_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_UNKNOWN,
+                         &Wifi::getChipIdsInternal,
+                         hidl_status_cb);
+}
+
+Return<void> Wifi::getChip(ChipId chip_id, getChip_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_UNKNOWN,
+                         &Wifi::getChipInternal,
+                         hidl_status_cb,
+                         chip_id);
+}
+
+WifiStatus Wifi::registerEventCallbackInternal(
+    const sp<IWifiEventCallback>& event_callback) {
+  // TODO(b/31632518): remove the callback when the client is destroyed
+  event_callbacks_.emplace_back(event_callback);
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus Wifi::startInternal() {
   if (run_state_ == RunState::STARTED) {
-    for (const auto& callback : callbacks_) {
-      callback->onStart();
-    }
-    return Void();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
   } else if (run_state_ == RunState::STOPPING) {
-    for (const auto& callback : callbacks_) {
-      callback->onStartFailure(CreateFailureReason(
-          CommandFailureReason::NOT_AVAILABLE, "HAL is stopping"));
-    }
-    return Void();
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
+                            "HAL is stopping");
   }
 
   LOG(INFO) << "Starting HAL";
-  wifi_error status = legacy_hal_->start();
-  if (status != WIFI_SUCCESS) {
-    LOG(ERROR) << "Failed to start Wifi HAL";
-    for (auto& callback : callbacks_) {
-      callback->onStartFailure(
-          CreateFailureReasonLegacyError(status, "Failed to start HAL"));
-    }
-    return Void();
+  wifi_error legacy_status = legacy_hal_->start();
+  if (legacy_status != WIFI_SUCCESS) {
+    LOG(ERROR) << "Failed to start Wifi HAL: "
+               << legacyErrorToString(legacy_status);
+    return createWifiStatusFromLegacyError(legacy_status,
+                                           "Failed to start HAL");
   }
 
   // Create the chip instance once the HAL is started.
   chip_ = new WifiChip(kChipId, legacy_hal_);
   run_state_ = RunState::STARTED;
-  for (const auto& callback : callbacks_) {
-    callback->onStart();
+  for (const auto& callback : event_callbacks_) {
+    if (!callback->onStart().getStatus().isOk()) {
+      LOG(ERROR) << "Failed to invoke onStart callback";
+    };
   }
-  return Void();
+  return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-Return<void> Wifi::stop() {
+WifiStatus Wifi::stopInternal() {
   if (run_state_ == RunState::STOPPED) {
-    for (const auto& callback : callbacks_) {
-      callback->onStop();
-    }
-    return Void();
+    return createWifiStatus(WifiStatusCode::SUCCESS);
   } else if (run_state_ == RunState::STOPPING) {
-    return Void();
+    return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
+                            "HAL is stopping");
   }
 
   LOG(INFO) << "Stopping HAL";
@@ -98,41 +133,43 @@
     }
     chip_.clear();
     run_state_ = RunState::STOPPED;
-    for (const auto& callback : callbacks_) {
-      callback->onStop();
+    for (const auto& callback : event_callbacks_) {
+      if (!callback->onStop().getStatus().isOk()) {
+        LOG(ERROR) << "Failed to invoke onStop callback";
+      };
     }
   };
-  wifi_error status = legacy_hal_->stop(on_complete_callback_);
-  if (status != WIFI_SUCCESS) {
-    LOG(ERROR) << "Failed to stop Wifi HAL";
-    for (const auto& callback : callbacks_) {
-      callback->onFailure(
-          CreateFailureReasonLegacyError(status, "Failed to stop HAL"));
+  wifi_error legacy_status = legacy_hal_->stop(on_complete_callback_);
+  if (legacy_status != WIFI_SUCCESS) {
+    LOG(ERROR) << "Failed to stop Wifi HAL: "
+               << legacyErrorToString(legacy_status);
+    WifiStatus wifi_status =
+        createWifiStatusFromLegacyError(legacy_status, "Failed to stop HAL");
+    for (const auto& callback : event_callbacks_) {
+      callback->onFailure(wifi_status);
     }
+    return wifi_status;
   }
-  return Void();
+  return createWifiStatus(WifiStatusCode::SUCCESS);
 }
 
-Return<void> Wifi::getChipIds(getChipIds_cb cb) {
+std::pair<WifiStatus, std::vector<ChipId>> Wifi::getChipIdsInternal() {
   std::vector<ChipId> chip_ids;
   if (chip_.get()) {
     chip_ids.emplace_back(kChipId);
   }
-  hidl_vec<ChipId> hidl_data;
-  hidl_data.setToExternal(chip_ids.data(), chip_ids.size());
-  cb(hidl_data);
-  return Void();
+  return {createWifiStatus(WifiStatusCode::SUCCESS), std::move(chip_ids)};
 }
 
-Return<void> Wifi::getChip(ChipId chip_id, getChip_cb cb) {
-  if (chip_.get() && chip_id == kChipId) {
-    cb(chip_);
-  } else {
-    cb(nullptr);
+std::pair<WifiStatus, sp<IWifiChip>> Wifi::getChipInternal(ChipId chip_id) {
+  if (!chip_.get()) {
+    return {createWifiStatus(WifiStatusCode::ERROR_NOT_STARTED), nullptr};
   }
-  return Void();
+  if (chip_id != kChipId) {
+    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS), chip_};
 }
-
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace wifi
diff --git a/wifi/1.0/default/wifi.h b/wifi/1.0/default/wifi.h
index 55ba12b..7872303 100644
--- a/wifi/1.0/default/wifi.h
+++ b/wifi/1.0/default/wifi.h
@@ -39,23 +39,34 @@
  public:
   Wifi();
 
+  bool isValid();
+
   // HIDL methods exposed.
   Return<void> registerEventCallback(
-      const sp<IWifiEventCallback>& callback) override;
+      const sp<IWifiEventCallback>& event_callback,
+      registerEventCallback_cb hidl_status_cb) override;
   Return<bool> isStarted() override;
-  Return<void> start() override;
-  Return<void> stop() override;
-  Return<void> getChipIds(getChipIds_cb cb) override;
-  Return<void> getChip(ChipId chip_id, getChip_cb cb) override;
+  Return<void> start(start_cb hidl_status_cb) override;
+  Return<void> stop(stop_cb hidl_status_cb) override;
+  Return<void> getChipIds(getChipIds_cb hidl_status_cb) override;
+  Return<void> getChip(ChipId chip_id, getChip_cb hidl_status_cb) override;
 
  private:
   enum class RunState { STOPPED, STARTED, STOPPING };
 
+  // Corresponding worker functions for the HIDL methods.
+  WifiStatus registerEventCallbackInternal(
+      const sp<IWifiEventCallback>& event_callback);
+  WifiStatus startInternal();
+  WifiStatus stopInternal();
+  std::pair<WifiStatus, std::vector<ChipId>> getChipIdsInternal();
+  std::pair<WifiStatus, sp<IWifiChip>> getChipInternal(ChipId chip_id);
+
   // Instance is created in this root level |IWifi| HIDL interface object
   // and shared with all the child HIDL interface objects.
-  std::shared_ptr<WifiLegacyHal> legacy_hal_;
+  std::shared_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
   RunState run_state_;
-  std::vector<sp<IWifiEventCallback>> callbacks_;
+  std::vector<sp<IWifiEventCallback>> event_callbacks_;
   sp<WifiChip> chip_;
 
   DISALLOW_COPY_AND_ASSIGN(Wifi);
diff --git a/wifi/1.0/default/wifi_ap_iface.cpp b/wifi/1.0/default/wifi_ap_iface.cpp
index aded04d..b8b7a3a 100644
--- a/wifi/1.0/default/wifi_ap_iface.cpp
+++ b/wifi/1.0/default/wifi_ap_iface.cpp
@@ -14,20 +14,22 @@
  * limitations under the License.
  */
 
-#include "wifi_ap_iface.h"
-
 #include <android-base/logging.h>
 
-#include "failure_reason_util.h"
+#include "hidl_return_util.h"
+#include "wifi_ap_iface.h"
+#include "wifi_status_util.h"
 
 namespace android {
 namespace hardware {
 namespace wifi {
 namespace V1_0 {
 namespace implementation {
+using hidl_return_util::validateAndCall;
 
-WifiApIface::WifiApIface(const std::string& ifname,
-                         const std::weak_ptr<WifiLegacyHal> legacy_hal)
+WifiApIface::WifiApIface(
+    const std::string& ifname,
+    const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
     : ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) {}
 
 void WifiApIface::invalidate() {
@@ -35,15 +37,30 @@
   is_valid_ = false;
 }
 
-Return<void> WifiApIface::getName(getName_cb cb) {
-  hidl_string hidl_ifname;
-  hidl_ifname.setToExternal(ifname_.c_str(), ifname_.size());
-  cb(hidl_ifname);
-  return Void();
+bool WifiApIface::isValid() {
+  return is_valid_;
 }
 
-Return<IfaceType> WifiApIface::getType() {
-  return IfaceType::AP;
+Return<void> WifiApIface::getName(getName_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiApIface::getNameInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiApIface::getType(getType_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiApIface::getTypeInternal,
+                         hidl_status_cb);
+}
+
+std::pair<WifiStatus, std::string> WifiApIface::getNameInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
+}
+
+std::pair<WifiStatus, IfaceType> WifiApIface::getTypeInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::AP};
 }
 
 }  // namespace implementation
diff --git a/wifi/1.0/default/wifi_ap_iface.h b/wifi/1.0/default/wifi_ap_iface.h
index b95a3d8..ee5dc56 100644
--- a/wifi/1.0/default/wifi_ap_iface.h
+++ b/wifi/1.0/default/wifi_ap_iface.h
@@ -34,17 +34,22 @@
 class WifiApIface : public IWifiApIface {
  public:
   WifiApIface(const std::string& ifname,
-              const std::weak_ptr<WifiLegacyHal> legacy_hal);
+              const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
   // Refer to |WifiChip::invalidate()|.
   void invalidate();
+  bool isValid();
 
   // HIDL methods exposed.
-  Return<void> getName(getName_cb cb) override;
-  Return<IfaceType> getType() override;
+  Return<void> getName(getName_cb hidl_status_cb) override;
+  Return<void> getType(getType_cb hidl_status_cb) override;
 
  private:
+  // Corresponding worker functions for the HIDL methods.
+  std::pair<WifiStatus, std::string> getNameInternal();
+  std::pair<WifiStatus, IfaceType> getTypeInternal();
+
   std::string ifname_;
-  std::weak_ptr<WifiLegacyHal> legacy_hal_;
+  std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
   bool is_valid_;
 
   DISALLOW_COPY_AND_ASSIGN(WifiApIface);
diff --git a/wifi/1.0/default/wifi_chip.cpp b/wifi/1.0/default/wifi_chip.cpp
index 4dd020b..4d1bce5 100644
--- a/wifi/1.0/default/wifi_chip.cpp
+++ b/wifi/1.0/default/wifi_chip.cpp
@@ -14,29 +14,17 @@
  * limitations under the License.
  */
 
-#include "wifi_chip.h"
-
 #include <android-base/logging.h>
 
-#include "failure_reason_util.h"
+#include "hidl_return_util.h"
+#include "wifi_chip.h"
+#include "wifi_status_util.h"
 
 namespace {
 using android::sp;
 using android::hardware::hidl_vec;
 using android::hardware::hidl_string;
 
-hidl_vec<hidl_string> createHidlVecOfIfaceNames(const std::string& ifname) {
-  std::vector<hidl_string> ifnames;
-  if (!ifname.empty()) {
-    hidl_string hidl_ifname;
-    hidl_ifname = ifname.c_str();
-    ifnames.emplace_back(hidl_ifname);
-  }
-  hidl_vec<hidl_string> hidl_ifnames;
-  hidl_ifnames.setToExternal(ifnames.data(), ifnames.size());
-  return hidl_ifnames;
-}
-
 template <typename Iface>
 void invalidateAndClear(sp<Iface>& iface) {
   if (iface.get()) {
@@ -51,330 +39,235 @@
 namespace wifi {
 namespace V1_0 {
 namespace implementation {
+using hidl_return_util::validateAndCall;
 
 WifiChip::WifiChip(ChipId chip_id,
-                   const std::weak_ptr<WifiLegacyHal> legacy_hal)
+                   const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
     : chip_id_(chip_id), legacy_hal_(legacy_hal), is_valid_(true) {}
 
 void WifiChip::invalidate() {
   invalidateAndRemoveAllIfaces();
   legacy_hal_.reset();
-  callbacks_.clear();
+  event_callbacks_.clear();
   is_valid_ = false;
 }
 
-Return<ChipId> WifiChip::getId() {
-  return chip_id_;
+bool WifiChip::isValid() {
+  return is_valid_;
+}
+
+Return<void> WifiChip::getId(getId_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getIdInternal,
+                         hidl_status_cb);
 }
 
 Return<void> WifiChip::registerEventCallback(
-    const sp<IWifiChipEventCallback>& callback) {
-  if (!is_valid_)
-    return Void();
-  // TODO(b/31632518): remove the callback when the client is destroyed
-  callbacks_.emplace_back(callback);
-  return Void();
+    const sp<IWifiChipEventCallback>& event_callback,
+    registerEventCallback_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::registerEventCallbackInternal,
+                         hidl_status_cb,
+                         event_callback);
 }
 
-Return<void> WifiChip::getAvailableModes(getAvailableModes_cb cb) {
-  if (!is_valid_) {
-    cb(hidl_vec<ChipMode>());
-    return Void();
-  } else {
-    // TODO add implementation
-    return Void();
-  }
+Return<void> WifiChip::getCapabilities(getCapabilities_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getCapabilitiesInternal,
+                         hidl_status_cb);
 }
 
-Return<void> WifiChip::configureChip(uint32_t /*mode_id*/) {
-  if (!is_valid_)
-    return Void();
-
-  invalidateAndRemoveAllIfaces();
-  // TODO add implementation
-  return Void();
+Return<void> WifiChip::getAvailableModes(getAvailableModes_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getAvailableModesInternal,
+                         hidl_status_cb);
 }
 
-Return<uint32_t> WifiChip::getMode() {
-  if (!is_valid_)
-    return 0;
-  // TODO add implementation
-  return 0;
+Return<void> WifiChip::configureChip(uint32_t mode_id,
+                                     configureChip_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::configureChipInternal,
+                         hidl_status_cb,
+                         mode_id);
 }
 
-Return<void> WifiChip::requestChipDebugInfo() {
-  if (!is_valid_)
-    return Void();
-
-  IWifiChipEventCallback::ChipDebugInfo result;
-
-  std::pair<wifi_error, std::string> ret =
-      legacy_hal_.lock()->getDriverVersion();
-  if (ret.first != WIFI_SUCCESS) {
-    LOG(ERROR) << "Failed to get driver version: "
-               << LegacyErrorToString(ret.first);
-    FailureReason reason = CreateFailureReasonLegacyError(
-        ret.first, " failed to get driver version");
-    for (const auto& callback : callbacks_) {
-      callback->onChipDebugInfoFailure(reason);
-    }
-    return Void();
-  }
-  result.driverDescription = ret.second.c_str();
-
-  ret = legacy_hal_.lock()->getFirmwareVersion();
-  if (ret.first != WIFI_SUCCESS) {
-    LOG(ERROR) << "Failed to get firmware version: "
-               << LegacyErrorToString(ret.first);
-    FailureReason reason = CreateFailureReasonLegacyError(
-        ret.first, " failed to get firmware version");
-    for (const auto& callback : callbacks_) {
-      callback->onChipDebugInfoFailure(reason);
-    }
-    return Void();
-  }
-  result.firmwareDescription = ret.second.c_str();
-
-  for (const auto& callback : callbacks_) {
-    callback->onChipDebugInfoAvailable(result);
-  }
-  return Void();
+Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getModeInternal,
+                         hidl_status_cb);
 }
 
-Return<void> WifiChip::requestDriverDebugDump() {
-  if (!is_valid_)
-    return Void();
-
-  std::pair<wifi_error, std::vector<char>> ret =
-      legacy_hal_.lock()->requestDriverMemoryDump();
-  if (ret.first != WIFI_SUCCESS) {
-    LOG(ERROR) << "Failed to get driver debug dump: "
-               << LegacyErrorToString(ret.first);
-    FailureReason reason = CreateFailureReasonLegacyError(ret.first, "");
-    for (const auto& callback : callbacks_) {
-      callback->onDriverDebugDumpFailure(reason);
-    }
-    return Void();
-  }
-
-  auto& driver_dump = ret.second;
-  hidl_vec<uint8_t> hidl_data;
-  hidl_data.setToExternal(reinterpret_cast<uint8_t*>(driver_dump.data()),
-                          driver_dump.size());
-  for (const auto& callback : callbacks_) {
-    callback->onDriverDebugDumpAvailable(hidl_data);
-  }
-  return Void();
+Return<void> WifiChip::requestChipDebugInfo(
+    requestChipDebugInfo_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::requestChipDebugInfoInternal,
+                         hidl_status_cb);
 }
 
-Return<void> WifiChip::requestFirmwareDebugDump() {
-  if (!is_valid_)
-    return Void();
-
-  std::pair<wifi_error, std::vector<char>> ret =
-      legacy_hal_.lock()->requestFirmwareMemoryDump();
-  if (ret.first != WIFI_SUCCESS) {
-    LOG(ERROR) << "Failed to get firmware debug dump: "
-               << LegacyErrorToString(ret.first);
-    FailureReason reason = CreateFailureReasonLegacyError(ret.first, "");
-    for (const auto& callback : callbacks_) {
-      callback->onFirmwareDebugDumpFailure(reason);
-    }
-    return Void();
-  }
-
-  auto& firmware_dump = ret.second;
-  hidl_vec<uint8_t> hidl_data;
-  hidl_data.setToExternal(reinterpret_cast<uint8_t*>(firmware_dump.data()),
-                          firmware_dump.size());
-  for (const auto& callback : callbacks_) {
-    callback->onFirmwareDebugDumpAvailable(hidl_data);
-  }
-  return Void();
+Return<void> WifiChip::requestDriverDebugDump(
+    requestDriverDebugDump_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::requestDriverDebugDumpInternal,
+                         hidl_status_cb);
 }
 
-Return<void> WifiChip::createApIface(createApIface_cb cb) {
-  if (!is_valid_) {
-    cb(nullptr);
-    return Void();
-  }
-
-  // TODO(b/31997422): Disallow this based on the chip combination.
-  std::string ifname = legacy_hal_.lock()->getApIfaceName();
-  ap_iface_ = new WifiApIface(ifname, legacy_hal_);
-  cb(ap_iface_);
-  return Void();
+Return<void> WifiChip::requestFirmwareDebugDump(
+    requestFirmwareDebugDump_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::requestFirmwareDebugDumpInternal,
+                         hidl_status_cb);
 }
 
-Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb cb) {
-  if (!is_valid_) {
-    cb(hidl_vec<hidl_string>());
-    return Void();
-  }
-
-  std::string ifname;
-  if (ap_iface_.get()) {
-    ifname = legacy_hal_.lock()->getApIfaceName().c_str();
-  }
-  cb(createHidlVecOfIfaceNames(ifname));
-  return Void();
+Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::createApIfaceInternal,
+                         hidl_status_cb);
 }
 
-Return<void> WifiChip::getApIface(const hidl_string& ifname, getApIface_cb cb) {
-  if (!is_valid_) {
-    cb(nullptr);
-    return Void();
-  }
-
-  if (ap_iface_.get() &&
-      (ifname.c_str() == legacy_hal_.lock()->getApIfaceName())) {
-    cb(ap_iface_);
-  } else {
-    cb(nullptr);
-  }
-  return Void();
+Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getApIfaceNamesInternal,
+                         hidl_status_cb);
 }
 
-Return<void> WifiChip::createNanIface(createNanIface_cb cb) {
-  if (!is_valid_) {
-    cb(nullptr);
-    return Void();
-  }
-
-  // TODO(b/31997422): Disallow this based on the chip combination.
-  std::string ifname = legacy_hal_.lock()->getNanIfaceName();
-  nan_iface_ = new WifiNanIface(ifname, legacy_hal_);
-  cb(nan_iface_);
-  return Void();
+Return<void> WifiChip::getApIface(const hidl_string& ifname,
+                                  getApIface_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getApIfaceInternal,
+                         hidl_status_cb,
+                         ifname);
 }
 
-Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb cb) {
-  if (!is_valid_) {
-    cb(hidl_vec<hidl_string>());
-    return Void();
-  }
+Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::createNanIfaceInternal,
+                         hidl_status_cb);
+}
 
-  std::string ifname;
-  if (nan_iface_.get()) {
-    ifname = legacy_hal_.lock()->getNanIfaceName().c_str();
-  }
-  cb(createHidlVecOfIfaceNames(ifname));
-  return Void();
+Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getNanIfaceNamesInternal,
+                         hidl_status_cb);
 }
 
 Return<void> WifiChip::getNanIface(const hidl_string& ifname,
-                                   getNanIface_cb cb) {
-  if (!is_valid_) {
-    cb(nullptr);
-    return Void();
-  }
-
-  if (nan_iface_.get() &&
-      (ifname.c_str() == legacy_hal_.lock()->getNanIfaceName())) {
-    cb(nan_iface_);
-  } else {
-    cb(nullptr);
-  }
-  return Void();
+                                   getNanIface_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getNanIfaceInternal,
+                         hidl_status_cb,
+                         ifname);
 }
 
-Return<void> WifiChip::createP2pIface(createP2pIface_cb cb) {
-  if (!is_valid_) {
-    cb(nullptr);
-    return Void();
-  }
-
-  // TODO(b/31997422): Disallow this based on the chip combination.
-  std::string ifname = legacy_hal_.lock()->getP2pIfaceName();
-  p2p_iface_ = new WifiP2pIface(ifname, legacy_hal_);
-  cb(p2p_iface_);
-  return Void();
+Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::createP2pIfaceInternal,
+                         hidl_status_cb);
 }
 
-Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb cb) {
-  if (!is_valid_) {
-    cb(hidl_vec<hidl_string>());
-    return Void();
-  }
-
-  std::string ifname;
-  if (p2p_iface_.get()) {
-    ifname = legacy_hal_.lock()->getP2pIfaceName().c_str();
-  }
-  cb(createHidlVecOfIfaceNames(ifname));
-  return Void();
+Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getP2pIfaceNamesInternal,
+                         hidl_status_cb);
 }
 
 Return<void> WifiChip::getP2pIface(const hidl_string& ifname,
-                                   getP2pIface_cb cb) {
-  if (!is_valid_) {
-    cb(nullptr);
-    return Void();
-  }
-
-  if (p2p_iface_.get() &&
-      (ifname.c_str() == legacy_hal_.lock()->getP2pIfaceName())) {
-    cb(p2p_iface_);
-  } else {
-    cb(nullptr);
-  }
-  return Void();
+                                   getP2pIface_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getP2pIfaceInternal,
+                         hidl_status_cb,
+                         ifname);
 }
 
-Return<void> WifiChip::createStaIface(createStaIface_cb cb) {
-  if (!is_valid_) {
-    cb(nullptr);
-    return Void();
-  }
-
-  // TODO(b/31997422): Disallow this based on the chip combination.
-  std::string ifname = legacy_hal_.lock()->getStaIfaceName();
-  sta_iface_ = new WifiStaIface(ifname, legacy_hal_);
-  cb(sta_iface_);
-  return Void();
+Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::createStaIfaceInternal,
+                         hidl_status_cb);
 }
 
-Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb cb) {
-  if (!is_valid_) {
-    cb(hidl_vec<hidl_string>());
-    return Void();
-  }
-
-  std::string ifname;
-  if (sta_iface_.get()) {
-    ifname = legacy_hal_.lock()->getStaIfaceName().c_str();
-  }
-  cb(createHidlVecOfIfaceNames(ifname));
-  return Void();
+Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getStaIfaceNamesInternal,
+                         hidl_status_cb);
 }
 
 Return<void> WifiChip::getStaIface(const hidl_string& ifname,
-                                   getStaIface_cb cb) {
-  if (!is_valid_) {
-    cb(nullptr);
-    return Void();
-  }
-
-  if (sta_iface_.get() &&
-      (ifname.c_str() == legacy_hal_.lock()->getStaIfaceName())) {
-    cb(sta_iface_);
-  } else {
-    cb(nullptr);
-  }
-  return Void();
+                                   getStaIface_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getStaIfaceInternal,
+                         hidl_status_cb,
+                         ifname);
 }
 
-Return<void> WifiChip::createRttController(const sp<IWifiIface>& bound_iface,
-                                           createRttController_cb cb) {
-  if (!is_valid_) {
-    cb(nullptr);
-    return Void();
-  }
+Return<void> WifiChip::createRttController(
+    const sp<IWifiIface>& bound_iface, createRttController_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::createRttControllerInternal,
+                         hidl_status_cb,
+                         bound_iface);
+}
 
-  sp<WifiRttController> rtt = new WifiRttController(bound_iface, legacy_hal_);
-  rtt_controllers_.emplace_back(rtt);
-  cb(rtt);
-  return Void();
+Return<void> WifiChip::getDebugRingBuffersStatus(
+    getDebugRingBuffersStatus_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getDebugRingBuffersStatusInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiChip::startLoggingToDebugRingBuffer(
+    const hidl_string& ring_name,
+    WifiDebugRingBufferVerboseLevel verbose_level,
+    uint32_t max_interval_in_sec,
+    uint32_t min_data_size_in_bytes,
+    startLoggingToDebugRingBuffer_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::startLoggingToDebugRingBufferInternal,
+                         hidl_status_cb,
+                         ring_name,
+                         verbose_level,
+                         max_interval_in_sec,
+                         min_data_size_in_bytes);
+}
+
+Return<void> WifiChip::forceDumpToDebugRingBuffer(
+    const hidl_string& ring_name,
+    forceDumpToDebugRingBuffer_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::forceDumpToDebugRingBufferInternal,
+                         hidl_status_cb,
+                         ring_name);
+}
+
+Return<void> WifiChip::getDebugHostWakeReasonStats(
+    getDebugHostWakeReasonStats_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+                         &WifiChip::getDebugHostWakeReasonStatsInternal,
+                         hidl_status_cb);
 }
 
 void WifiChip::invalidateAndRemoveAllIfaces() {
@@ -390,6 +283,232 @@
   rtt_controllers_.clear();
 }
 
+std::pair<WifiStatus, ChipId> WifiChip::getIdInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), chip_id_};
+}
+
+WifiStatus WifiChip::registerEventCallbackInternal(
+    const sp<IWifiChipEventCallback>& event_callback) {
+  // TODO(b/31632518): remove the callback when the client is destroyed
+  event_callbacks_.emplace_back(event_callback);
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal() {
+  // TODO add implementation
+  return {createWifiStatus(WifiStatusCode::SUCCESS), 0};
+}
+
+std::pair<WifiStatus, std::vector<IWifiChip::ChipMode>>
+WifiChip::getAvailableModesInternal() {
+  // TODO add implementation
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiChip::configureChipInternal(uint32_t /* mode_id */) {
+  invalidateAndRemoveAllIfaces();
+  // TODO add implementation
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, uint32_t> WifiChip::getModeInternal() {
+  // TODO add implementation
+  return {createWifiStatus(WifiStatusCode::SUCCESS), 0};
+}
+
+std::pair<WifiStatus, IWifiChip::ChipDebugInfo>
+WifiChip::requestChipDebugInfoInternal() {
+  IWifiChip::ChipDebugInfo result;
+  wifi_error legacy_status;
+  std::string driver_desc;
+  std::tie(legacy_status, driver_desc) = legacy_hal_.lock()->getDriverVersion();
+  if (legacy_status != WIFI_SUCCESS) {
+    LOG(ERROR) << "Failed to get driver version: "
+               << legacyErrorToString(legacy_status);
+    WifiStatus status = createWifiStatusFromLegacyError(
+        legacy_status, "failed to get driver version");
+    return {status, result};
+  }
+  result.driverDescription = driver_desc.c_str();
+
+  std::string firmware_desc;
+  std::tie(legacy_status, firmware_desc) =
+      legacy_hal_.lock()->getFirmwareVersion();
+  if (legacy_status != WIFI_SUCCESS) {
+    LOG(ERROR) << "Failed to get firmware version: "
+               << legacyErrorToString(legacy_status);
+    WifiStatus status = createWifiStatusFromLegacyError(
+        legacy_status, "failed to get firmware version");
+    return {status, result};
+  }
+  result.firmwareDescription = firmware_desc.c_str();
+
+  return {createWifiStatus(WifiStatusCode::SUCCESS), result};
+}
+
+std::pair<WifiStatus, std::vector<uint8_t>>
+WifiChip::requestDriverDebugDumpInternal() {
+  wifi_error legacy_status;
+  std::vector<uint8_t> driver_dump;
+  std::tie(legacy_status, driver_dump) =
+      legacy_hal_.lock()->requestDriverMemoryDump();
+  if (legacy_status != WIFI_SUCCESS) {
+    LOG(ERROR) << "Failed to get driver debug dump: "
+               << legacyErrorToString(legacy_status);
+    return {createWifiStatusFromLegacyError(legacy_status),
+            std::vector<uint8_t>()};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS), driver_dump};
+}
+
+std::pair<WifiStatus, std::vector<uint8_t>>
+WifiChip::requestFirmwareDebugDumpInternal() {
+  wifi_error legacy_status;
+  std::vector<uint8_t> firmware_dump;
+  std::tie(legacy_status, firmware_dump) =
+      legacy_hal_.lock()->requestFirmwareMemoryDump();
+  if (legacy_status != WIFI_SUCCESS) {
+    LOG(ERROR) << "Failed to get firmware debug dump: "
+               << legacyErrorToString(legacy_status);
+    return {createWifiStatusFromLegacyError(legacy_status), {}};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS), firmware_dump};
+}
+
+std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::createApIfaceInternal() {
+  // TODO(b/31997422): Disallow this based on the chip combination.
+  std::string ifname = legacy_hal_.lock()->getApIfaceName();
+  ap_iface_ = new WifiApIface(ifname, legacy_hal_);
+  return {createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_};
+}
+
+std::pair<WifiStatus, std::vector<hidl_string>>
+WifiChip::getApIfaceNamesInternal() {
+  if (!ap_iface_.get()) {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS),
+          {legacy_hal_.lock()->getApIfaceName()}};
+}
+
+std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::getApIfaceInternal(
+    const hidl_string& ifname) {
+  if (!ap_iface_.get() ||
+      (ifname.c_str() != legacy_hal_.lock()->getApIfaceName())) {
+    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_};
+}
+
+std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::createNanIfaceInternal() {
+  // TODO(b/31997422): Disallow this based on the chip combination.
+  std::string ifname = legacy_hal_.lock()->getNanIfaceName();
+  nan_iface_ = new WifiNanIface(ifname, legacy_hal_);
+  return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};
+}
+
+std::pair<WifiStatus, std::vector<hidl_string>>
+WifiChip::getNanIfaceNamesInternal() {
+  if (!nan_iface_.get()) {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS),
+          {legacy_hal_.lock()->getNanIfaceName()}};
+}
+
+std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::getNanIfaceInternal(
+    const hidl_string& ifname) {
+  if (!nan_iface_.get() ||
+      (ifname.c_str() != legacy_hal_.lock()->getNanIfaceName())) {
+    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};
+}
+
+std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::createP2pIfaceInternal() {
+  // TODO(b/31997422): Disallow this based on the chip combination.
+  std::string ifname = legacy_hal_.lock()->getP2pIfaceName();
+  p2p_iface_ = new WifiP2pIface(ifname, legacy_hal_);
+  return {createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_};
+}
+
+std::pair<WifiStatus, std::vector<hidl_string>>
+WifiChip::getP2pIfaceNamesInternal() {
+  if (!p2p_iface_.get()) {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS),
+          {legacy_hal_.lock()->getP2pIfaceName()}};
+}
+
+std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::getP2pIfaceInternal(
+    const hidl_string& ifname) {
+  if (!p2p_iface_.get() ||
+      (ifname.c_str() != legacy_hal_.lock()->getP2pIfaceName())) {
+    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_};
+}
+
+std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::createStaIfaceInternal() {
+  // TODO(b/31997422): Disallow this based on the chip combination.
+  std::string ifname = legacy_hal_.lock()->getStaIfaceName();
+  sta_iface_ = new WifiStaIface(ifname, legacy_hal_);
+  return {createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_};
+}
+
+std::pair<WifiStatus, std::vector<hidl_string>>
+WifiChip::getStaIfaceNamesInternal() {
+  if (!sta_iface_.get()) {
+    return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS),
+          {legacy_hal_.lock()->getStaIfaceName()}};
+}
+
+std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::getStaIfaceInternal(
+    const hidl_string& ifname) {
+  if (!sta_iface_.get() ||
+      (ifname.c_str() != legacy_hal_.lock()->getStaIfaceName())) {
+    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
+  }
+  return {createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_};
+}
+
+std::pair<WifiStatus, sp<IWifiRttController>>
+WifiChip::createRttControllerInternal(const sp<IWifiIface>& bound_iface) {
+  sp<WifiRttController> rtt = new WifiRttController(bound_iface, legacy_hal_);
+  rtt_controllers_.emplace_back(rtt);
+  return {createWifiStatus(WifiStatusCode::SUCCESS), rtt};
+}
+
+std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
+WifiChip::getDebugRingBuffersStatusInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiChip::startLoggingToDebugRingBufferInternal(
+    const hidl_string& /* ring_name */,
+    WifiDebugRingBufferVerboseLevel /* verbose_level */,
+    uint32_t /* max_interval_in_sec */,
+    uint32_t /* min_data_size_in_bytes */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiChip::forceDumpToDebugRingBufferInternal(
+    const hidl_string& /* ring_name */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
+WifiChip::getDebugHostWakeReasonStatsInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace wifi
diff --git a/wifi/1.0/default/wifi_chip.h b/wifi/1.0/default/wifi_chip.h
index 94ffa63..c1a7173 100644
--- a/wifi/1.0/default/wifi_chip.h
+++ b/wifi/1.0/default/wifi_chip.h
@@ -42,7 +42,8 @@
  */
 class WifiChip : public IWifiChip {
  public:
-  WifiChip(ChipId chip_id, const std::weak_ptr<WifiLegacyHal> legacy_hal);
+  WifiChip(ChipId chip_id,
+           const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
   // HIDL does not provide a built-in mechanism to let the server invalidate
   // a HIDL interface object after creation. If any client process holds onto
   // a reference to the object in their context, any method calls on that
@@ -57,41 +58,105 @@
   // All HIDL method implementations should check if the object is still marked
   // valid before processing them.
   void invalidate();
+  bool isValid();
 
   // HIDL methods exposed.
-  Return<ChipId> getId() override;
+  Return<void> getId(getId_cb hidl_status_cb) override;
   Return<void> registerEventCallback(
-      const sp<IWifiChipEventCallback>& callback) override;
-  Return<void> getAvailableModes(getAvailableModes_cb cb) override;
-  Return<void> configureChip(uint32_t mode_id) override;
-  Return<uint32_t> getMode() override;
-  Return<void> requestChipDebugInfo() override;
-  Return<void> requestDriverDebugDump() override;
-  Return<void> requestFirmwareDebugDump() override;
-  Return<void> createApIface(createApIface_cb cb) override;
-  Return<void> getApIfaceNames(getApIfaceNames_cb cb) override;
-  Return<void> getApIface(const hidl_string& ifname, getApIface_cb cb) override;
-  Return<void> createNanIface(createNanIface_cb cb) override;
-  Return<void> getNanIfaceNames(getNanIfaceNames_cb cb) override;
+      const sp<IWifiChipEventCallback>& event_callback,
+      registerEventCallback_cb hidl_status_cb) override;
+  Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
+  Return<void> getAvailableModes(getAvailableModes_cb hidl_status_cb) override;
+  Return<void> configureChip(uint32_t mode_id,
+                             configureChip_cb hidl_status_cb) override;
+  Return<void> getMode(getMode_cb hidl_status_cb) override;
+  Return<void> requestChipDebugInfo(
+      requestChipDebugInfo_cb hidl_status_cb) override;
+  Return<void> requestDriverDebugDump(
+      requestDriverDebugDump_cb hidl_status_cb) override;
+  Return<void> requestFirmwareDebugDump(
+      requestFirmwareDebugDump_cb hidl_status_cb) override;
+  Return<void> createApIface(createApIface_cb hidl_status_cb) override;
+  Return<void> getApIfaceNames(getApIfaceNames_cb hidl_status_cb) override;
+  Return<void> getApIface(const hidl_string& ifname,
+                          getApIface_cb hidl_status_cb) override;
+  Return<void> createNanIface(createNanIface_cb hidl_status_cb) override;
+  Return<void> getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) override;
   Return<void> getNanIface(const hidl_string& ifname,
-                           getNanIface_cb cb) override;
-  Return<void> createP2pIface(createP2pIface_cb cb) override;
-  Return<void> getP2pIfaceNames(getP2pIfaceNames_cb cb) override;
+                           getNanIface_cb hidl_status_cb) override;
+  Return<void> createP2pIface(createP2pIface_cb hidl_status_cb) override;
+  Return<void> getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) override;
   Return<void> getP2pIface(const hidl_string& ifname,
-                           getP2pIface_cb cb) override;
-  Return<void> createStaIface(createStaIface_cb cb) override;
-  Return<void> getStaIfaceNames(getStaIfaceNames_cb cb) override;
+                           getP2pIface_cb hidl_status_cb) override;
+  Return<void> createStaIface(createStaIface_cb hidl_status_cb) override;
+  Return<void> getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) override;
   Return<void> getStaIface(const hidl_string& ifname,
-                           getStaIface_cb cb) override;
-  Return<void> createRttController(const sp<IWifiIface>& bound_iface,
-                                   createRttController_cb cb) override;
+                           getStaIface_cb hidl_status_cb) override;
+  Return<void> createRttController(
+      const sp<IWifiIface>& bound_iface,
+      createRttController_cb hidl_status_cb) override;
+  Return<void> getDebugRingBuffersStatus(
+      getDebugRingBuffersStatus_cb hidl_status_cb) override;
+  Return<void> startLoggingToDebugRingBuffer(
+      const hidl_string& ring_name,
+      WifiDebugRingBufferVerboseLevel verbose_level,
+      uint32_t max_interval_in_sec,
+      uint32_t min_data_size_in_bytes,
+      startLoggingToDebugRingBuffer_cb hidl_status_cb) override;
+  Return<void> forceDumpToDebugRingBuffer(
+      const hidl_string& ring_name,
+      forceDumpToDebugRingBuffer_cb hidl_status_cb) override;
+  Return<void> getDebugHostWakeReasonStats(
+      getDebugHostWakeReasonStats_cb hidl_status_cb) override;
 
  private:
   void invalidateAndRemoveAllIfaces();
 
+  // Corresponding worker functions for the HIDL methods.
+  std::pair<WifiStatus, ChipId> getIdInternal();
+  WifiStatus registerEventCallbackInternal(
+      const sp<IWifiChipEventCallback>& event_callback);
+  std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
+  std::pair<WifiStatus, std::vector<ChipMode>> getAvailableModesInternal();
+  WifiStatus configureChipInternal(uint32_t mode_id);
+  std::pair<WifiStatus, uint32_t> getModeInternal();
+  std::pair<WifiStatus, IWifiChip::ChipDebugInfo>
+  requestChipDebugInfoInternal();
+  std::pair<WifiStatus, std::vector<uint8_t>> requestDriverDebugDumpInternal();
+  std::pair<WifiStatus, std::vector<uint8_t>>
+  requestFirmwareDebugDumpInternal();
+  std::pair<WifiStatus, sp<IWifiApIface>> createApIfaceInternal();
+  std::pair<WifiStatus, std::vector<hidl_string>> getApIfaceNamesInternal();
+  std::pair<WifiStatus, sp<IWifiApIface>> getApIfaceInternal(
+      const hidl_string& ifname);
+  std::pair<WifiStatus, sp<IWifiNanIface>> createNanIfaceInternal();
+  std::pair<WifiStatus, std::vector<hidl_string>> getNanIfaceNamesInternal();
+  std::pair<WifiStatus, sp<IWifiNanIface>> getNanIfaceInternal(
+      const hidl_string& ifname);
+  std::pair<WifiStatus, sp<IWifiP2pIface>> createP2pIfaceInternal();
+  std::pair<WifiStatus, std::vector<hidl_string>> getP2pIfaceNamesInternal();
+  std::pair<WifiStatus, sp<IWifiP2pIface>> getP2pIfaceInternal(
+      const hidl_string& ifname);
+  std::pair<WifiStatus, sp<IWifiStaIface>> createStaIfaceInternal();
+  std::pair<WifiStatus, std::vector<hidl_string>> getStaIfaceNamesInternal();
+  std::pair<WifiStatus, sp<IWifiStaIface>> getStaIfaceInternal(
+      const hidl_string& ifname);
+  std::pair<WifiStatus, sp<IWifiRttController>> createRttControllerInternal(
+      const sp<IWifiIface>& bound_iface);
+  std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
+  getDebugRingBuffersStatusInternal();
+  WifiStatus startLoggingToDebugRingBufferInternal(
+      const hidl_string& ring_name,
+      WifiDebugRingBufferVerboseLevel verbose_level,
+      uint32_t max_interval_in_sec,
+      uint32_t min_data_size_in_bytes);
+  WifiStatus forceDumpToDebugRingBufferInternal(const hidl_string& ring_name);
+  std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
+  getDebugHostWakeReasonStatsInternal();
+
   ChipId chip_id_;
-  std::weak_ptr<WifiLegacyHal> legacy_hal_;
-  std::vector<sp<IWifiChipEventCallback>> callbacks_;
+  std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
+  std::vector<sp<IWifiChipEventCallback>> event_callbacks_;
   sp<WifiApIface> ap_iface_;
   sp<WifiNanIface> nan_iface_;
   sp<WifiP2pIface> p2p_iface_;
diff --git a/wifi/1.0/default/wifi_legacy_hal.cpp b/wifi/1.0/default/wifi_legacy_hal.cpp
index 553a058..28b7f9a 100644
--- a/wifi/1.0/default/wifi_legacy_hal.cpp
+++ b/wifi/1.0/default/wifi_legacy_hal.cpp
@@ -16,15 +16,21 @@
 
 #include <array>
 
-#include "failure_reason_util.h"
-#include "wifi_legacy_hal.h"
-
 #include <android-base/logging.h>
 #include <cutils/properties.h>
-#include <wifi_system/hal_tool.h>
 #include <wifi_system/interface_tool.h>
 
-namespace {
+#include "wifi_legacy_hal.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_0 {
+namespace implementation {
+namespace legacy_hal {
+// Constants used in the class.
+static constexpr uint32_t kMaxVersionStringLength = 256;
+
 // Legacy HAL functions accept "C" style function pointers, so use global
 // functions to pass to the legacy HAL function and store the corresponding
 // std::function methods to be invoked.
@@ -51,15 +57,7 @@
     on_firmware_memory_dump_internal_callback(buffer, buffer_size);
   }
 }
-}
-
-namespace android {
-namespace hardware {
-namespace wifi {
-namespace V1_0 {
-namespace implementation {
-
-const uint32_t WifiLegacyHal::kMaxVersionStringLength = 256;
+// End of the free-standing "C" style callbacks.
 
 WifiLegacyHal::WifiLegacyHal()
     : global_handle_(nullptr),
@@ -71,9 +69,11 @@
   CHECK(!global_handle_ && !wlan_interface_handle_ &&
         !awaiting_event_loop_termination_);
 
-  android::wifi_system::HalTool hal_tool;
   android::wifi_system::InterfaceTool if_tool;
-  if (!hal_tool.InitFunctionTable(&global_func_table_)) {
+  // TODO: Add back the HAL Tool if we need to. All we need from the HAL tool
+  // for now is this function call which we can directly call.
+  wifi_error status = init_wifi_vendor_hal_func_table(&global_func_table_);
+  if (status != WIFI_SUCCESS) {
     LOG(ERROR) << "Failed to initialize legacy hal function table";
     return WIFI_ERROR_UNKNOWN;
   }
@@ -83,7 +83,7 @@
   }
 
   LOG(INFO) << "Starting legacy HAL";
-  wifi_error status = global_func_table_.wifi_initialize(&global_handle_);
+  status = global_func_table_.wifi_initialize(&global_handle_);
   if (status != WIFI_SUCCESS || !global_handle_) {
     LOG(ERROR) << "Failed to retrieve global handle";
     return status;
@@ -104,9 +104,9 @@
   on_stop_complete_internal_callback = [&](wifi_handle handle) {
     CHECK_EQ(global_handle_, handle) << "Handle mismatch";
     on_stop_complete_user_callback();
-    global_handle_ = nullptr;
-    wlan_interface_handle_ = nullptr;
-    on_stop_complete_internal_callback = nullptr;
+    // Invalidate all the internal pointers now that the HAL is
+    // stopped.
+    invalidate();
   };
   awaiting_event_loop_termination_ = true;
   global_func_table_.wifi_cleanup(global_handle_, onStopComplete);
@@ -143,7 +143,7 @@
   buffer.fill(0);
   wifi_error status = global_func_table_.wifi_get_driver_version(
       wlan_interface_handle_, buffer.data(), buffer.size());
-  return std::make_pair(status, buffer.data());
+  return {status, buffer.data()};
 }
 
 std::pair<wifi_error, std::string> WifiLegacyHal::getFirmwareVersion() {
@@ -151,33 +151,59 @@
   buffer.fill(0);
   wifi_error status = global_func_table_.wifi_get_firmware_version(
       wlan_interface_handle_, buffer.data(), buffer.size());
-  return std::make_pair(status, buffer.data());
+  return {status, buffer.data()};
 }
 
-std::pair<wifi_error, std::vector<char>>
+std::pair<wifi_error, std::vector<uint8_t>>
 WifiLegacyHal::requestDriverMemoryDump() {
-  std::vector<char> driver_dump;
+  std::vector<uint8_t> driver_dump;
   on_driver_memory_dump_internal_callback = [&driver_dump](char* buffer,
                                                            int buffer_size) {
-    driver_dump.insert(driver_dump.end(), buffer, buffer + buffer_size);
+    driver_dump.insert(driver_dump.end(),
+                       reinterpret_cast<uint8_t*>(buffer),
+                       reinterpret_cast<uint8_t*>(buffer) + buffer_size);
   };
   wifi_error status = global_func_table_.wifi_get_driver_memory_dump(
       wlan_interface_handle_, {onDriverMemoryDump});
   on_driver_memory_dump_internal_callback = nullptr;
-  return std::make_pair(status, std::move(driver_dump));
+  return {status, std::move(driver_dump)};
 }
 
-std::pair<wifi_error, std::vector<char>>
+std::pair<wifi_error, std::vector<uint8_t>>
 WifiLegacyHal::requestFirmwareMemoryDump() {
-  std::vector<char> firmware_dump;
+  std::vector<uint8_t> firmware_dump;
   on_firmware_memory_dump_internal_callback = [&firmware_dump](
       char* buffer, int buffer_size) {
-    firmware_dump.insert(firmware_dump.end(), buffer, buffer + buffer_size);
+    firmware_dump.insert(firmware_dump.end(),
+                         reinterpret_cast<uint8_t*>(buffer),
+                         reinterpret_cast<uint8_t*>(buffer) + buffer_size);
   };
   wifi_error status = global_func_table_.wifi_get_firmware_memory_dump(
       wlan_interface_handle_, {onFirmwareMemoryDump});
   on_firmware_memory_dump_internal_callback = nullptr;
-  return std::make_pair(status, std::move(firmware_dump));
+  return {status, std::move(firmware_dump)};
+}
+
+std::pair<wifi_error, uint32_t> WifiLegacyHal::getSupportedFeatureSet() {
+  feature_set set;
+  static_assert(sizeof(set) == sizeof(uint32_t),
+                "Some features can not be represented in output");
+  wifi_error status = global_func_table_.wifi_get_supported_feature_set(
+      wlan_interface_handle_, &set);
+  return {status, static_cast<uint32_t>(set)};
+}
+
+std::pair<wifi_error, PacketFilterCapabilities>
+WifiLegacyHal::getPacketFilterCapabilities() {
+  PacketFilterCapabilities caps;
+  wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
+      wlan_interface_handle_, &caps.version, &caps.max_len);
+  return {status, caps};
+}
+
+wifi_error WifiLegacyHal::setPacketFilter(const std::vector<uint8_t>& program) {
+  return global_func_table_.wifi_set_packet_filter(
+      wlan_interface_handle_, program.data(), program.size());
 }
 
 wifi_error WifiLegacyHal::retrieveWlanInterfaceHandle() {
@@ -187,8 +213,7 @@
   wifi_error status = global_func_table_.wifi_get_ifaces(
       global_handle_, &num_iface_handles, &iface_handles);
   if (status != WIFI_SUCCESS) {
-    LOG(ERROR) << "Failed to enumerate interface handles: "
-               << LegacyErrorToString(status);
+    LOG(ERROR) << "Failed to enumerate interface handles";
     return status;
   }
   for (int i = 0; i < num_iface_handles; ++i) {
@@ -197,8 +222,7 @@
     status = global_func_table_.wifi_get_iface_name(
         iface_handles[i], current_ifname.data(), current_ifname.size());
     if (status != WIFI_SUCCESS) {
-      LOG(WARNING) << "Failed to get interface handle name: "
-                   << LegacyErrorToString(status);
+      LOG(WARNING) << "Failed to get interface handle name";
       continue;
     }
     if (ifname_to_find == current_ifname.data()) {
@@ -221,6 +245,15 @@
   if_tool.SetWifiUpState(false);
 }
 
+void WifiLegacyHal::invalidate() {
+  global_handle_ = nullptr;
+  wlan_interface_handle_ = nullptr;
+  on_stop_complete_internal_callback = nullptr;
+  on_driver_memory_dump_internal_callback = nullptr;
+  on_firmware_memory_dump_internal_callback = nullptr;
+}
+
+}  // namespace legacy_hal
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace wifi
diff --git a/wifi/1.0/default/wifi_legacy_hal.h b/wifi/1.0/default/wifi_legacy_hal.h
index 3585975..8bd146a 100644
--- a/wifi/1.0/default/wifi_legacy_hal.h
+++ b/wifi/1.0/default/wifi_legacy_hal.h
@@ -19,14 +19,25 @@
 
 #include <functional>
 #include <thread>
-
-#include <hardware_legacy/wifi_hal.h>
+#include <vector>
 
 namespace android {
 namespace hardware {
 namespace wifi {
 namespace V1_0 {
 namespace implementation {
+// This is in a separate namespace to prevent typename conflicts between
+// the legacy HAL types and the HIDL interface types.
+namespace legacy_hal {
+// Wrap all the types defined inside the legacy HAL header files inside this
+// namespace.
+#include <hardware_legacy/wifi_hal.h>
+
+// APF capabilities supported by the iface.
+struct PacketFilterCapabilities {
+  uint32_t version;
+  uint32_t max_len;
+};
 
 /**
  * Class that encapsulates all legacy HAL interactions.
@@ -48,16 +59,19 @@
   // Wrappers for all the functions in the legacy HAL function table.
   std::pair<wifi_error, std::string> getDriverVersion();
   std::pair<wifi_error, std::string> getFirmwareVersion();
-  std::pair<wifi_error, std::vector<char>> requestDriverMemoryDump();
-  std::pair<wifi_error, std::vector<char>> requestFirmwareMemoryDump();
+  std::pair<wifi_error, std::vector<uint8_t>> requestDriverMemoryDump();
+  std::pair<wifi_error, std::vector<uint8_t>> requestFirmwareMemoryDump();
+  std::pair<wifi_error, uint32_t> getSupportedFeatureSet();
+  // APF functions.
+  std::pair<wifi_error, PacketFilterCapabilities> getPacketFilterCapabilities();
+  wifi_error setPacketFilter(const std::vector<uint8_t>& program);
 
  private:
-  static const uint32_t kMaxVersionStringLength;
-
   // Retrieve the interface handle to be used for the "wlan" interface.
   wifi_error retrieveWlanInterfaceHandle();
   // Run the legacy HAL event loop thread.
   void runEventLoop();
+  void invalidate();
 
   // Event loop thread used by legacy HAL.
   std::thread event_loop_thread_;
@@ -71,6 +85,7 @@
   bool awaiting_event_loop_termination_;
 };
 
+}  // namespace legacy_hal
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace wifi
diff --git a/wifi/1.0/default/wifi_nan_iface.cpp b/wifi/1.0/default/wifi_nan_iface.cpp
index 3c7ae4b..48e75a5 100644
--- a/wifi/1.0/default/wifi_nan_iface.cpp
+++ b/wifi/1.0/default/wifi_nan_iface.cpp
@@ -14,38 +14,330 @@
  * limitations under the License.
  */
 
-#include "wifi_nan_iface.h"
-
 #include <android-base/logging.h>
 
-#include "failure_reason_util.h"
+#include "hidl_return_util.h"
+#include "wifi_nan_iface.h"
+#include "wifi_status_util.h"
 
 namespace android {
 namespace hardware {
 namespace wifi {
 namespace V1_0 {
 namespace implementation {
+using hidl_return_util::validateAndCall;
 
-WifiNanIface::WifiNanIface(const std::string& ifname,
-                           const std::weak_ptr<WifiLegacyHal> legacy_hal)
+WifiNanIface::WifiNanIface(
+    const std::string& ifname,
+    const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
     : ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) {}
 
 void WifiNanIface::invalidate() {
   legacy_hal_.reset();
+  event_callbacks_.clear();
   is_valid_ = false;
 }
 
-Return<void> WifiNanIface::getName(getName_cb cb) {
-  hidl_string hidl_ifname;
-  hidl_ifname.setToExternal(ifname_.c_str(), ifname_.size());
-  cb(hidl_ifname);
-  return Void();
+bool WifiNanIface::isValid() {
+  return is_valid_;
 }
 
-Return<IfaceType> WifiNanIface::getType() {
-  return IfaceType::NAN;
+Return<void> WifiNanIface::getName(getName_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::getNameInternal,
+                         hidl_status_cb);
 }
 
+Return<void> WifiNanIface::registerEventCallback(
+    const sp<IWifiNanIfaceEventCallback>& callback,
+    registerEventCallback_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::registerEventCallbackInternal,
+                         hidl_status_cb,
+                         callback);
+}
+
+Return<void> WifiNanIface::enableRequest(uint32_t cmd_id,
+                                         const NanEnableRequest& msg,
+                                         enableRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::enableRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::disableRequest(uint32_t cmd_id,
+                                          disableRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::disableRequestInternal,
+                         hidl_status_cb,
+                         cmd_id);
+}
+
+Return<void> WifiNanIface::publishRequest(uint32_t cmd_id,
+                                          const NanPublishRequest& msg,
+                                          publishRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::publishRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::publishCancelRequest(
+    uint32_t cmd_id,
+    const NanPublishCancelRequest& msg,
+    publishCancelRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::publishCancelRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::subscribeRequest(
+    uint32_t cmd_id,
+    const NanSubscribeRequest& msg,
+    subscribeRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::subscribeRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::subscribeCancelRequest(
+    uint32_t cmd_id,
+    const NanSubscribeCancelRequest& msg,
+    subscribeCancelRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::subscribeCancelRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::transmitFollowupRequest(
+    uint32_t cmd_id,
+    const NanTransmitFollowupRequest& msg,
+    transmitFollowupRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::transmitFollowupRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::configRequest(uint32_t cmd_id,
+                                         const NanConfigRequest& msg,
+                                         configRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::configRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::beaconSdfPayloadRequest(
+    uint32_t cmd_id,
+    const NanBeaconSdfPayloadRequest& msg,
+    beaconSdfPayloadRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::beaconSdfPayloadRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::getVersion(getVersion_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::getVersionInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiNanIface::getCapabilities(uint32_t cmd_id,
+                                           getCapabilities_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::getCapabilitiesInternal,
+                         hidl_status_cb,
+                         cmd_id);
+}
+
+Return<void> WifiNanIface::dataInterfaceCreate(
+    uint32_t cmd_id,
+    const hidl_string& iface_name,
+    dataInterfaceCreate_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::dataInterfaceCreateInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         iface_name);
+}
+
+Return<void> WifiNanIface::dataInterfaceDelete(
+    uint32_t cmd_id,
+    const hidl_string& iface_name,
+    dataInterfaceDelete_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::dataInterfaceDeleteInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         iface_name);
+}
+
+Return<void> WifiNanIface::dataRequestInitiator(
+    uint32_t cmd_id,
+    const NanDataPathInitiatorRequest& msg,
+    dataRequestInitiator_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::dataRequestInitiatorInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::dataIndicationResponse(
+    uint32_t cmd_id,
+    const NanDataPathIndicationResponse& msg,
+    dataIndicationResponse_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::dataIndicationResponseInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::dataEnd(uint32_t cmd_id,
+                                   const NanDataPathEndRequest& msg,
+                                   dataEnd_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::dataEndInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         msg);
+}
+
+Return<void> WifiNanIface::getType(getType_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiNanIface::getTypeInternal,
+                         hidl_status_cb);
+}
+
+std::pair<WifiStatus, std::string> WifiNanIface::getNameInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
+}
+
+std::pair<WifiStatus, IfaceType> WifiNanIface::getTypeInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::NAN};
+}
+
+WifiStatus WifiNanIface::registerEventCallbackInternal(
+    const sp<IWifiNanIfaceEventCallback>& callback) {
+  // TODO(b/31632518): remove the callback when the client is destroyed
+  event_callbacks_.emplace_back(callback);
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiNanIface::enableRequestInternal(
+    uint32_t /* cmd_id */, const NanEnableRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiNanIface::disableRequestInternal(uint32_t /* cmd_id */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiNanIface::publishRequestInternal(
+    uint32_t /* cmd_id */, const NanPublishRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiNanIface::publishCancelRequestInternal(
+    uint32_t /* cmd_id */, const NanPublishCancelRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::subscribeRequestInternal(
+    uint32_t /* cmd_id */, const NanSubscribeRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::subscribeCancelRequestInternal(
+    uint32_t /* cmd_id */, const NanSubscribeCancelRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::transmitFollowupRequestInternal(
+    uint32_t /* cmd_id */, const NanTransmitFollowupRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::configRequestInternal(
+    uint32_t /* cmd_id */, const NanConfigRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::beaconSdfPayloadRequestInternal(
+    uint32_t /* cmd_id */, const NanBeaconSdfPayloadRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+std::pair<WifiStatus, NanVersion> WifiNanIface::getVersionInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), 0};
+}
+WifiStatus WifiNanIface::getCapabilitiesInternal(uint32_t /* cmd_id */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::dataInterfaceCreateInternal(
+    uint32_t /* cmd_id */, const std::string& /* iface_name */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::dataInterfaceDeleteInternal(
+    uint32_t /* cmd_id */, const std::string& /* iface_name */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::dataRequestInitiatorInternal(
+    uint32_t /* cmd_id */, const NanDataPathInitiatorRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::dataIndicationResponseInternal(
+    uint32_t /* cmd_id */, const NanDataPathIndicationResponse& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+WifiStatus WifiNanIface::dataEndInternal(
+    uint32_t /* cmd_id */, const NanDataPathEndRequest& /* msg */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace wifi
diff --git a/wifi/1.0/default/wifi_nan_iface.h b/wifi/1.0/default/wifi_nan_iface.h
index 93e2e77..4f89b31 100644
--- a/wifi/1.0/default/wifi_nan_iface.h
+++ b/wifi/1.0/default/wifi_nan_iface.h
@@ -19,6 +19,7 @@
 
 #include <android-base/macros.h>
 #include <android/hardware/wifi/1.0/IWifiNanIface.h>
+#include <android/hardware/wifi/1.0/IWifiNanIfaceEventCallback.h>
 
 #include "wifi_legacy_hal.h"
 
@@ -34,17 +35,108 @@
 class WifiNanIface : public IWifiNanIface {
  public:
   WifiNanIface(const std::string& ifname,
-               const std::weak_ptr<WifiLegacyHal> legacy_hal);
+               const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
   // Refer to |WifiChip::invalidate()|.
   void invalidate();
+  bool isValid();
 
   // HIDL methods exposed.
-  Return<void> getName(getName_cb cb) override;
-  Return<IfaceType> getType() override;
+  Return<void> getName(getName_cb hidl_status_cb) override;
+  Return<void> getType(getType_cb hidl_status_cb) override;
+  Return<void> registerEventCallback(
+      const sp<IWifiNanIfaceEventCallback>& callback,
+      registerEventCallback_cb hidl_status_cb) override;
+  Return<void> enableRequest(uint32_t cmd_id,
+                             const NanEnableRequest& msg,
+                             enableRequest_cb hidl_status_cb) override;
+  Return<void> disableRequest(uint32_t cmd_id,
+                              disableRequest_cb hidl_status_cb) override;
+  Return<void> publishRequest(uint32_t cmd_id,
+                              const NanPublishRequest& msg,
+                              publishRequest_cb hidl_status_cb) override;
+  Return<void> publishCancelRequest(
+      uint32_t cmd_id,
+      const NanPublishCancelRequest& msg,
+      publishCancelRequest_cb hidl_status_cb) override;
+  Return<void> subscribeRequest(uint32_t cmd_id,
+                                const NanSubscribeRequest& msg,
+                                subscribeRequest_cb hidl_status_cb) override;
+  Return<void> subscribeCancelRequest(
+      uint32_t cmd_id,
+      const NanSubscribeCancelRequest& msg,
+      subscribeCancelRequest_cb hidl_status_cb) override;
+  Return<void> transmitFollowupRequest(
+      uint32_t cmd_id,
+      const NanTransmitFollowupRequest& msg,
+      transmitFollowupRequest_cb hidl_status_cb) override;
+  Return<void> configRequest(uint32_t cmd_id,
+                             const NanConfigRequest& msg,
+                             configRequest_cb hidl_status_cb) override;
+  Return<void> beaconSdfPayloadRequest(
+      uint32_t cmd_id,
+      const NanBeaconSdfPayloadRequest& msg,
+      beaconSdfPayloadRequest_cb hidl_status_cb) override;
+  Return<void> getVersion(getVersion_cb hidl_status_cb) override;
+  Return<void> getCapabilities(uint32_t cmd_id,
+                               getCapabilities_cb hidl_status_cb) override;
+  Return<void> dataInterfaceCreate(
+      uint32_t cmd_id,
+      const hidl_string& iface_name,
+      dataInterfaceCreate_cb hidl_status_cb) override;
+  Return<void> dataInterfaceDelete(
+      uint32_t cmd_id,
+      const hidl_string& iface_name,
+      dataInterfaceDelete_cb hidl_status_cb) override;
+  Return<void> dataRequestInitiator(
+      uint32_t cmd_id,
+      const NanDataPathInitiatorRequest& msg,
+      dataRequestInitiator_cb hidl_status_cb) override;
+  Return<void> dataIndicationResponse(
+      uint32_t cmd_id,
+      const NanDataPathIndicationResponse& msg,
+      dataIndicationResponse_cb hidl_status_cb) override;
+  Return<void> dataEnd(uint32_t cmd_id,
+                       const NanDataPathEndRequest& msg,
+                       dataEnd_cb hidl_status_cb) override;
 
  private:
+  // Corresponding worker functions for the HIDL methods.
+  std::pair<WifiStatus, std::string> getNameInternal();
+  std::pair<WifiStatus, IfaceType> getTypeInternal();
+  WifiStatus registerEventCallbackInternal(
+      const sp<IWifiNanIfaceEventCallback>& callback);
+  WifiStatus enableRequestInternal(uint32_t cmd_id,
+                                   const NanEnableRequest& msg);
+  WifiStatus disableRequestInternal(uint32_t cmd_id);
+  WifiStatus publishRequestInternal(uint32_t cmd_id,
+                                    const NanPublishRequest& msg);
+  WifiStatus publishCancelRequestInternal(uint32_t cmd_id,
+                                          const NanPublishCancelRequest& msg);
+  WifiStatus subscribeRequestInternal(uint32_t cmd_id,
+                                      const NanSubscribeRequest& msg);
+  WifiStatus subscribeCancelRequestInternal(
+      uint32_t cmd_id, const NanSubscribeCancelRequest& msg);
+  WifiStatus transmitFollowupRequestInternal(
+      uint32_t cmd_id, const NanTransmitFollowupRequest& msg);
+  WifiStatus configRequestInternal(uint32_t cmd_id,
+                                   const NanConfigRequest& msg);
+  WifiStatus beaconSdfPayloadRequestInternal(
+      uint32_t cmd_id, const NanBeaconSdfPayloadRequest& msg);
+  std::pair<WifiStatus, NanVersion> getVersionInternal();
+  WifiStatus getCapabilitiesInternal(uint32_t cmd_id);
+  WifiStatus dataInterfaceCreateInternal(uint32_t cmd_id,
+                                         const std::string& iface_name);
+  WifiStatus dataInterfaceDeleteInternal(uint32_t cmd_id,
+                                         const std::string& iface_name);
+  WifiStatus dataRequestInitiatorInternal(
+      uint32_t cmd_id, const NanDataPathInitiatorRequest& msg);
+  WifiStatus dataIndicationResponseInternal(
+      uint32_t cmd_id, const NanDataPathIndicationResponse& msg);
+  WifiStatus dataEndInternal(uint32_t cmd_id, const NanDataPathEndRequest& msg);
+
   std::string ifname_;
-  std::weak_ptr<WifiLegacyHal> legacy_hal_;
+  std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
+  std::vector<sp<IWifiNanIfaceEventCallback>> event_callbacks_;
   bool is_valid_;
 
   DISALLOW_COPY_AND_ASSIGN(WifiNanIface);
diff --git a/wifi/1.0/default/wifi_p2p_iface.cpp b/wifi/1.0/default/wifi_p2p_iface.cpp
index 349a158..0d055f1 100644
--- a/wifi/1.0/default/wifi_p2p_iface.cpp
+++ b/wifi/1.0/default/wifi_p2p_iface.cpp
@@ -14,20 +14,22 @@
  * limitations under the License.
  */
 
-#include "wifi_p2p_iface.h"
-
 #include <android-base/logging.h>
 
-#include "failure_reason_util.h"
+#include "hidl_return_util.h"
+#include "wifi_p2p_iface.h"
+#include "wifi_status_util.h"
 
 namespace android {
 namespace hardware {
 namespace wifi {
 namespace V1_0 {
 namespace implementation {
+using hidl_return_util::validateAndCall;
 
-WifiP2pIface::WifiP2pIface(const std::string& ifname,
-                           const std::weak_ptr<WifiLegacyHal> legacy_hal)
+WifiP2pIface::WifiP2pIface(
+    const std::string& ifname,
+    const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
     : ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) {}
 
 void WifiP2pIface::invalidate() {
@@ -35,15 +37,30 @@
   is_valid_ = false;
 }
 
-Return<void> WifiP2pIface::getName(getName_cb cb) {
-  hidl_string hidl_ifname;
-  hidl_ifname.setToExternal(ifname_.c_str(), ifname_.size());
-  cb(hidl_ifname);
-  return Void();
+bool WifiP2pIface::isValid() {
+  return is_valid_;
 }
 
-Return<IfaceType> WifiP2pIface::getType() {
-  return IfaceType::P2P;
+Return<void> WifiP2pIface::getName(getName_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiP2pIface::getNameInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiP2pIface::getType(getType_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiP2pIface::getTypeInternal,
+                         hidl_status_cb);
+}
+
+std::pair<WifiStatus, std::string> WifiP2pIface::getNameInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
+}
+
+std::pair<WifiStatus, IfaceType> WifiP2pIface::getTypeInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::P2P};
 }
 
 }  // namespace implementation
diff --git a/wifi/1.0/default/wifi_p2p_iface.h b/wifi/1.0/default/wifi_p2p_iface.h
index d70415d..d2982db 100644
--- a/wifi/1.0/default/wifi_p2p_iface.h
+++ b/wifi/1.0/default/wifi_p2p_iface.h
@@ -34,17 +34,22 @@
 class WifiP2pIface : public IWifiP2pIface {
  public:
   WifiP2pIface(const std::string& ifname,
-               const std::weak_ptr<WifiLegacyHal> legacy_hal);
+               const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
   // Refer to |WifiChip::invalidate()|.
   void invalidate();
+  bool isValid();
 
   // HIDL methods exposed.
-  Return<void> getName(getName_cb cb) override;
-  Return<IfaceType> getType() override;
+  Return<void> getName(getName_cb hidl_status_cb) override;
+  Return<void> getType(getType_cb hidl_status_cb) override;
 
  private:
+  // Corresponding worker functions for the HIDL methods.
+  std::pair<WifiStatus, std::string> getNameInternal();
+  std::pair<WifiStatus, IfaceType> getTypeInternal();
+
   std::string ifname_;
-  std::weak_ptr<WifiLegacyHal> legacy_hal_;
+  std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
   bool is_valid_;
 
   DISALLOW_COPY_AND_ASSIGN(WifiP2pIface);
diff --git a/wifi/1.0/default/wifi_rtt_controller.cpp b/wifi/1.0/default/wifi_rtt_controller.cpp
index e2df1a8..6ac0629 100644
--- a/wifi/1.0/default/wifi_rtt_controller.cpp
+++ b/wifi/1.0/default/wifi_rtt_controller.cpp
@@ -14,33 +14,261 @@
  * limitations under the License.
  */
 
-#include "wifi_rtt_controller.h"
-
 #include <android-base/logging.h>
 
-#include "failure_reason_util.h"
+#include "hidl_return_util.h"
+#include "wifi_rtt_controller.h"
+#include "wifi_status_util.h"
 
 namespace android {
 namespace hardware {
 namespace wifi {
 namespace V1_0 {
 namespace implementation {
+using hidl_return_util::validateAndCall;
 
 WifiRttController::WifiRttController(
     const sp<IWifiIface>& bound_iface,
-    const std::weak_ptr<WifiLegacyHal> legacy_hal)
+    const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
     : bound_iface_(bound_iface), legacy_hal_(legacy_hal), is_valid_(true) {}
 
 void WifiRttController::invalidate() {
   legacy_hal_.reset();
+  event_callbacks_.clear();
   is_valid_ = false;
 }
 
-Return<void> WifiRttController::getBoundIface(getBoundIface_cb cb) {
-  cb(bound_iface_);
-  return Void();
+bool WifiRttController::isValid() {
+  return is_valid_;
 }
 
+Return<void> WifiRttController::getBoundIface(getBoundIface_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::getBoundIfaceInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiRttController::registerEventCallback(
+    const sp<IWifiRttControllerEventCallback>& callback,
+    registerEventCallback_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::registerEventCallbackInternal,
+                         hidl_status_cb,
+                         callback);
+}
+
+Return<void> WifiRttController::rangeRequest(
+    uint32_t cmd_id,
+    const hidl_vec<RttConfig>& rtt_configs,
+    rangeRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::rangeRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         rtt_configs);
+}
+
+Return<void> WifiRttController::rangeCancel(
+    uint32_t cmd_id,
+    const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
+    rangeCancel_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::rangeCancelInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         addrs);
+}
+
+Return<void> WifiRttController::setChannelMap(uint32_t cmd_id,
+                                              const RttChannelMap& params,
+                                              uint32_t num_dw,
+                                              setChannelMap_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::setChannelMapInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         params,
+                         num_dw);
+}
+
+Return<void> WifiRttController::clearChannelMap(
+    uint32_t cmd_id, clearChannelMap_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::clearChannelMapInternal,
+                         hidl_status_cb,
+                         cmd_id);
+}
+
+Return<void> WifiRttController::getCapabilities(
+    getCapabilities_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::getCapabilitiesInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiRttController::setDebugCfg(RttDebugType type,
+                                            setDebugCfg_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::setDebugCfgInternal,
+                         hidl_status_cb,
+                         type);
+}
+
+Return<void> WifiRttController::getDebugInfo(getDebugInfo_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::getDebugInfoInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiRttController::setLci(uint32_t cmd_id,
+                                       const RttLciInformation& lci,
+                                       setLci_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::setLciInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         lci);
+}
+
+Return<void> WifiRttController::setLcr(uint32_t cmd_id,
+                                       const RttLcrInformation& lcr,
+                                       setLcr_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::setLcrInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         lcr);
+}
+
+Return<void> WifiRttController::getResponderInfo(
+    getResponderInfo_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::getResponderInfoInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiRttController::enableResponder(
+    uint32_t cmd_id,
+    const WifiChannelInfo& channel_hint,
+    uint32_t maxDurationSeconds,
+    const RttResponder& info,
+    enableResponder_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::enableResponderInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         channel_hint,
+                         maxDurationSeconds,
+                         info);
+}
+
+Return<void> WifiRttController::disableResponder(
+    uint32_t cmd_id, disableResponder_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::disableResponderInternal,
+                         hidl_status_cb,
+                         cmd_id);
+}
+
+std::pair<WifiStatus, sp<IWifiIface>>
+WifiRttController::getBoundIfaceInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), bound_iface_};
+}
+
+WifiStatus WifiRttController::registerEventCallbackInternal(
+    const sp<IWifiRttControllerEventCallback>& callback) {
+  // TODO(b/31632518): remove the callback when the client is destroyed
+  event_callbacks_.emplace_back(callback);
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::rangeRequestInternal(
+    uint32_t /* cmd_id */, const std::vector<RttConfig>& /* rtt_configs */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::rangeCancelInternal(
+    uint32_t /* cmd_id */,
+    const std::vector<hidl_array<uint8_t, 6>>& /* addrs */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::setChannelMapInternal(
+    uint32_t /* cmd_id */,
+    const RttChannelMap& /* params */,
+    uint32_t /* num_dw */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::clearChannelMapInternal(uint32_t /* cmd_id */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, RttCapabilities>
+WifiRttController::getCapabilitiesInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiRttController::setDebugCfgInternal(RttDebugType /* type */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, RttDebugInfo> WifiRttController::getDebugInfoInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiRttController::setLciInternal(
+    uint32_t /* cmd_id */, const RttLciInformation& /* lci */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::setLcrInternal(
+    uint32_t /* cmd_id */, const RttLcrInformation& /* lcr */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, RttResponder>
+WifiRttController::getResponderInfoInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiRttController::enableResponderInternal(
+    uint32_t /* cmd_id */,
+    const WifiChannelInfo& /* channel_hint */,
+    uint32_t /* maxDurationSeconds */,
+    const RttResponder& /* info */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::disableResponderInternal(uint32_t /* cmd_id */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace wifi
diff --git a/wifi/1.0/default/wifi_rtt_controller.h b/wifi/1.0/default/wifi_rtt_controller.h
index 8d78b93..3dd5340 100644
--- a/wifi/1.0/default/wifi_rtt_controller.h
+++ b/wifi/1.0/default/wifi_rtt_controller.h
@@ -20,6 +20,7 @@
 #include <android-base/macros.h>
 #include <android/hardware/wifi/1.0/IWifiIface.h>
 #include <android/hardware/wifi/1.0/IWifiRttController.h>
+#include <android/hardware/wifi/1.0/IWifiRttControllerEventCallback.h>
 
 #include "wifi_legacy_hal.h"
 
@@ -35,16 +36,75 @@
 class WifiRttController : public IWifiRttController {
  public:
   WifiRttController(const sp<IWifiIface>& bound_iface,
-                    const std::weak_ptr<WifiLegacyHal> legacy_hal);
+                    const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
   // Refer to |WifiChip::invalidate()|.
   void invalidate();
+  bool isValid();
 
   // HIDL methods exposed.
-  Return<void> getBoundIface(getBoundIface_cb cb) override;
+  Return<void> getBoundIface(getBoundIface_cb hidl_status_cb) override;
+  Return<void> registerEventCallback(
+      const sp<IWifiRttControllerEventCallback>& callback,
+      registerEventCallback_cb hidl_status_cb) override;
+  Return<void> rangeRequest(uint32_t cmd_id,
+                            const hidl_vec<RttConfig>& rtt_configs,
+                            rangeRequest_cb hidl_status_cb) override;
+  Return<void> rangeCancel(uint32_t cmd_id,
+                           const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
+                           rangeCancel_cb hidl_status_cb) override;
+  Return<void> setChannelMap(uint32_t cmd_id,
+                             const RttChannelMap& params,
+                             uint32_t num_dw,
+                             setChannelMap_cb hidl_status_cb) override;
+  Return<void> clearChannelMap(uint32_t cmd_id,
+                               clearChannelMap_cb hidl_status_cb) override;
+  Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
+  Return<void> setDebugCfg(RttDebugType type,
+                           setDebugCfg_cb hidl_status_cb) override;
+  Return<void> getDebugInfo(getDebugInfo_cb hidl_status_cb) override;
+  Return<void> setLci(uint32_t cmd_id,
+                      const RttLciInformation& lci,
+                      setLci_cb hidl_status_cb) override;
+  Return<void> setLcr(uint32_t cmd_id,
+                      const RttLcrInformation& lcr,
+                      setLcr_cb hidl_status_cb) override;
+  Return<void> getResponderInfo(getResponderInfo_cb hidl_status_cb) override;
+  Return<void> enableResponder(uint32_t cmd_id,
+                               const WifiChannelInfo& channel_hint,
+                               uint32_t maxDurationSeconds,
+                               const RttResponder& info,
+                               enableResponder_cb hidl_status_cb) override;
+  Return<void> disableResponder(uint32_t cmd_id,
+                                disableResponder_cb hidl_status_cb) override;
 
  private:
+  // Corresponding worker functions for the HIDL methods.
+  std::pair<WifiStatus, sp<IWifiIface>> getBoundIfaceInternal();
+  WifiStatus registerEventCallbackInternal(
+      const sp<IWifiRttControllerEventCallback>& callback);
+  WifiStatus rangeRequestInternal(uint32_t cmd_id,
+                                  const std::vector<RttConfig>& rtt_configs);
+  WifiStatus rangeCancelInternal(
+      uint32_t cmd_id, const std::vector<hidl_array<uint8_t, 6>>& addrs);
+  WifiStatus setChannelMapInternal(uint32_t cmd_id,
+                                   const RttChannelMap& params,
+                                   uint32_t num_dw);
+  WifiStatus clearChannelMapInternal(uint32_t cmd_id);
+  std::pair<WifiStatus, RttCapabilities> getCapabilitiesInternal();
+  WifiStatus setDebugCfgInternal(RttDebugType type);
+  std::pair<WifiStatus, RttDebugInfo> getDebugInfoInternal();
+  WifiStatus setLciInternal(uint32_t cmd_id, const RttLciInformation& lci);
+  WifiStatus setLcrInternal(uint32_t cmd_id, const RttLcrInformation& lcr);
+  std::pair<WifiStatus, RttResponder> getResponderInfoInternal();
+  WifiStatus enableResponderInternal(uint32_t cmd_id,
+                                     const WifiChannelInfo& channel_hint,
+                                     uint32_t maxDurationSeconds,
+                                     const RttResponder& info);
+  WifiStatus disableResponderInternal(uint32_t cmd_id);
+
   sp<IWifiIface> bound_iface_;
-  std::weak_ptr<WifiLegacyHal> legacy_hal_;
+  std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
+  std::vector<sp<IWifiRttControllerEventCallback>> event_callbacks_;
   bool is_valid_;
 
   DISALLOW_COPY_AND_ASSIGN(WifiRttController);
diff --git a/wifi/1.0/default/wifi_sta_iface.cpp b/wifi/1.0/default/wifi_sta_iface.cpp
index 225cec4..6365032 100644
--- a/wifi/1.0/default/wifi_sta_iface.cpp
+++ b/wifi/1.0/default/wifi_sta_iface.cpp
@@ -14,36 +14,275 @@
  * limitations under the License.
  */
 
-#include "wifi_sta_iface.h"
-
 #include <android-base/logging.h>
 
-#include "failure_reason_util.h"
+#include "hidl_return_util.h"
+#include "wifi_sta_iface.h"
+#include "wifi_status_util.h"
 
 namespace android {
 namespace hardware {
 namespace wifi {
 namespace V1_0 {
 namespace implementation {
+using hidl_return_util::validateAndCall;
 
-WifiStaIface::WifiStaIface(const std::string& ifname,
-                           const std::weak_ptr<WifiLegacyHal> legacy_hal)
+WifiStaIface::WifiStaIface(
+    const std::string& ifname,
+    const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
     : ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) {}
 
 void WifiStaIface::invalidate() {
   legacy_hal_.reset();
+  event_callbacks_.clear();
   is_valid_ = false;
 }
 
-Return<void> WifiStaIface::getName(getName_cb cb) {
-  hidl_string hidl_ifname;
-  hidl_ifname.setToExternal(ifname_.c_str(), ifname_.size());
-  cb(hidl_ifname);
-  return Void();
+bool WifiStaIface::isValid() {
+  return is_valid_;
 }
 
-Return<IfaceType> WifiStaIface::getType() {
-  return IfaceType::STA;
+Return<void> WifiStaIface::getName(getName_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::getNameInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getType(getType_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::getTypeInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::registerEventCallback(
+    const sp<IWifiStaIfaceEventCallback>& callback,
+    registerEventCallback_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::registerEventCallbackInternal,
+                         hidl_status_cb,
+                         callback);
+}
+
+Return<void> WifiStaIface::getCapabilities(getCapabilities_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::getCapabilitiesInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getApfPacketFilterCapabilities(
+    getApfPacketFilterCapabilities_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::getApfPacketFilterCapabilitiesInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::installApfPacketFilter(
+    uint32_t cmd_id,
+    const hidl_vec<uint8_t>& program,
+    installApfPacketFilter_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::installApfPacketFilterInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         program);
+}
+
+Return<void> WifiStaIface::getBackgroundScanCapabilities(
+    getBackgroundScanCapabilities_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::getBackgroundScanCapabilitiesInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getValidFrequenciesForBackgroundScan(
+    StaBackgroundScanBand band,
+    getValidFrequenciesForBackgroundScan_cb hidl_status_cb) {
+  return validateAndCall(
+      this,
+      WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+      &WifiStaIface::getValidFrequenciesForBackgroundScanInternal,
+      hidl_status_cb,
+      band);
+}
+
+Return<void> WifiStaIface::startBackgroundScan(
+    uint32_t cmd_id,
+    const StaBackgroundScanParameters& params,
+    startBackgroundScan_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::startBackgroundScanInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         params);
+}
+
+Return<void> WifiStaIface::stopBackgroundScan(
+    uint32_t cmd_id, stopBackgroundScan_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::stopBackgroundScanInternal,
+                         hidl_status_cb,
+                         cmd_id);
+}
+
+Return<void> WifiStaIface::enableLinkLayerStatsCollection(
+    bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::enableLinkLayerStatsCollectionInternal,
+                         hidl_status_cb,
+                         debug);
+}
+
+Return<void> WifiStaIface::disableLinkLayerStatsCollection(
+    disableLinkLayerStatsCollection_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::disableLinkLayerStatsCollectionInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getLinkLayerStats(
+    getLinkLayerStats_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::getLinkLayerStatsInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::startDebugPacketFateMonitoring(
+    startDebugPacketFateMonitoring_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::startDebugPacketFateMonitoringInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::stopDebugPacketFateMonitoring(
+    stopDebugPacketFateMonitoring_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::stopDebugPacketFateMonitoringInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getDebugTxPacketFates(
+    getDebugTxPacketFates_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::getDebugTxPacketFatesInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiStaIface::getDebugRxPacketFates(
+    getDebugRxPacketFates_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
+                         &WifiStaIface::getDebugRxPacketFatesInternal,
+                         hidl_status_cb);
+}
+
+std::pair<WifiStatus, std::string> WifiStaIface::getNameInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
+}
+
+std::pair<WifiStatus, IfaceType> WifiStaIface::getTypeInternal() {
+  return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::STA};
+}
+
+WifiStatus WifiStaIface::registerEventCallbackInternal(
+    const sp<IWifiStaIfaceEventCallback>& callback) {
+  // TODO(b/31632518): remove the callback when the client is destroyed
+  event_callbacks_.emplace_back(callback);
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, uint32_t> WifiStaIface::getCapabilitiesInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), 0};
+}
+
+std::pair<WifiStatus, StaApfPacketFilterCapabilities>
+WifiStaIface::getApfPacketFilterCapabilitiesInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiStaIface::installApfPacketFilterInternal(
+    uint32_t /* cmd_id */, const std::vector<uint8_t>& /* program */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, StaBackgroundScanCapabilities>
+WifiStaIface::getBackgroundScanCapabilitiesInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
+WifiStaIface::getValidFrequenciesForBackgroundScanInternal(
+    StaBackgroundScanBand /* band */) {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiStaIface::startBackgroundScanInternal(
+    uint32_t /* cmd_id */, const StaBackgroundScanParameters& /* params */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiStaIface::stopBackgroundScanInternal(uint32_t /* cmd_id */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiStaIface::enableLinkLayerStatsCollectionInternal(
+    bool /* debug */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, StaLinkLayerStats>
+WifiStaIface::getLinkLayerStatsInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiStaIface::startDebugPacketFateMonitoringInternal() {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiStaIface::stopDebugPacketFateMonitoringInternal() {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>>
+WifiStaIface::getDebugTxPacketFatesInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>>
+WifiStaIface::getDebugRxPacketFatesInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
 }
 
 }  // namespace implementation
diff --git a/wifi/1.0/default/wifi_sta_iface.h b/wifi/1.0/default/wifi_sta_iface.h
index fc5efec..09a883c 100644
--- a/wifi/1.0/default/wifi_sta_iface.h
+++ b/wifi/1.0/default/wifi_sta_iface.h
@@ -19,6 +19,7 @@
 
 #include <android-base/macros.h>
 #include <android/hardware/wifi/1.0/IWifiStaIface.h>
+#include <android/hardware/wifi/1.0/IWifiStaIfaceEventCallback.h>
 
 #include "wifi_legacy_hal.h"
 
@@ -34,17 +35,80 @@
 class WifiStaIface : public IWifiStaIface {
  public:
   WifiStaIface(const std::string& ifname,
-               const std::weak_ptr<WifiLegacyHal> legacy_hal);
+               const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
   // Refer to |WifiChip::invalidate()|.
   void invalidate();
+  bool isValid();
 
   // HIDL methods exposed.
-  Return<void> getName(getName_cb cb) override;
-  Return<IfaceType> getType() override;
+  Return<void> getName(getName_cb hidl_status_cb) override;
+  Return<void> getType(getType_cb hidl_status_cb) override;
+  Return<void> registerEventCallback(
+      const sp<IWifiStaIfaceEventCallback>& callback,
+      registerEventCallback_cb hidl_status_cb) override;
+  Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
+  Return<void> getApfPacketFilterCapabilities(
+      getApfPacketFilterCapabilities_cb hidl_status_cb) override;
+  Return<void> installApfPacketFilter(
+      uint32_t cmd_id,
+      const hidl_vec<uint8_t>& program,
+      installApfPacketFilter_cb hidl_status_cb) override;
+  Return<void> getBackgroundScanCapabilities(
+      getBackgroundScanCapabilities_cb hidl_status_cb) override;
+  Return<void> getValidFrequenciesForBackgroundScan(
+      StaBackgroundScanBand band,
+      getValidFrequenciesForBackgroundScan_cb hidl_status_cb) override;
+  Return<void> startBackgroundScan(
+      uint32_t cmd_id,
+      const StaBackgroundScanParameters& params,
+      startBackgroundScan_cb hidl_status_cb) override;
+  Return<void> stopBackgroundScan(
+      uint32_t cmd_id, stopBackgroundScan_cb hidl_status_cb) override;
+  Return<void> enableLinkLayerStatsCollection(
+      bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) override;
+  Return<void> disableLinkLayerStatsCollection(
+      disableLinkLayerStatsCollection_cb hidl_status_cb) override;
+  Return<void> getLinkLayerStats(getLinkLayerStats_cb hidl_status_cb) override;
+  Return<void> startDebugPacketFateMonitoring(
+      startDebugPacketFateMonitoring_cb hidl_status_cb) override;
+  Return<void> stopDebugPacketFateMonitoring(
+      stopDebugPacketFateMonitoring_cb hidl_status_cb) override;
+  Return<void> getDebugTxPacketFates(
+      getDebugTxPacketFates_cb hidl_status_cb) override;
+  Return<void> getDebugRxPacketFates(
+      getDebugRxPacketFates_cb hidl_status_cb) override;
 
  private:
+  // Corresponding worker functions for the HIDL methods.
+  std::pair<WifiStatus, std::string> getNameInternal();
+  std::pair<WifiStatus, IfaceType> getTypeInternal();
+  WifiStatus registerEventCallbackInternal(
+      const sp<IWifiStaIfaceEventCallback>& callback);
+  std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
+  std::pair<WifiStatus, StaApfPacketFilterCapabilities>
+  getApfPacketFilterCapabilitiesInternal();
+  WifiStatus installApfPacketFilterInternal(
+      uint32_t cmd_id, const std::vector<uint8_t>& program);
+  std::pair<WifiStatus, StaBackgroundScanCapabilities>
+  getBackgroundScanCapabilitiesInternal();
+  std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
+  getValidFrequenciesForBackgroundScanInternal(StaBackgroundScanBand band);
+  WifiStatus startBackgroundScanInternal(
+      uint32_t cmd_id, const StaBackgroundScanParameters& params);
+  WifiStatus stopBackgroundScanInternal(uint32_t cmd_id);
+  WifiStatus enableLinkLayerStatsCollectionInternal(bool debug);
+  WifiStatus disableLinkLayerStatsCollectionInternal();
+  std::pair<WifiStatus, StaLinkLayerStats> getLinkLayerStatsInternal();
+  WifiStatus startDebugPacketFateMonitoringInternal();
+  WifiStatus stopDebugPacketFateMonitoringInternal();
+  std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>>
+  getDebugTxPacketFatesInternal();
+  std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>>
+  getDebugRxPacketFatesInternal();
+
   std::string ifname_;
-  std::weak_ptr<WifiLegacyHal> legacy_hal_;
+  std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
+  std::vector<sp<IWifiStaIfaceEventCallback>> event_callbacks_;
   bool is_valid_;
 
   DISALLOW_COPY_AND_ASSIGN(WifiStaIface);
diff --git a/wifi/1.0/default/wifi_status_util.cpp b/wifi/1.0/default/wifi_status_util.cpp
new file mode 100644
index 0000000..34a1c1d
--- /dev/null
+++ b/wifi/1.0/default/wifi_status_util.cpp
@@ -0,0 +1,103 @@
+/*
+ * 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.
+ */
+
+#include "wifi_status_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_0 {
+namespace implementation {
+
+std::string legacyErrorToString(wifi_error error) {
+  switch (error) {
+    case WIFI_SUCCESS:
+      return "SUCCESS";
+    case WIFI_ERROR_UNINITIALIZED:
+      return "UNINITIALIZED";
+    case WIFI_ERROR_NOT_AVAILABLE:
+      return "NOT_AVAILABLE";
+    case WIFI_ERROR_NOT_SUPPORTED:
+      return "NOT_SUPPORTED";
+    case WIFI_ERROR_INVALID_ARGS:
+      return "INVALID_ARGS";
+    case WIFI_ERROR_INVALID_REQUEST_ID:
+      return "INVALID_REQUEST_ID";
+    case WIFI_ERROR_TIMED_OUT:
+      return "TIMED_OUT";
+    case WIFI_ERROR_TOO_MANY_REQUESTS:
+      return "TOO_MANY_REQUESTS";
+    case WIFI_ERROR_OUT_OF_MEMORY:
+      return "OUT_OF_MEMORY";
+    case WIFI_ERROR_UNKNOWN:
+    default:
+      return "UNKNOWN";
+  }
+}
+
+WifiStatus createWifiStatus(WifiStatusCode code,
+                            const std::string& description) {
+  return {code, description};
+}
+
+WifiStatus createWifiStatus(WifiStatusCode code) {
+  return createWifiStatus(code, "");
+}
+
+WifiStatus createWifiStatusFromLegacyError(wifi_error error,
+                                           const std::string& desc) {
+  switch (error) {
+    case WIFI_ERROR_UNINITIALIZED:
+    case WIFI_ERROR_NOT_AVAILABLE:
+      return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, desc);
+
+    case WIFI_ERROR_NOT_SUPPORTED:
+      return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED, desc);
+
+    case WIFI_ERROR_INVALID_ARGS:
+    case WIFI_ERROR_INVALID_REQUEST_ID:
+      return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS, desc);
+
+    case WIFI_ERROR_TIMED_OUT:
+      return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
+                              desc + ", timed out");
+
+    case WIFI_ERROR_TOO_MANY_REQUESTS:
+      return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
+                              desc + ", too many requests");
+
+    case WIFI_ERROR_OUT_OF_MEMORY:
+      return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
+                              desc + ", out of memory");
+
+    case WIFI_ERROR_NONE:
+      return createWifiStatus(WifiStatusCode::SUCCESS, desc);
+
+    case WIFI_ERROR_UNKNOWN:
+    default:
+      return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, "unknown");
+  }
+}
+
+WifiStatus createWifiStatusFromLegacyError(wifi_error error) {
+  return createWifiStatusFromLegacyError(error, "");
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
diff --git a/wifi/1.0/default/failure_reason_util.h b/wifi/1.0/default/wifi_status_util.h
similarity index 65%
rename from wifi/1.0/default/failure_reason_util.h
rename to wifi/1.0/default/wifi_status_util.h
index 7d51bbf..c988b05 100644
--- a/wifi/1.0/default/failure_reason_util.h
+++ b/wifi/1.0/default/wifi_status_util.h
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef FAILURE_REASON_UTIL_H_
-#define FAILURE_REASON_UTIL_H_
+#ifndef WIFI_STATUS_UTIL_H_
+#define WIFI_STATUS_UTIL_H_
 
 #include <android/hardware/wifi/1.0/IWifi.h>
 #include <hardware_legacy/wifi_hal.h>
@@ -26,12 +26,13 @@
 namespace V1_0 {
 namespace implementation {
 
-std::string LegacyErrorToString(wifi_error error);
-
-FailureReason CreateFailureReason(CommandFailureReason reason,
-                                  const std::string& description);
-FailureReason CreateFailureReasonLegacyError(wifi_error error,
-                                             const std::string& description);
+std::string legacyErrorToString(wifi_error error);
+WifiStatus createWifiStatus(WifiStatusCode code,
+                            const std::string& description);
+WifiStatus createWifiStatus(WifiStatusCode code);
+WifiStatus createWifiStatusFromLegacyError(wifi_error error,
+                                           const std::string& description);
+WifiStatus createWifiStatusFromLegacyError(wifi_error error);
 
 }  // namespace implementation
 }  // namespace V1_0
@@ -39,4 +40,4 @@
 }  // namespace hardware
 }  // namespace android
 
-#endif  // FAILURE_REASON_UTIL_H_
+#endif  // WIFI_STATUS_UTIL_H_
diff --git a/wifi/1.0/types.hal b/wifi/1.0/types.hal
index d9abaef..066662c 100644
--- a/wifi/1.0/types.hal
+++ b/wifi/1.0/types.hal
@@ -17,25 +17,29 @@
 package android.hardware.wifi@1.0;
 
 /**
- * List of failure reasons returned.
+ * Enum values indicating the status of operation.
  */
-enum CommandFailureReason : uint32_t {
-  UNKNOWN,
-  DUPLICATE_COMMAND_ID,
-  NOT_SUPPORTED,
-  NOT_AVAILABLE,
-  INVALID_ARGS,
-  DRIVER_ERROR_OTHER,
-  FIRMWARE_ERROR_OTHER,
-  SCAN_INVALID_CHANNEL
+enum WifiStatusCode : uint32_t {
+  /** No errors. */
+  SUCCESS,
+  /** Method invoked on an invalid |IWifiChip| object. */
+  ERROR_WIFI_CHIP_INVALID,
+  /** Method invoked on an invalid |IWifiIface| object. */
+  ERROR_WIFI_IFACE_INVALID,
+  /** Method invoked on an invalid |IWifiRttController| object. */
+  ERROR_WIFI_RTT_CONTROLLER_INVALID,
+  ERROR_NOT_SUPPORTED,
+  ERROR_NOT_AVAILABLE,
+  ERROR_NOT_STARTED,
+  ERROR_INVALID_ARGS,
+  ERROR_UNKNOWN
 };
 
 /**
- * Generic structure to return information about a failure.
+ * Generic structure to return the status of an operation.
  */
-struct FailureReason {
-  CommandFailureReason reason;
-
+struct WifiStatus {
+  WifiStatusCode code;
   /**
    * A vendor specific error message from the vendor to provide more
    * information beyond the reason code.
@@ -51,7 +55,7 @@
   AP,
   P2P,
   /**
-   * NAN control interface. Datapath support may be queried and created
+   * NAN control interface. Datapath support must be queried and created
    * through this interface.
    */
   NAN,
@@ -66,3 +70,3103 @@
  * An identifier for a mode that the chip can be put in.
  */
 typedef uint32_t ChipModeId;
+
+/**
+ * A unique handle provided by the client to identify individual invocations of
+ * certain API's like |IWifiStaIface.startBackgroundScan|,
+ * |IWifiStaIface.installApfPacketFilter|, etc.
+ */
+typedef uint32_t CommandId;
+
+/**
+ * Channel frequency in Mhz.
+ */
+typedef uint32_t WifiChannelInMhz;
+
+/**
+ * Channel operating width in Mhz.
+ */
+enum WifiChannelWidthInMhz : uint32_t {
+  WIDTH_20    = 0,
+  WIDTH_40    = 1,
+  WIDTH_80    = 2,
+  WIDTH_160   = 3,
+  WIDTH_80P80 = 4,
+  WIDTH_5     = 5,
+  WIDTH_10    = 6,
+  WIDTH_INVALID = -1
+};
+
+/**
+ * Channel information.
+ */
+struct WifiChannelInfo {
+  /**
+   * Channel width (20, 40, 80, 80+80, 160).
+   */
+  WifiChannelWidthInMhz width;
+  /**
+   * Primary 20 MHz channel.
+   */
+  WifiChannelInMhz centerFreq;
+  /**
+   * Center frequency (MHz) first segment.
+   */
+  WifiChannelInMhz centerFreq0;
+  /**
+   * Center frequency (MHz) second segment.
+   */
+  WifiChannelInMhz centerFreq1;
+};
+
+/**
+ * RSSI information.
+ */
+typedef int32_t Rssi;
+
+/**
+ * Mac Address type. 6 octets representing physical address of a device.
+ */
+typedef uint8_t[6] MacAddress;
+
+/**
+ * SSID type. 32 octets representing the network.
+ */
+typedef uint8_t[32] Ssid;
+
+/**
+ * BSSID type. 6 octets representing the physical address of an AP.
+ */
+typedef MacAddress Bssid;
+
+/**
+ * TimeStamp in milliseconds (ms).
+ */
+typedef uint32_t TimeStampInMs;
+
+/**
+ * TimeStamp in microseconds (us).
+ */
+typedef uint64_t TimeStampInUs;
+
+/**
+ * TimeStamp in picoseconds (ps).
+ */
+typedef uint64_t TimeSpanInPs;
+
+/**
+ * Information elements contained within the |ScanResult| structure.
+ * These elements correspond to the IEEE_802.11 standard.
+ */
+struct WifiInformationElement {
+  uint8_t id;
+  vec<uint8_t> data;
+};
+
+enum WifiRatePreamble : uint32_t {
+  OFDM = 0,
+  CCK = 1,
+  HT = 2,
+  VHT = 3,
+  RESERVED = 4
+};
+
+/**
+ * Number of spatial streams in VHT/HT.
+ */
+enum WifiRateNss : uint32_t {
+  NSS_1x1 = 0,
+  NSS_2x2 = 1,
+  NSS_3x3 = 2,
+  NSS_4x4 = 3
+};
+
+/**
+ * Wifi rate info.
+ */
+struct WifiRateInfo {
+  /**
+   * Preamble used for RTT measurements.
+   */
+  WifiRatePreamble preamble;
+  /**
+   * Number of spatial streams.
+   */
+  WifiRateNss nss;
+  /**
+   * Bandwidth of channel.
+   */
+  WifiChannelWidthInMhz bw;
+  /**
+   * OFDM/CCK rate code would be as per ieee std in the units of 0.5mbps.
+   * HT/VHT it would be mcs index.
+   */
+  uint8_t rateMcsIdx;
+  /**
+   * Bitrate in units of 100 Kbps.
+   */
+  uint32_t bitRateInKbps;
+};
+
+/**
+ * STA specific types.
+ * TODO(b/32159498): Move to a separate nan_types.hal.
+ */
+/**
+ * Parameters to specify the APF capability of this iface.
+ */
+struct StaApfPacketFilterCapabilities {
+  /**
+   * Version of the packet filter interpreter supported
+   */
+  uint32_t version;
+  /**
+   * Maximum size of the filter bytecodes in byte for an iface.
+   */
+  uint32_t maxLength;
+};
+
+/**
+ * Parameters to specify the Background Scan capability of this iface.
+ */
+struct StaBackgroundScanCapabilities {
+  /**
+   * Maximum number of byte available for cached scan results
+   */
+  uint32_t maxCacheSize;
+  /**
+   * Maximum number of buckets that can be supplied for a scan
+   */
+  uint32_t maxBuckets;
+  /**
+   * Maximum number of APs that must be stored for each scan.
+   */
+  uint32_t maxApCachePerScan;
+  /**
+   * Max reporting number of scans threshold that can be specified in the scan
+   * parameters.
+   */
+  int32_t maxReportingThreshold;
+};
+
+/**
+ * Bands that can be specified in Background scan requests.
+ */
+enum StaBackgroundScanBand : uint32_t {
+  BAND_UNSPECIFIED,
+  /**
+   * 2.4 GHz.
+   */
+  BAND_24GHZ = 1,
+  /**
+   * 5 GHz without DFS.
+   */
+  BAND_5GHZ = 2,
+  /**
+   * 5 GHz DFS only.
+   */
+  BAND_5GHZ_DFS = 4,
+  /**
+   * 5 GHz with DFS.
+   */
+  BAND_5GHZ_WITH_DFS = 6,
+  /**
+   * 2.4 GHz + 5 GHz; no DFS.
+   */
+  BAND_24GHZ_5GHZ = 3,
+  /**
+   * 2.4 GHz + 5 GHz with DFS
+   */
+  BAND_24GHZ_5GHZ_WITH_DFS = 7
+};
+
+/**
+ * Mask of event reporting schemes that can be specified in background scan
+ * requests.
+ */
+enum StaBackgroundScanBucketEventReportSchemeMask : uint32_t {
+  /**
+   * Report a scan completion event after scan. If this is not set then scan
+   * completion events must be reported if report_threshold_percent or
+   * report_threshold_num_scans is reached.
+   */
+  EACH_SCAN = 1 << 0,
+  /**
+   * Forward scan results (beacons/probe responses + IEs) in real time to HAL,
+   * in addition to completion events.
+   * Note: To keep backward compatibility, fire completion events regardless
+   * of REPORT_EVENTS_EACH_SCAN.
+   */
+  FULL_RESULTS = 1 << 1,
+  /**
+   * Controls if scans for this bucket must be placed in the results buffer.
+   */
+  NO_BATCH = 1 << 2,
+};
+
+/**
+ * Background Scan parameters per bucket that can be specified in background
+ * scan requests.
+ */
+struct StaBackgroundScanBucketParameters {
+  /**
+   * Bands to scan or 0 if frequencies list must be used instead.
+   */
+  StaBackgroundScanBand band;
+  /**
+   * Channel frequencies (in Mhz) to scan if |band| is set to
+   * |UNSPECIFIED|.
+   */
+  vec<WifiChannelInMhz> frequencies;
+  /**
+   * Period at which this bucket must be scanned (in milliseconds). Must be an integer
+   * multiple of the |basePeriodInMs| specified in the BackgroundScanParameters.
+   */
+  uint32_t periodInMs;
+  /**
+   * Bitset of |BackgroundScanBucketEventReportSchemeMask| values controlling
+   * when events for this bucket must be reported.
+   */
+  uint32_t eventReportScheme;
+  /**
+   * For exponential back off. If |exponentialMaxPeriodInMs| is non zero or
+   * different than period, then this bucket is an exponential backoff bucket
+   * and the scan period must grow exponentially as per formula:
+   *   actual_period(N) = period * (base ^ (N/step_count))
+   * to this maximum period (in milliseconds).
+   */
+  uint32_t exponentialMaxPeriodInMs;
+  /**
+   * For exponential back off. multiplier: new_period=old_period * base
+   */
+  uint32_t exponentialBase;
+  /**
+   * For exponential back off. Number of scans to perform for a given
+   * period.
+   */
+  uint32_t exponentialStepCount;
+};
+
+/**
+ * Background Scan parameters that can be specified in background scan
+ * requests.
+ */
+struct StaBackgroundScanParameters {
+  /**
+   * GCD of all bucket periods (in milliseconds).
+   */
+  uint32_t basePeriodInMs;
+  /**
+   * Maximum number of APs that must be stored for each scan. If the maximum
+   * is reached the highest RSSI results must be returned.
+   */
+  uint32_t maxApPerScan;
+  /**
+   * % cache buffer filled threshold at which the host must be notified of
+   * batched scan results.
+   */
+  uint32_t reportThresholdPercent;
+  /**
+   * Threshold at which the AP must be woken up, in number of scans.
+   */
+  uint32_t reportThresholdNumScans;
+  /**
+   * List of buckets to be scheduled.
+   */
+  vec<StaBackgroundScanBucketParameters> buckets;
+};
+
+/**
+ * Packet stats for different traffic categories.
+ */
+struct StaLinkLayerIfacePacketStats {
+  /**
+   * Number of received unicast data packets.
+   */
+  uint64_t rxMpdu;
+  /**
+   * Number of successfully transmitted unicast data pkts (ACK rcvd).
+   */
+  uint64_t txMpdu;
+  /**
+   * Number of transmitted unicast data pkt losses (no ACK).
+   */
+  uint64_t lostMpdu;
+  /**
+   * Number of transmitted unicast data retry pkts.
+   */
+  uint64_t retries;
+};
+
+/**
+ * Iface statistics for the current connection.
+ */
+struct StaLinkLayerIfaceStats {
+  /**
+   * Number beacons received from the connected AP.
+   */
+  uint32_t beaconRx;
+  /**
+   * Access Point Beacon and Management frames RSSI (averaged).
+   */
+  int32_t avgRssiMgmt;
+  /**
+   * WME Best Effort Access Category packet counters.
+   */
+  StaLinkLayerIfacePacketStats wmeBePktStats;
+  /**
+   * WME Background Access Category packet counters.
+   */
+  StaLinkLayerIfacePacketStats wmeBkPktStats;
+  /**
+   * WME Video Access Category packet counters.
+   */
+  StaLinkLayerIfacePacketStats wmeViPktStats;
+  /**
+   * WME Voice Access Category packet counters.
+   */
+  StaLinkLayerIfacePacketStats wmeVoPktStats;
+};
+
+/**
+ * Cumulative radio statistics since collection was enabled.
+ */
+struct StaLinkLayerRadioStats {
+  /**
+   * Time for which the radio is awake.
+   */
+  uint32_t onTimeInMs;
+  /**
+   * Total time for which the radio is in active transmission.
+   */
+  uint32_t txTimeInMs;
+  /**
+   * Time for which the radio is in active tranmission per tx level.
+   */
+  vec<uint32_t> txTimeInMsPerLevel;
+  /**
+   * Time for which the radio is in active receive.
+   */
+  uint32_t rxTimeInMs;
+  /**
+   *  Total time for which the radio is awake due to scan.
+   */
+  uint32_t onTimeInMsForScan;
+};
+
+/**
+ * Link layer stats retrieved via |getLinkLayerStats|.
+ */
+struct StaLinkLayerStats {
+  StaLinkLayerIfaceStats iface;
+  StaLinkLayerRadioStats radio;
+  /**
+   * TimeStamp for each stats sample.
+   * This is the absolute milliseconds from boot when these stats were
+   * sampled.
+   */
+  TimeStampInMs timeStampInMs;
+};
+
+/**
+ * Structure describing all the information about a single access point seen
+ * during the scan.
+ */
+struct StaScanResult {
+  TimeStampInUs timeStampInUs;
+  vec<uint8_t> ssid;
+  Bssid bssid;
+  Rssi rssi;
+  WifiChannelInMhz frequency;
+  uint16_t beaconPeriodInMs;
+  uint16_t capability;
+  vec<WifiInformationElement> informationElements;
+};
+
+/**
+ * Mask of flags set in the |ScanData| instance.
+ */
+enum StaScanDataFlagMask {
+  /**
+   * Indicates that a scan was interrupted/did not occur so results may be
+   * incomplete.
+   */
+  WIFI_SCAN_FLAG_INTERRUPTED = 1 << 0,
+};
+
+/**
+ * Structure describing all the information about all the access points seen during
+ * the scan.
+ */
+struct StaScanData {
+  /**
+   * Bitset containing |ScanDataFlagMask| values.
+   */
+  uint32_t flags;
+  /**
+   * Bitset where each bit indicates if the bucket with that index was
+   * scanned.
+   */
+  uint32_t bucketsScanned;
+  /**
+   * List of scan results.
+   */
+  vec<StaScanResult> results;
+};
+
+/**
+ * NAN specific types.
+ * TODO(b/32159498): Move to a separate nan_types.hal.
+ */
+/**
+ * Various max sizes used in the NAN interface.
+ */
+enum NanMaxSize : uint32_t {
+  SOCIAL_CHANNELS = 3,
+  SERVICE_NAME_LEN = 255,
+  MATCH_FILTER_LEN = 255,
+  SERVICE_SPECIFIC_INFO_LEN = 1024,
+  VSA_DATA_LEN = 1024,
+  MESH_DATA_LEN = 32,
+  INFRA_DATA_LEN = 32,
+  CLUSTER_ATTRIBUTE_LEN = 255,
+  SUBSCRIBE_MAX_ADDRESS = 42,
+  FAM_CHANNELS = 32,
+  POSTDISCOVERY_LEN = 5,
+  FRAME_DATA_LEN = 504,
+  DP_APP_INFO_LEN = 512,
+};
+
+/**
+ * NAN protocol Version info.
+ */
+typedef int32_t NanVersion;
+
+/**
+ * NAN data path identifiers.
+ */
+typedef uint32_t NanDataPathId;
+
+/**
+ * Data request Initiator/Responder app/service related info.
+ */
+struct NanDataPathAppInfo {
+  /**
+   * Max length: |MAX_DP_APP_INFO_LEN|.
+   */
+  vec<uint8_t> ndpAppInfo;
+};
+
+/**
+ * Configuration params of Data request Initiator/Responder.
+ */
+struct NanDataPathCfg {
+  /**
+   * Indicates whether to use Security/No Security.
+   */
+  bool useSecurity;
+  /**
+   * Indicating whether to use QOS/No QOS.
+   */
+  bool useQos;
+};
+
+/**
+ * Indicates the availability interval duration associated with the
+ * Availability Intervals Bitmap field
+ */
+enum NanAvailDuration : uint32_t {
+  DURATION_16MS = 0,
+  DURATION_32MS = 1,
+  DURATION_64MS = 2,
+};
+
+/**
+ * Possible connection types in Post NAN Discovery attributes.
+ */
+enum NanConnectionType : uint32_t {
+  WLAN_INFRA = 0,
+  P2P_OPER = 1,
+  WLAN_IBSS = 2,
+  WLAN_MESH = 3,
+  FURTHER_SERVICE_AVAILABILITY = 4,
+  WLAN_RANGING = 5,
+};
+
+/**
+ * Possible device roles in Post NAN Discovery attributes.
+ */
+enum NanDeviceRole : uint32_t {
+  WLAN_INFRA_AP = 0,
+  WLAN_INFRA_STA = 1,
+  P2P_OPER_GO = 2,
+  P2P_OPER_DEV = 3,
+  P2P_OPER_CLI = 4,
+};
+
+/**
+ * Data request Responder's response.
+ */
+enum NanDataPathResponseCode : uint32_t {
+  ACCEPT = 0,
+  REJECT,
+};
+
+/**
+ * Further availability per channel information.
+ */
+struct NanFurtherAvailabilityChannel {
+  /**
+   * Defined above.
+   */
+  NanAvailDuration entryControl;
+  /**
+   * 1 byte field indicating the frequency band the NAN Device
+   * must be available as defined in IEEE Std. 802.11-2012
+   * Annex E Table E-4 Global Operating Classes
+   */
+  uint8_t classVal;
+  /**
+   * 1 byte field indicating the channel the NAN Device
+   * must be available.
+   */
+  uint8_t channel;
+  /**
+   * Map Id - 4 bit field which identifies the Further
+   * availability map attribute.
+   */
+  uint8_t mapid;
+  /**
+   * Divides the time between the beginnings of consecutive "Discovery
+   * Windows" of a given NAN cluster into consecutive time intervals
+   * of equal durations. The time interval duration is specified by
+   * the |entryControl| field.
+   * A  device that sets the i-th bit of the Availability
+   * Intervals Bitmap to 1 shall be present during the corresponding
+   * i-th time interval in the operation channel indicated by the
+   * Operating Class and Channel Number fields in the same Availability Entry.
+   * A  device that sets the i-th bit of the Availability Intervals Bitmap to
+   * 0 may be present during the corresponding i-th time interval in the operation
+   * channel indicated by the Operating Class and Channel Number fields in the same
+   * Availability Entry.
+   * The size of the Bitmap is dependent upon the Availability Interval Duration
+   * Chosen in the Entry Control Field.  The size can be either 1, 2 or 4 bytes long
+   * - Duration field is equal to 0, only AIB[0] is valid
+   * - Duration field is equal to 1, only AIB [0] and AIB [1] is valid
+   * - Duration field is equal to 2, AIB [0], AIB [1], AIB [2] and AIB [3] are valid
+   */
+  uint32_t availIntervalBitmap;
+};
+
+/**
+ * NAN Publish Types.
+ */
+enum NanPublishType : uint32_t {
+  UNSOLICITED = 0,
+  SOLICITED,
+  UNSOLICITED_SOLICITED,
+};
+
+/**
+ * NAN Transmit Priorities.
+ */
+enum NanTxPriority : uint32_t {
+  NORMAL = 0,
+  HIGH,
+};
+
+/**
+ * NAN Transmit Types.
+ */
+enum NanTxType : uint32_t {
+  BROADCAST = 0,
+  UNICAST,
+};
+
+/**
+ * NAN Subscribe Type.
+ */
+enum NanSubscribeType : uint32_t {
+  PASSIVE = 0,
+  ACTIVE,
+};
+
+/**
+ * NAN Service Response Filter Attribute Bit.
+ */
+enum NanSrfType : uint32_t {
+  BLOOM_FILTER = 0,
+  PARTIAL_MAC_ADDR,
+};
+
+/**
+ * NAN Service Response Filter Include Bit.
+ */
+enum NanSrfIncludeType : uint32_t {
+  DO_NOT_RESPOND = 0,
+  RESPOND,
+};
+
+/**
+ * NAN Match indication type.
+ */
+enum NanMatchAlg : uint32_t {
+  MATCH_ONCE = 0,
+  MATCH_CONTINUOUS,
+  MATCH_NEVER,
+};
+
+/**
+ * NAN Transmit Window Type.
+ */
+enum NanTransmitWindowType : uint32_t {
+  DW = 0,
+  FAW,
+};
+
+/**
+ * NAN DP channel config options.
+ */
+enum NanDataPathChannelCfg : uint32_t {
+  CHANNEL_NOT_REQUESTED = 0,
+  REQUEST_CHANNEL_SETUP,
+  FORCE_CHANNEL_SETUP,
+};
+
+/**
+ * Host can send Vendor specific attributes which the Discovery Engine can
+ * enclose in Beacons and/or Service Discovery frames transmitted.
+ * Below structure is used to populate that.
+ * TODO(b/32207606): This can be moved to vendor extension.
+ */
+struct NanTransmitVendorSpecificAttribute {
+  /**
+   * 0 = transmit only in the next discovery window
+   * 1 = transmit in next 16 discovery window
+   */
+  uint8_t payloadTransmitFlag;
+  /**
+   * Below flags must determine in which all frames
+   * the vendor specific attributes must be included
+   */
+  uint8_t txInDiscoveryBeacon;
+  uint8_t txInSyncBeacon;
+  uint8_t txInServiceDiscovery;
+  /**
+   * Organizationally Unique Identifier.
+   */
+  uint32_t vendorOui;
+  /**
+   * Vendor specific attribute to be transmitted.
+   * Max length: |MAX_VSA_DATA_LEN|.
+   */
+  vec<uint8_t> vsa;
+};
+
+/**
+ * Host can set the Periodic scan parameters for each of the
+ * 3(6, 44, 149) Social channels. Only these channels are allowed
+ * any other channels are rejected
+ */
+ enum NanChannelIndex : uint32_t {
+  CHANNEL_24G_BAND = 0,
+  CHANNEL_5G_BAND_LOW,
+  CHANNEL_5G_BAND_HIGH,
+};
+
+/**
+ * Structure to set the Social Channel Scan parameters
+ * passed as part of EnableRequest/ConfigRequest.
+ */
+struct NanSocialChannelScanParams {
+  /**
+   * Dwell time of each social channel in milliseconds
+   * ChannelIndex corresponds to the respective channel
+   * If time set to 0 then the FW default time must be used.
+   * Max length: |MAX_SOCIAL_CHANNELS|.
+   * dwellTime[i] refers to the dwell time of the i'th social channel.
+   */
+  vec<uint8_t> dwellTime;
+  /**
+   * Scan period of each social channel in seconds
+   * ChannelIndex corresponds to the respective channel
+   * If time set to 0 then the FW default time must be used.
+   * Max length: |MAX_SOCIAL_CHANNELS|.
+   * scanPeriod[i] refers to the scan period of the i'th social channel.
+   */
+  vec<uint16_t> scanPeriod;
+};
+
+/**
+ * Enable Request Message Structure
+ * The EnableReq message in  structs the Discovery Engine to enter an operational state
+ */
+struct NanEnableRequest {
+  /**
+   * Mandatory parameters below.
+   */
+  uint8_t masterPref;
+  /**
+   * A cluster_low value matching cluster_high indicates a request to join
+   * a cluster with that value. If the requested cluster is not found the
+   * device must start its own cluster.
+   */
+  uint16_t clusterLow;
+  uint16_t clusterHigh;
+  /**
+   * Optional configuration of Enable request.
+   * Each of the optional parameters have configure flag which
+   * determine whether configuration is to be passed or not.
+   */
+  bool validSupport5gVal;
+  uint8_t support5gVal;
+  /**
+   * BIT 0 is used to specify to include Service IDs in Sync/Discovery beacons
+   * 0 - Do not include SIDs in any beacons
+   * 1 - Include SIDs in all beacons.
+   * Rest 7 bits are count field which allows control over the number of SIDs
+   * included in the Beacon.  0 means to include as many SIDs that fit into
+   * the maximum allow Beacon frame size
+   */
+  bool validSidBeaconVal;
+  uint8_t sidBeaconVal;
+  /**
+   * The rssi values below must be specified without sign.
+   * For eg: -70dBm must be specified as 70.
+   */
+  bool valid2dot4gRssiCloseVal;
+  uint8_t rssiClose2dot4gVal;
+  bool valid2dot4gRssiMiddleVal;
+  uint8_t rssiMiddle2dot4gVal;
+  bool valid2dot4gRssiProximityVal;
+  uint8_t rssiProximity2dot4gVal;
+  bool validHopCountLimitVal;
+  uint8_t hopCountLimitVal;
+  /**
+   * Defines 2.4G channel access support
+   */
+  bool valid2dot4gSupportVal;
+  bool support2dot4gVal;
+  /**
+   * Defines 2.4G channels must be used for sync/discovery beacons
+   */
+  bool valid2dot4gBeaconsVal;
+  bool beacon2dot4gVal;
+  /**
+   * Defines 2.4G channels must be used for Service Discovery frames
+   */
+  bool valid2dot4gSdfVal;
+  bool sdf2dot4gVal;
+  /**
+   * Defines 5G channels must be used for sync/discovery beacons
+   */
+  bool valid5gBeaconsVal;
+  bool beacon5gVal;
+  /**
+   * Defines 5G channels must be used for Service Discovery frames
+   */
+  bool valid5gSdfVal;
+  bool sdf5gVal;
+  /**
+   * 1 byte value which defines the RSSI in
+   * dBm for a close by Peer in 5 Ghz channels.
+   * The rssi values must be specified without sign.
+   * For eg: -70dBm must be specified as 70.
+   */
+  bool valid5gRssiCloseVal;
+  uint8_t rssiClose5gVal;
+  /**
+   * 1 byte value which defines the RSSI value in
+   * dBm for a close by Peer in 5 Ghz channels.
+   * The rssi values must be specified without sign.
+   * For eg: -70dBm must be specified as 70.
+   */
+  bool valid5gRssiMiddleVal;
+  uint8_t rssiMiddle5gVal;
+  /**
+   * 1 byte value which defines the RSSI filter
+   * threshold.  Any Service Descriptors received above this
+   * value that are configured for RSSI filtering must be dropped.
+   * The rssi values must be specified without sign.
+   * For eg: -70dBm must be specified as 70.
+   */
+  bool valid5gRssiCloseProximityVal;
+  uint8_t rssiCloseProximity5gVal;
+  /**
+   * 1 byte quantity which defines the window size over
+   * which the “average RSSI” must be calculated over.
+   */
+  bool validRssiWindowSizeVal;
+  uint8_t rssiWindowSizeVal;
+  /**
+   * The 24 bit Organizationally Unique ID + the 8 bit Network Id.
+   */
+  uint8_t validOuiVal;
+  uint32_t ouiVal;
+  /**
+   * NAN Interface Address, If not configured the Discovery Engine
+   * must generate a 6 byte Random MAC.
+   */
+  bool validIntfAddrVal;
+  MacAddress intfAddrVal;
+  /**
+   * If set to true, the Discovery Engine must enclose the Cluster
+   * Attribute only sent in Beacons in a Vendor Specific Attribute
+   * and transmit in a Service Descriptor Frame.
+   */
+  bool configClusterAttributeVal;
+  /**
+   * The periodicity in seconds between full scan’s to find any new
+   * clusters available in the area. A Full scan must not be done
+   * more than every 10 seconds and must not be done less than every
+   * 30 seconds.
+   */
+  bool validScanParamsVal;
+  NanSocialChannelScanParams scanParamsVal;
+  /**
+   * 1 byte quantity which forces the Random Factor to a particular
+   * value for all transmitted Sync/Discovery beacons
+   */
+  bool validRandomFactorForceVal;
+  uint8_t randomFactorForceVal;
+  /**
+   * 1 byte quantity which forces the HC for all transmitted Sync and
+   * Discovery Beacon NO matter the real HC being received over the
+   * air.
+   */
+  bool validHopCountForceVal;
+  uint8_t hopCountForceVal;
+  /**
+   * Channel frequency in MHz to enable  on.
+   */
+  bool valid24gChannelVal;
+  WifiChannelInMhz channel24gVal;
+  bool valid5gChannelVal;
+  WifiChannelInMhz channel5gVal;
+};
+
+
+/**
+ * Publish Msg Structure
+ * Message is used to request the DE to publish the Service Name
+ * using the parameters passed into the "Discovery Window".
+ */
+struct NanPublishRequest {
+  /**
+   * Id  0 means new publish, any other id is existing publish.
+   */
+  uint16_t publishId;
+  /**
+   * How many seconds to run for. 0 means forever until canceled.
+   */
+  uint16_t ttl;
+  /**
+   * Periodicity of OTA unsolicited publish. Specified in increments of 500 ms.
+   */
+  uint16_t period;
+  /**
+   * 0= unsolicited, solicited = 1, 2= both.
+   */
+  NanPublishType publishType;
+  /**
+   * 0 = broadcast, 1= unicast  if solicited publish.
+   */
+  NanTxType txType;
+  /**
+   * Number of OTA Publish, 0 means forever until canceled.
+   */
+  uint8_t publishCount;
+  /**
+   * UTF-8 encoded string identifying the service.
+   * Max length: |MAX_SERVICE_NAME_LEN|.
+   */
+  string serviceName;
+  /**
+   * Field which specifies how the matching indication to host is controlled.
+   * 0 - Match and Indicate Once
+   * 1 - Match and Indicate continuous
+   * 2 - Match and Indicate never. This means don't indicate the match to
+   *     the host.
+   * 3 - Reserved
+   */
+  NanMatchAlg publishMatchIndicator;
+  /**
+   * Sequence of values NAN Device that has invoked a Subscribe method
+   * corresponding to this Publish method.
+   * Max length: |MAX_SERVICE_SPECIFIC_INFO_LEN|.
+   */
+  vec<uint8_t> serviceSpecificInfo;
+  /**
+   * Ordered sequence of <length, value> pairs which specify further response conditions
+   * beyond the service name used to filter subscribe messages to respond to.
+   * This is only needed when the PT is set to SOLICITED or SOLICITED_UNSOLICITED.
+   * Max length: |MAX_MATCH_FILTER_LEN|.
+   */
+  vec<uint8_t> rxMatchFilter;
+  /**
+   * Ordered sequence of <length, value> pairs to be included in the Discovery Frame.
+   * If present it is always sent in a Discovery Frame
+   * Max length: |MAX_MATCH_FILTER_LEN|.
+   */
+  vec<uint8_t> txMatchFilter;
+  /**
+   * Flag which specifies that the Publish must use the configured RSSI
+   * threshold and the received RSSI in order to filter requests
+   * false – ignore the configured RSSI threshold when running a Service
+   * Descriptor attribute or Service ID List Attribute through the DE matching logic.
+   * true – use the configured RSSI threshold when running a Service
+   * Descriptor attribute or Service ID List Attribute through the DE matching logic.
+   */
+  bool useRssiThreshold;
+  /**
+   * 8-bit bitmap which allows the Host to associate this publish
+   * with a particular Post-NAN Connectivity attribute
+   * which has been sent down in a ConfigureRequest/EnableRequest
+   * message.  If the DE fails to find a configured Post-NAN
+   * connectivity attributes referenced by the bitmap,
+   * the DE must return an error code to the Host.
+   * If the Publish is configured to use a Post-NAN Connectivity
+   * attribute and the Host does not refresh the Post-NAN Connectivity
+   * attribute the Publish must be canceled and the Host must be sent
+   * a PublishTerminatedIndication message.
+   */
+  uint8_t connmap;
+  /**
+   * Set/Enable corresponding bits to disable any indications that follow a publish.
+   * BIT0 - Disable publish termination indication.
+   * BIT1 - Disable match expired indication.
+   * BIT2 - Disable followUp indication received (OTA).
+   */
+  uint8_t recvIndicationCfg;
+};
+
+/**
+ * Publish Cancel Msg Structure.
+ * The PublishServiceCancelReq Message is used to request the DE to stop publishing
+ * the Service Name identified by the Publish Id in the message.
+ */
+struct NanPublishCancelRequest {
+  uint16_t publishId;
+};
+
+/**
+ * NAN Subscribe Structure.
+ * The SubscribeServiceReq message is sent to the Discovery Engine
+ * whenever the Upper layers would like to listen for a Service Name
+ */
+struct NanSubscribeRequest {
+  /**
+   * Id 0 means new subscribe, non zero is existing subscribe.
+   */
+  uint16_t subscribeId;
+  /**
+   * How many seconds to run for. 0 means forever until canceled.
+   */
+  uint16_t ttl;
+  /**
+   * Periodicity of OTA Active Subscribe. Units in increments of 500 ms,
+   * 0 = attempt every DW.
+   */
+  uint16_t period;
+  /**
+   * Flag which specifies how the Subscribe request shall be processed.
+   * 0 - PASSIVE , 1- ACTIVE.
+   */
+  NanSubscribeType subscribeType;
+  /**
+   * Flag which specifies on Active Subscribes how the Service Response Filter
+   * attribute is populated.
+   * 0 - Bloom Filter, 1 - MAC Addr.
+   */
+  NanSrfType serviceResponseFilter;
+  /**
+   * Flag which specifies how the Service Response Filter Include bit is
+   * populated.
+   * 0=Do not respond if in the Address Set, 1= Respond.
+   */
+  NanSrfIncludeType serviceResponseInclude;
+  /**
+   * Flag which specifies if the Service Response Filter must be used when
+   * creating Subscribes.
+   * 0=Do not send the Service Response Filter,1= send.
+   */
+  bool shouldUseServiceResponseFilter;
+  /**
+   * Flag which specifies if the Service Specific Info is needed in
+   * the Publish message before creating the MatchIndication.
+   * 0=Not needed, 1= Required.
+   */
+  bool isSsiRequiredForMatchIndication;
+  /**
+   * Field which specifies how the matching indication to host is controlled.
+   * 0 - Match and Indicate Once
+   * 1 - Match and Indicate continuous
+   * 2 - Match and Indicate never. This means don't indicate the match to the
+   *     host.
+   * 3 - Reserved
+   */
+  NanMatchAlg subscribeMatchIndicator;
+  /**
+   * The number of Subscribe Matches which must occur
+   * before the Subscribe request is automatically terminated.
+   * If this value is 0 this field is not used by the DE.
+   */
+  uint8_t subscribeCount;
+  /**
+   * UTF-8 encoded string identifying the service.
+   * Max length: |MAX_SERVICE_NAME_LEN|.
+   */
+  string serviceName;
+  /**
+   * Sequence of values which further specify the published service beyond the
+   * service name.
+   * Max length: |MAX_SERVICE_SPECIFIC_INFO_LEN|.
+   */
+  vec<uint8_t> serviceSpecificInfo;
+  /**
+   * Ordered sequence of <length, value> pairs used to filter out received
+   * publish discovery messages.
+   * This can be sent both for a Passive or an Active Subscribe
+   * Max length: |MAX_MATCH_FILTER_LEN|.
+   */
+  vec<uint8_t> rxMatchFilter;
+  /**
+   * Ordered sequence of <length, value> pairs  included in the
+   * Discovery Frame when an Active Subscribe is used.
+   * Max length: |MAX_MATCH_FILTER_LEN|.
+   */
+  vec<uint8_t> txMatchFilter;
+  /**
+   * Flag which specifies that the Publish must use the configured RSSI
+   * threshold and the received RSSI in order to filter requests
+   * false – ignore the configured RSSI threshold when running a Service
+   * Descriptor attribute or Service ID List Attribute through the DE matching logic.
+   * true – use the configured RSSI threshold when running a Service
+   * Descriptor attribute or Service ID List Attribute through the DE matching logic.
+   */
+  bool useRssiThreshold;
+  /**
+   * 8-bit bitmap which allows the Host to associate this Active
+   * Subscribe with a particular Post-NAN Connectivity attribute
+   * which has been sent down in a ConfigureRequest/EnableRequest
+   * message.  If the DE fails to find a configured Post-NAN
+   * connectivity attributes referenced by the bitmap,
+   * the DE must return an error code to the Host.
+   * If the Subscribe is configured to use a Post-NAN Connectivity
+   * attribute and the Host does not refresh the Post-NAN Connectivity
+   * attribute the Subscribe must be canceled and the Host must be sent
+   * a SubscribeTerminatedIndication message.
+   */
+  uint8_t connmap;
+  /**
+   * NAN Interface Address, conforming to the format as described in
+   * 8.2.4.3.2 of IEEE Std. 802.11-2012.
+   * Max length: |MAX_SUBSCRIBE_MAX_ADDRESS|.
+   */
+  vec<MacAddress> intfAddr;
+  /**
+   * Set/Enable corresponding bits to disable indications that follow a
+   * subscribe.
+   * BIT0 - Disable subscribe termination indication.
+   * BIT1 - Disable match expired indication.
+   * BIT2 - Disable followUp indication received (OTA).
+   */
+  uint8_t recvIndicationCfg;
+};
+
+/**
+ * NAN Subscribe Cancel Structure
+ * The SubscribeCancelReq Message is used to request the DE to stop looking
+ * for the Service Name.
+ */
+struct NanSubscribeCancelRequest {
+  uint16_t subscribeId;
+};
+
+/**
+ * Transmit follow up Structure.
+ * The TransmitFollowupReq message is sent to the DE to allow the sending of
+ * the Service_Specific_Info to a particular MAC address.
+ */
+struct NanTransmitFollowupRequest {
+  /**
+   * Publish or Subscribe Id of an earlier Publish/Subscribe.
+   */
+  uint16_t publishSubscribeId;
+  /**
+   * This Id is the Requestor Instance that is passed as
+   * part of earlier MatchInd/FollowupInd message.
+   */
+  uint32_t requestorInstanceId;
+  /**
+   * Unicast address.
+   */
+  MacAddress addr;
+  /**
+   * Priority of the request 2=high.
+   */
+  NanTxPriority priority;
+  /**
+   * Flag which the DE uses to decide if received in a DW or a FAW
+   * 0= send in a DW, 1=send in FAW.
+   */
+  NanTransmitWindowType dwOrFaw;
+  /**
+   * Sequence of values which further specify the published service beyond
+   * the service name.
+   * Max length: |MAX_SERVICE_SPECIFIC_INFO_LEN|.
+   */
+  vec<uint8_t> serviceSpecificInfo;
+  /**
+   * Set/Enable corresponding bits to disable responses after followUp.
+   * BIT0 - Disable followUp response from FW.
+   */
+  uint8_t recvIndicationCfg;
+};
+
+/**
+ * Config Structure.
+ * The ConfigurationReq message is sent by the Host to the
+ * Discovery Engine in order to configure the Discovery Engine during runtime.
+ */
+struct NanConfigRequest {
+  bool validSidBeaconVal;
+  uint8_t sidBeacon;
+  bool validRssiProximityVal;
+  uint8_t rssiProximity;
+  bool validMasterPrefVal;
+  uint8_t masterPref;
+  /**
+   * 1 byte value which defines the RSSI filter threshold.
+   * Any Service Descriptors received above this value
+   * that are configured for RSSI filtering must be dropped.
+   * The rssi values must be specified without sign.
+   * For eg: -70dBm must be specified as 70.
+   */
+  bool valid5gRssiCloseProximityVal;
+  uint8_t rssiCloseProximity5gVal;
+  /**
+   * 2 byte quantity which defines the window size over
+   * which the “average RSSI” must be calculated over.
+   */
+  bool validRssiWindowSizeVal;
+  uint16_t rssiWindowSizeVal;
+  /**
+   * If set to 1, the Discovery Engine must enclose the Cluster
+   * Attribute only sent in Beacons in a Vendor Specific Attribute
+   * and transmit in a Service Descriptor Frame.
+   */
+  bool configClusterAttributeVal;
+  /**
+   * The periodicity in seconds between full scan’s to find any new
+   * clusters available in the area.  A Full scan must not be done
+   * more than every 10 seconds and must not be done less than every
+   * 30 seconds.
+   */
+  bool validScanParamsVal;
+  NanSocialChannelScanParams scanParamsVal;
+  /**
+   * 1 byte quantity which forces the Random Factor to a particular
+   * value for all transmitted Sync/Discovery beacons
+   */
+  bool validRandomFactorForceVal;
+  uint8_t randomFactorForceVal;
+  /**
+   * 1 byte quantity which forces the HC for all transmitted Sync and
+   * Discovery Beacon NO matter the real HC being received over the
+   * air.
+   */
+  bool validHopCountForceVal;
+  uint8_t hopCountForceVal;
+};
+
+/**
+ * Beacon Sdf Payload Structure
+ * The Discovery Engine can be configured to publish vendor specific attributes as part of
+ * beacon or service discovery frame transmitted as part of this request..
+ */
+struct NanBeaconSdfPayloadRequest {
+  /**
+   * VendorAttribute must have the Vendor Specific Attribute which the
+   * vendor wants to publish as part of Discovery or Sync or Service discovery frame
+   */
+  NanTransmitVendorSpecificAttribute vsa;
+};
+
+/**
+ *  Data Path Initiator requesting a data session.
+ */
+struct NanDataPathInitiatorRequest {
+  /**
+   * Unique Instance Id identifying the Responder's service.
+   * This is same as publish_id notified on the subscribe side
+   * in a publish/subscribe scenario
+   */
+  uint32_t serviceInstanceId;
+  /**
+   * Config flag for channel request.
+   */
+  NanDataPathChannelCfg channelRequestType;
+  /**
+   * Channel frequency in MHz to start data-path.
+   */
+  WifiChannelInMhz channel;
+  /**
+   * Discovery MAC addr of the publisher/peer.
+   */
+  MacAddress peerDiscMacAddr;
+  /**
+   * Interface name on which this NDP session is to be started.
+   * This must be the same interface name provided during interface
+   * create.
+   */
+  string ndpIface;
+  /**
+   * Initiator/Responder Security/QoS configuration.
+   */
+  NanDataPathCfg ndpCfg;
+  /**
+   * App/Service information of the Initiator.
+   */
+  NanDataPathAppInfo appInfo;
+};
+
+/**
+ * Data struct Nanto initiate a data response on the responder side
+ * for an indication received with a data request.
+ */
+struct NanDataPathIndicationResponse {
+  /**
+   * Unique token Id generated on the initiator/responder
+   * side used for a NDP session between two NAN devices.
+   */
+  NanDataPathId ndpInstanceId;
+  /**
+   * Interface name on which this NDP session is to be started.
+   * This must be the same interface name provided during interface
+   * create.
+   */
+  string ndpIface;
+  /**
+   * Initiator/Responder Security/QoS configuration.
+   */
+  NanDataPathCfg ndpCfg;
+  /**
+   * App/Service information of the responder.
+   */
+  NanDataPathAppInfo appInfo;
+  /**
+   * Response Code indicating ACCEPT/REJECT/DEFER
+   */
+  NanDataPathResponseCode rspCode;
+};
+
+/**
+ * NDP termination info.
+ */
+struct NanDataPathEndRequest {
+  uint8_t numNdpInstances;
+  /**
+   * Unique token Id generated on the initiator/responder side
+   * used for a NDP session between two NAN devices
+   */
+  vec<NanDataPathId> ndpInstanceIds;
+};
+
+/**
+ * Definition of various ResponseType
+ */
+enum NanResponseType : uint32_t  {
+  ENABLED = 0,
+  DISABLED = 1,
+  PUBLISH = 2,
+  PUBLISH_CANCEL = 3,
+  TRANSMIT_FOLLOWUP = 4,
+  SUBSCRIBE = 5,
+  SUBSCRIBE_CANCEL = 6,
+  CONFIG = 8,
+  ERROR = 10,
+  BEACON_SDF_PAYLOAD = 11,
+  GET_CAPABILITIES = 12,
+  DP_INTERFACE_CREATE = 13,
+  DP_INTERFACE_DELETE = 14,
+  DP_INITIATOR_RESPONSE = 15,
+  DP_RESPONDER_RESPONSE = 16,
+  DP_END = 17,
+};
+
+/**
+ * Various NAN Protocol Response code
+ */
+enum NanStatusType : uint32_t {
+  /* NAN Protocol Response Codes */
+  SUCCESS = 0,
+  TIMEOUT = 1,
+  DE_FAILURE = 2,
+  INVALID_MSG_VERSION = 3,
+  INVALID_MSG_LEN = 4,
+  INVALID_MSG_ID = 5,
+  INVALID_HANDLE = 6,
+  NO_SPACE_AVAILABLE = 7,
+  INVALID_PUBLISH_TYPE = 8,
+  INVALID_TX_TYPE = 9,
+  INVALID_MATCH_ALGORITHM = 10,
+  DISABLE_IN_PROGRESS = 11,
+  INVALID_TLV_LEN = 12,
+  INVALID_TLV_TYPE = 13,
+  MISSING_TLV_TYPE = 14,
+  INVALID_TOTAL_TLVS_LEN = 15,
+  INVALID_MATCH_HANDLE = 16,
+  INVALID_TLV_VALUE = 17,
+  INVALID_TX_PRIORITY = 18,
+  INVALID_CONNECTION_MAP = 19,
+  NOT_ALLOWED = 22,
+  NO_OTA_ACK = 23,
+  TX_FAIL = 24,
+  ALREADY_ENABLED = 25,
+  FOLLOWUP_QUEUE_FULL = 26,
+
+  /* NAN Configuration Response codes */
+  INVALID_RSSI_CLOSE_VALUE = 4096,
+  INVALID_RSSI_MIDDLE_VALUE = 4097,
+  INVALID_HOP_COUNT_LIMIT = 4098,
+  INVALID_MASTER_PREFERENCE_VALUE = 4099,
+  INVALID_LOW_CLUSTER_ID_VALUE = 4100,
+  INVALID_HIGH_CLUSTER_ID_VALUE = 4101,
+  INVALID_BACKGROUND_SCAN_PERIOD = 4102,
+  INVALID_RSSI_PROXIMITY_VALUE = 4103,
+  INVALID_SCAN_CHANNEL = 4104,
+  INVALID_POST_CONNECTIVITY_CAPABILITIES_BITMAP = 4105,
+  INVALID_FURTHER_AVAILABILITY_MAP_NUMCHAN_VALUE = 4106,
+  INVALID_FURTHER_AVAILABILITY_MAP_DURATION_VALUE = 4107,
+  INVALID_FURTHER_AVAILABILITY_MAP_CLASS_VALUE = 4108,
+  INVALID_FURTHER_AVAILABILITY_MAP_CHANNEL_VALUE = 4109,
+  INVALID_FURTHER_AVAILABILITY_MAP_AVAILABILITY_INTERVAL_BITMAP_VALUE = 4110,
+  INVALID_FURTHER_AVAILABILITY_MAP_MAP_ID = 4111,
+  INVALID_POST_DISCOVERY_CONN_TYPE_VALUE = 4112,
+  INVALID_POST_DISCOVERY_DEVICE_ROLE_VALUE = 4113,
+  INVALID_POST_DISCOVERY_DURATION_VALUE = 4114,
+  INVALID_POST_DISCOVERY_BITMAP_VALUE = 4115,
+  MISSING_FUTHER_AVAILABILITY_MAP = 4116,
+  INVALID_BAND_CONFIG_FLAGS = 4117,
+  INVALID_RANDOM_FACTOR_UPDATE_TIME_VALUE = 4118,
+  INVALID_ONGOING_SCAN_PERIOD = 4119,
+  INVALID_DW_INTERVAL_VALUE = 4120,
+  INVALID_DB_INTERVAL_VALUE = 4121,
+
+  /* 4122-8191 RESERVED */
+  TERMINATED_REASON_INVALID = 8192,
+  TERMINATED_REASON_TIMEOUT = 8193,
+  TERMINATED_REASON_USER_REQUEST = 8194,
+  TERMINATED_REASON_FAILURE = 8195,
+  TERMINATED_REASON_COUNT_REACHED = 8196,
+  TERMINATED_REASON_DE_SHUTDOWN = 8197,
+  TERMINATED_REASON_DISABLE_IN_PROGRESS = 8198,
+  TERMINATED_REASON_POST_DISC_ATTR_EXPIRED = 8199,
+  TERMINATED_REASON_POST_DISC_LEN_EXCEEDED = 8200,
+  TERMINATED_REASON_FURTHER_AVAIL_MAP_EMPTY = 8201,
+
+  /* 9000-9500 NDP Status type */
+  NDP_UNSUPPORTED_CONCURRENCY = 9000,
+  NDP_DATA_IFACE_CREATE_FAILED = 9001,
+  NDP_DATA_IFACE_DELETE_FAILED = 9002,
+  NDP_DATA_INITIATOR_REQUEST_FAILED = 9003,
+  NDP_DATA_RESPONDER_REQUEST_FAILED = 9004,
+  NDP_INVALID_SERVICE_INSTANCE_ID = 9005,
+  NDP_INVALID_NDP_INSTANCE_ID = 9006,
+  NDP_INVALID_RESPONSE_CODE = 9007,
+  NDP_INVALID_APP_INFO_LEN = 9008,
+
+  /* OTA failures and timeouts during negotiation */
+  NDP_MGMT_FRAME_REQUEST_FAILED = 9009,
+  NDP_MGMT_FRAME_RESPONSE_FAILED = 9010,
+  NDP_MGMT_FRAME_CONFIRM_FAILED = 9011,
+  NDP_END_FAILED = 9012,
+  NDP_MGMT_FRAME_END_REQUEST_FAILED = 9013,
+
+  /* 9500 onwards vendor specific error codes */
+  NDP_VENDOR_SPECIFIC_ERROR = 9500,
+};
+
+/**
+ * NAN Response message header
+ */
+struct NanResponseMsgHeader {
+  /**
+   * Contains the result code.
+   */
+  NanStatusType status;
+  /**
+   * For error returns the value is returned which was in error.
+   * TODO(b/32207606): Find all the error values.
+   */
+  uint32_t value;
+  /**
+   * ResponseType Definitions.
+   */
+  NanResponseType responseType;
+};
+
+/**
+ * Publish Response Message structure.
+ */
+struct NanPublishResponse {
+  uint16_t publishId;
+};
+
+/**
+ * NAN Publish Response Messages.
+ */
+struct NanPublishResponseMsg {
+  NanResponseMsgHeader header;
+  NanPublishResponse body;
+};
+
+
+/**
+ * Subscribe Response Message structure.
+ */
+struct NanSubscribeResponse {
+  uint16_t subscribeId;
+};
+
+/**
+ * NAN Subscribe Response Messages.
+ */
+struct NanSubscribeResponseMsg {
+  NanResponseMsgHeader header;
+  NanSubscribeResponse body;
+};
+
+/**
+ * Response returned for Initiators Data request.
+ */
+struct NanDataPathResponse {
+  /**
+   * Unique token Id generated on the initiator
+   * side used for a NDP session between two NAN devices
+   */
+  NanDataPathId ndpInstanceId;
+};
+
+/**
+ * NAN Data Path Response Messages.
+ */
+struct NanDataPathResponseMsg {
+  NanResponseMsgHeader header;
+  NanDataPathResponse body;
+};
+
+/**
+ * NDP Capabilites response.
+ */
+struct NanCapabilitiesResponse {
+  uint32_t maxConcurrentClusters;
+  uint32_t maxPublishes;
+  uint32_t maxSubscribes;
+  uint32_t maxServiceNameLen;
+  uint32_t maxMatchFilterLen;
+  uint32_t maxTotalMatchFilterLen;
+  uint32_t maxServiceSpecificInfoLen;
+  uint32_t maxVsaDataLen;
+  uint32_t maxMeshDataLen;
+  uint32_t maxNdiInterfaces;
+  uint32_t maxNdpSessions;
+  uint32_t maxAppInfoLen;
+  uint32_t maxQueuedTransmitFollowupMsgs;
+};
+
+/**
+ * NAN Capabilities Response Messages.
+ */
+struct NanCapabilitiesResponseMsg {
+  NanResponseMsgHeader header;
+  NanCapabilitiesResponse body;
+};
+
+/**
+ * Publish Terminated Message structure.
+ * The PublishTerminatedInd message is sent by the DE whenever a Publish
+ * terminates from a user-specified timeout or a unrecoverable error in the DE.
+ */
+struct NanPublishTerminatedInd {
+  /**
+   * Id returned during the initial Publish.
+   */
+  uint16_t publishId;
+  NanStatusType reason;
+};
+
+/**
+ * Match Indication Message structure.
+ * The MatchInd message is sent once per responding MAC address whenever
+ * the Discovery Engine detects a match for a previous SubscribeServiceReq
+ * or PublishServiceReq.
+ */
+struct NanMatchInd {
+  /**
+   * Publish or Subscribe Id of an earlier Publish/Subscribe.
+   */
+  uint16_t publishSubscribeId;
+  /**
+   * A 32 bit Requestor Instance Id which is sent to the Application.
+   * This Id must be sent in any subsequent UnmatchInd/FollowupInd
+   * messages.
+   */
+  uint32_t requestorInstanceId;
+  MacAddress addr;
+  /**
+   * Sequence of octets which were received in a Discovery Frame matching the
+   * Subscribe Request.
+   * Max length: |MAX_SERVICE_SPECIFIC_INFO_LEN|.
+   */
+  vec<uint8_t> serviceSpecificInfo;
+  /**
+   * Ordered sequence of <length, value> pairs received in the Discovery Frame
+   * matching the Subscribe Request.
+   * Max length: |MAX_MATCH_FILTER_LEN|.
+   */
+  vec<uint8_t> sdfMatchFilter;
+  /**
+   * Flag to indicate if the Match occurred in a Beacon Frame or in a
+   * Service Discovery Frame.
+   */
+  bool matchOccuredFlag;
+  /**
+   * Flag to indicate FW is out of resource and that it can no longer
+   * track this Service Name. The Host still need to send the received
+   * Match_Handle but duplicate MatchInd messages may be received on
+   * this Handle until the resource frees up.
+   */
+  bool outOfResourceFlag;
+  /**
+   * If RSSI filtering was configured in SubscribeRequest then this
+   * field must contain the received RSSI value. 0 if not.
+   * All rssi values must be specified without sign.
+   * For eg: -70dBm must be specified as 70.
+   */
+  uint8_t rssiValue;
+};
+
+/**
+ * MatchExpired Indication Message structure.
+ * The MatchExpiredInd message is sent whenever the Discovery Engine detects that
+ * a previously Matched Service has been gone for too long. If the previous
+ * MatchInd message for this Publish/Subscribe Id had the out_of_resource_flag
+ * set then this message must not be received
+ */
+struct NanMatchExpiredInd {
+  /**
+   * Publish or Subscribe Id of an earlier Publish/Subscribe.
+   */
+  uint16_t publishSubscribeId;
+  /**
+   * 32 bit value sent by the DE in a previous
+   * MatchInd/FollowupInd to the application.
+   */
+  uint32_t requestorInstanceId;
+};
+
+/**
+ * Subscribe Terminated Message structure.
+ * The SubscribeTerminatedInd message is sent by the DE whenever a
+ * Subscribe terminates from a user-specified timeout or a unrecoverable error in the DE.
+ */
+struct NanSubscribeTerminatedInd {
+  /**
+   * Id returned during initial Subscribe.
+   */
+  uint16_t subscribeId;
+  NanStatusType reason;
+};
+
+/**
+ * Followup Indication Message structure.
+ * The FollowupInd message is sent by the DE to the Host whenever it receives a
+ * Followup message from another peer.
+ */
+struct NanFollowupInd {
+  /**
+   * Publish or Subscribe Id of an earlier Publish/Subscribe.
+   */
+  uint16_t publishSubscribeId;
+  /**
+   * A 32 bit Requestor instance Id which is sent to the Application.
+   * This Id must be used in subsequent UnmatchInd/FollowupInd messages.
+   */
+  uint32_t requestorInstanceId;
+  MacAddress addr;
+  /**
+   * Flag which the DE uses to decide if received in a DW or a FAW
+   * 0= send in a DW, 1=send in FAW.
+   */
+  NanTransmitWindowType dwOrFaw;
+  /**
+   * Sequence of values which further specify the published service beyond
+   * the service name
+   * Max length: |MAX_SERVICE_SPECIFIC_INFO_LEN|.
+   */
+  vec<uint8_t> serviceSpecificInfo;
+};
+
+/**
+ * NAN Protocol Event ID Codes.
+ */
+enum NanDiscEngEventType : uint32_t {
+  /**
+   * Event data notifying the Mac address of the Discovery engine.
+   * which is reported as one of the Discovery engine event
+   */
+  DISC_MAC_ADDR = 0,
+  /**
+   * Event data notifying the Cluster address of the cluster
+   * which is reported as one of the Discovery engine events.
+   */
+  STARTED_CLUSTER,
+  JOINED_CLUSTER,
+};
+
+/**
+ * Discovery Engine Event Indication Message structure.
+ * The Discovery Engine can inform the Host when significant events occur
+ * The data following the EventId is dependent upon the EventId type.
+ * In other words, each new event defined must carry a different
+ * structure of information back to the host.
+ */
+struct NanDiscEngEventInd {
+  /**
+   * NAN Protocol Event Codes.
+   */
+  NanDiscEngEventType eventType;
+  /**
+   * Mac Address associated with the corresponding event.
+   */
+  MacAddress addr;
+};
+
+/**
+ * NAN Disabled Indication Message structure.
+ * The DisableInd message indicates to the upper layers that the Discovery
+ * Engine has flushed all state and has been shutdown.  When this message is
+ * received the DE is guaranteed to have left the NAN cluster it was part of
+ * and must have terminated any in progress Publishes or Subscribes.
+ */
+struct NanDisabledInd {
+  NanStatusType reason;
+};
+
+/**
+ * Mask to determine on which frames attribute was received.
+ */
+enum NanVsaRxFrameMask: uint32_t {
+  DISCOVERY_BEACON_MASK = 1 << 0,
+  SYNC_BEACON_MASK = 1 << 1,
+  SERVICE_DISCOVERY_MASK = 1 << 2
+};
+
+struct NanReceiveVendorSpecificAttribute {
+  /**
+   * Frames on which this vendor specific attribute
+   * was received. Mask |NanVsaRxFrameMask| defined above.
+   */
+  uint8_t vsaReceivedOn;
+  /**
+   * Organizationally Unique Identifier.
+   */
+  uint32_t vendorOui;
+  /**
+   * Vendor specific attribute.
+   * Max length: |MAX_VSA_DATA_LEN|.
+   */
+  vec<uint8_t> vsa;
+};
+
+/**
+ * NAN Beacon SDF Payload Received Message structure.
+ * Discovery engine sends the details of received Beacon or
+ * Service Discovery Frames as part of this structure.
+ */
+struct NanBeaconSdfPayloadReceive {
+  /**
+   * Frame data.
+   * Max length: |MAX_FRAME_DATA_LEN|.
+   */
+  vec<uint8_t> frameData;
+};
+
+/**
+ * NAN Beacon or SDF Payload Indication Message structure.
+ * The BeaconSdfPayloadInd message indicates to the upper layers that information
+ * elements were received either in a Beacon or SDF which needs to be delivered
+ * outside of a Publish/Subscribe Handle.
+ */
+struct NanBeaconSdfPayloadInd {
+  /**
+   * The MAC address of the peer which sent the attributes.
+   */
+  MacAddress addr;
+  /**
+   * NAN Receive Vendor Specific Attribute.
+   */
+  bool isVsaReceived;
+  NanReceiveVendorSpecificAttribute vsa;
+  /**
+   * NAN Beacon or SDF Payload Received.
+   */
+  bool isBeaconSdfPayloadReceived;
+  NanBeaconSdfPayloadReceive data;
+};
+
+/**
+ * NAN Data path request Indication Message structure.
+ * Event indication received on the responder side when a Nan Data request or
+ * NDP session is initiated on the Initiator side.
+ */
+struct NanDataPathRequestInd {
+  /**
+   * Unique Instance Id corresponding to a service/session.
+   * This is similar to the publish_id generated on the
+   * publisher side.
+   */
+  uint16_t serviceInstanceId;
+  /**
+   * Discovery MAC addr of the peer/initiator.
+   */
+  MacAddress peerDiscMacAddr;
+  /**
+   * Unique token Id generated on the initiator/responder side
+   * used for a NDP session between two NAN devices.
+   */
+  NanDataPathId ndpInstanceId;
+  /**
+   * Initiator/Responder Security/QoS configuration.
+   */
+  NanDataPathCfg ndpCfg;
+  /**
+   * App/Service information of the initiator.
+   */
+  NanDataPathAppInfo appInfo;
+};
+
+/**
+ * NAN Data path confirmation Indication Message structure.
+ * Event indication of data confirm is received on both
+ * initiator and responder side confirming a NDP session.
+ */
+struct NanDataPathConfirmInd {
+  /**
+   * Unique token Id generated on the initiator/responder side
+   * used for a NDP session between two NAN devices
+   */
+  NanDataPathId ndpInstanceId;
+  /**
+   * NDI mac address of the peer.
+   * (required to derive target ipv6 address)
+   */
+  MacAddress peerNdiMacAddr;
+  /**
+   * App/Service information of Initiator/Responder.
+   */
+  NanDataPathAppInfo appInfo;
+  /**
+   * Response code indicating ACCEPT/REJECT/DEFER.
+   */
+  NanDataPathResponseCode rspCode;
+  /**
+   * Reason code indicating the cause for REJECT.
+   */
+  NanStatusType reasonCode;
+};
+
+/**
+ * NAN Data path end Indication Message structure.
+ * Event indication received on the initiator/responder side terminating
+ * a NDP session
+ */
+struct NanDataPathEndInd {
+  /**
+   * Unique token Id generated on the initiator/responder side
+   * used for a NDP session between two NAN devices
+   */
+  vec<NanDataPathId> ndpInstanceIds;
+};
+
+/**
+ * NAN Transmit followup Indication Message structure.
+ * Event Indication notifying the transmit followup in progress.
+ */
+struct NanTransmitFollowupInd {
+  CommandId cmdId;
+  NanStatusType reason;
+};
+
+/**
+ * RTT specific types.
+ * TODO(b/32159498): Move to a separate rtt_types.hal.
+ */
+/**
+ * Ranging status.
+ */
+enum RttStatus : uint32_t {
+  SUCCESS = 0,
+  /** General failure status */
+  FAILURE = 1,
+  /** Target STA does not respond to request */
+  FAIL_NO_RSP = 2,
+  /** Request rejected. Applies to 2-sided RTT only */
+  FAIL_REJECTED = 3,
+  FAIL_NOT_SCHEDULED_YET = 4,
+  /** Timing measurement times out */
+  FAIL_TM_TIMEOUT = 5,
+  /** Target on different channel, cannot range */
+  FAIL_AP_ON_DIFF_CHANNEL = 6,
+  /** Ranging not supported */
+  FAIL_NO_CAPABILITY = 7,
+  /** Request aborted for unknown reason */
+  ABORTED = 8,
+  /** Invalid T1-T4 timestamp */
+  FAIL_INVALID_TS = 9,
+  /** 11mc protocol failed */
+  FAIL_PROTOCOL = 10,
+  /** Request could not be scheduled */
+  FAIL_SCHEDULE = 11,
+  /** Responder cannot collaborate at time of request */
+  FAIL_BUSY_TRY_LATER = 12,
+  /** Bad request args */
+  INVALID_REQ = 13,
+  /** WiFi not enabled. */
+  NO_WIFI = 14,
+  /** Responder overrides param info, cannot range with new params */
+  FAIL_FTM_PARAM_OVERRIDE = 15,
+};
+
+/**
+ * RTT peer types.
+ */
+enum RttPeerType : uint32_t {
+  AP = 0x1,
+  STA = 0x2,
+  P2P_GO = 0x3,
+  P2P_CLIENT = 0x4,
+  NAN = 0x5,
+};
+
+/**
+ * RTT Measurement Bandwidth.
+ */
+enum RttBw : uint32_t {
+  BW_5MHZ = 0x01,
+  BW_10MHZ = 0x02,
+  BW_20MHZ = 0x04,
+  BW_40MHZ = 0x08,
+  BW_80MHZ = 0x10,
+  BW_160MHZ = 0x20,
+};
+
+/**
+ * RTT Measurement Preamble.
+ */
+enum RttPreamble : uint32_t {
+  LEGACY = 0x1,
+  HT = 0x2,
+  VHT = 0x4,
+};
+
+/**
+ * RTT Types.
+ */
+enum RttType : uint32_t {
+  ONE_SIDED = 0x1,
+  TWO_SIDED = 0x2,
+};
+
+/**
+ * RTT configuration.
+ */
+struct RttConfig {
+  /**
+   * Peer device mac address.
+   */
+  MacAddress addr;
+  /**
+   * 1-sided or 2-sided RTT.
+   */
+  RttType type;
+  /**
+   * Optional - peer device hint (STA, P2P, AP).
+   */
+  RttPeerType peer;
+  /**
+   * Required for STA-AP mode, optional for P2P, NBD etc.
+   */
+  WifiChannelInfo channel;
+  /**
+   * Time interval between bursts (units: 100 ms).
+   * Applies to 1-sided and 2-sided RTT multi-burst requests.
+   * Range: 0-31, 0: no preference by initiator (2-sided RTT).
+   */
+  uint32_t burstPeriod;
+  /**
+   * Total number of RTT bursts to be executed. It will be
+   * specified in the same way as the parameter "Number of
+   * Burst Exponent" found in the FTM frame format. It
+   * applies to both: 1-sided RTT and 2-sided RTT. Valid
+   * values are 0 to 15 as defined in 802.11mc std.
+   * 0 means single shot
+   * The implication of this parameter on the maximum
+   * number of RTT results is the following:
+   * for 1-sided RTT: max num of RTT results = (2^num_burst)*(num_frames_per_burst)
+   * for 2-sided RTT: max num of RTT results = (2^num_burst)*(num_frames_per_burst - 1)
+   */
+  uint32_t numBurst;
+  /**
+   * Num of frames per burst.
+   * Minimum value = 1, Maximum value = 31
+   * For 2-sided this equals the number of FTM frames
+   * to be attempted in a single burst. This also
+   * equals the number of FTM frames that the
+   * initiator will request that the responder send
+   * in a single frame.
+   */
+  uint32_t numFramesPerBurst;
+  /**
+   * Number of retries for a failed RTT frame.
+   * Applies to 1-sided RTT only. Minimum value = 0, Maximum value = 3
+   */
+  uint32_t numRetriesPerRttFrame;
+  /** Following fields are only valid for 2-side RTT. */
+  /**
+   * Maximum number of retries that the initiator can
+   * retry an FTMR frame.
+   * Minimum value = 0, Maximum value = 3
+   */
+  uint32_t numRetriesPerFtmr;
+  /**
+   * Whether to request location civic info or not.
+   */
+  bool mustRequestLci;
+  /**
+   * Whether to request location civic records or not.
+   */
+  bool mustRequestLcr;
+  /**
+   * Applies to 1-sided and 2-sided RTT. Valid values will
+   * be 2-11 and 15 as specified by the 802.11mc std for
+   * the FTM parameter burst duration. In a multi-burst
+   * request, if responder overrides with larger value,
+   * the initiator will return failure. In a single-burst
+   * request if responder overrides with larger value,
+   * the initiator will sent TMR_STOP to terminate RTT
+   * at the end of the burst_duration it requested.
+   */
+  uint32_t burstDuration;
+  /**
+   * RTT preamble to be used in the RTT frames.
+   */
+  RttPreamble preamble;
+  /**
+   * RTT BW to be used in the RTT frames.
+   */
+  RttBw bw;
+};
+
+/**
+ * RTT results.
+ */
+struct RttResult {
+  /**
+   * Peer device mac address.
+   */
+  MacAddress addr;
+  /**
+   * Burst number in a multi-burst request.
+   */
+  uint32_t burstNum;
+  /**
+   * Total RTT measurement frames attempted.
+   */
+  uint32_t measurementNumber;
+  /**
+   * Total successful RTT measurement frames.
+   */
+  uint32_t successNumber;
+  /**
+   * Maximum number of "FTM frames per burst" supported by
+   * the responder STA. Applies to 2-sided RTT only.
+   * If reponder overrides with larger value:
+   * - for single-burst request initiator will truncate the
+   * larger value and send a TMR_STOP after receiving as
+   * many frames as originally requested.
+   * - for multi-burst request, initiator will return
+   * failure right away.
+   */
+  uint8_t numberPerBurstPeer;
+  /**
+   * Ranging status.
+   */
+  RttStatus status;
+  /**
+   * When status == RTT_STATUS_FAIL_BUSY_TRY_LATER,
+   * this will be the time provided by the responder as to
+   * when the request can be tried again. Applies to 2-sided
+   * RTT only. In sec, 1-31sec.
+   */
+  uint8_t retryAfterDuration;
+  /**
+   * RTT type.
+   */
+  RttType type;
+  /**
+   * Average rssi in 0.5 dB steps e.g. 143 implies -71.5 dB.
+   */
+  Rssi rssi;
+  /**
+   * Rssi spread in 0.5 dB steps e.g. 5 implies 2.5 dB spread (optional).
+   */
+  Rssi rssiSpread;
+  /**
+   * 1-sided RTT: TX rate of RTT frame.
+   * 2-sided RTT: TX rate of initiator's Ack in response to FTM frame.
+   */
+  WifiRateInfo txRate;
+  /**
+   * 1-sided RTT: TX rate of Ack from other side.
+   * 2-sided RTT: TX rate of FTM frame coming from responder.
+   */
+  WifiRateInfo rxRate;
+  /**
+   * Round trip time in picoseconds
+   */
+  TimeSpanInPs rtt;
+  /**
+   * Rtt standard deviation in picoseconds.
+   */
+  TimeSpanInPs rttSd;
+  /**
+   * Difference between max and min rtt times recorded in picoseconds.
+   */
+  TimeSpanInPs rttSpread;
+  /**
+   * Distance in mm (optional).
+   */
+  int32_t distanceInMm;
+  /**
+   * Standard deviation in mm (optional).
+   */
+  int32_t distanceSdInMm;
+  /**
+   * Difference between max and min distance recorded in mm (optional).
+   */
+  int32_t distanceSpreadInMm;
+  /**
+   * Time of the measurement (in microseconds since boot).
+   */
+  TimeStampInUs timeStampInUs;
+  /**
+   * in ms, actual time taken by the FW to finish one burst
+   * measurement. Applies to 1-sided and 2-sided RTT.
+   */
+  uint32_t burstDurationInMs;
+  /**
+   * Number of bursts allowed by the responder. Applies
+   * to 2-sided RTT only.
+   */
+  uint32_t negotiatedBurstNum;
+  /**
+   * for 11mc only.
+   */
+  WifiInformationElement lci;
+  /**
+   * for 11mc only.
+   */
+  WifiInformationElement lcr;
+};
+
+/**
+ * NBD ranging channel map.
+ */
+struct RttChannelMap {
+  WifiChannelInMhz[32] availablity;
+};
+
+/**
+ * RTT Capabilities.
+ */
+struct RttCapabilities {
+  /**
+   * if 1-sided rtt data collection is supported.
+   */
+  bool rttOneSidedSupported;
+  /**
+   * if ftm rtt data collection is supported.
+   */
+  bool rttFtmSupported;
+  /**
+   * if initiator supports LCI request. Applies to 2-sided RTT.
+   */
+  bool lciSupported;
+  /**
+   * if initiator supports LCR request. Applies to 2-sided RTT.
+   */
+  bool lcrSupported;
+  /**
+   * if 11mc responder mode is supported.
+   */
+  bool responderSupported;
+  /**
+   * Bit mask indicates what preamble is supported by initiator.
+   * Combination of |RttPreamble| values.
+   */
+  uint8_t preambleSupport;
+  /**
+   * Bit mask indicates what BW is supported by initiator.
+   * Combination of |RttBw| values.
+   */
+  uint8_t bwSupport;
+  /**
+   * Draft 11mc spec version supported by chip.
+   * For instance, version 4.0 must be 40 and version 4.3 must be 43 etc.
+   */
+  uint8_t mcVersion;
+};
+
+/**
+ * Debugging definitions.
+ */
+enum RttDebugType : uint32_t {
+  DISABLE,
+  LOG,
+  PROTO,
+  BURST,
+  ACCURACY,
+  LOGDETAIL,
+};
+
+enum RttDebugFormat : uint32_t {
+  TXT,
+  BINARY,
+};
+
+/**
+ * Debug info.
+ */
+struct RttDebugInfo {
+  /**
+   * Version info.
+   */
+  uint32_t version;
+  /**
+   * Debug data type.
+   */
+  RttDebugType type;
+  /**
+   * Debug data format.
+   */
+  RttDebugFormat format;
+  /**
+   * Debug data content.
+   */
+  vec<uint8_t> data;
+};
+
+/**
+ * Structs for setting LCI/LCR information to be provided to a requestor.
+ */
+enum RttMotionPattern : uint32_t {
+  /**
+   * Not expected to change location.
+   */
+  NOT_EXPECTED = 0,
+  /**
+   * Expected to change location.
+   */
+  EXPECTED = 1,
+  /**
+   * Movement pattern unknown.
+   */
+  UNKNOWN = 2,
+};
+
+/**
+ * Movement pattern unknown.
+ */
+struct RttLciInformation {
+  /**
+   * latitude in degrees * 2^25 , 2's complement.
+   */
+  int64_t latitude;
+  /**
+   * longitude in degrees * 2^25 , 2's complement.
+   */
+  int64_t longitude;
+  /**
+   * Altitude in units of 1/256 m.
+   */
+  int32_t altitude;
+  /**
+   * As defined in Section 2.3.2 of IETF RFC 6225.
+   */
+  uint8_t latitudeUnc;
+  /**
+   * As defined in Section 2.3.2 of IETF RFC 6225.
+   */
+  uint8_t longitudeUnc;
+  /**
+   * As defined in Section 2.4.5 from IETF RFC 6225.
+   */
+  uint8_t altitudeUnc;
+  /** Following element for configuring the Z subelement. */
+  /**
+   * Motion pattern type.
+   */
+  RttMotionPattern motionPattern;
+  /**
+   * Floor in units of 1/16th of floor. 0x80000000 if unknown.
+   */
+  int32_t floor;
+  /**
+   * in units of 1/64 m.
+   */
+  int32_t heightAboveFloor;
+  /**
+   * in units of 1/64 m. 0 if unknown
+   */
+  int32_t heightUnc;
+};
+
+struct RttLcrInformation {
+  /**
+   * Country code symbol.
+   */
+  int8_t[2] countryCode;
+  /**
+   * Civic info to be copied in FTM frame.
+   */
+  string civicInfo;
+};
+
+/***
+ * RTT Responder information
+ */
+struct RttResponder {
+  WifiChannelInfo channel;
+  RttPreamble preamble;
+};
+
+/**
+ * Debug data specific types.
+ * TODO(b/32159498): Move to a separate debug_types.hal.
+ */
+typedef uint32_t WifiRingBufferId;
+
+/**
+ * Mask of flags present in |WifiDebugRingEntryHeader.flags| field.
+ */
+enum WifiDebugRingEntryFlags : uint8_t {
+  /**
+   * Set for binary entries
+   */
+  HAS_BINARY = 1 << 0,
+  /**
+   * Set if 64 bits timestamp is present
+   */
+  HAS_TIMESTAMP = 1 << 1,
+};
+
+/**
+ * This structure represent an entry within a debug ring buffer.
+ * Wifi driver are responsible to manage the debug ring buffer and write the
+ * debug information into those buffer.
+ *
+ * In general, the debug entries can be used to store meaningful 802.11
+ * information (SME, MLME, connection and packet statistics) as well as vendor
+ * proprietary data that is specific to a specific driver or chipset.
+ * Binary entries can be used so as to store packet data or vendor specific
+ * information and will be treated as blobs of data by android framework.
+ *
+ * A user land process will be started by framework so as to periodically
+ * retrieve the data logged by drivers into their debug ring buffer, store the
+ * data into log files and include the logs into android bugreports.
+ */
+struct WifiDebugRingEntryHeader {
+  /**
+   * The size of |payload| excluding the header.
+   */
+  uint16_t sizeInBytes;
+  /**
+   * Combination of |WifiDebugRingEntryFlags| values.
+   */
+  uint8_t flags;
+  /**
+   * Present if |HAS_TIMESTAMP| bit is set.
+   */
+  TimeStampInUs timestamp;
+};
+
+/**
+ * Below event types are used for both the connect and power event
+ * ring entries.
+ */
+enum WifiDebugRingEntryEventType : uint16_t {
+  /**
+   * Driver receives association command from kernel.
+   */
+  ASSOCIATION_REQUESTED = 0,
+  AUTH_COMPLETE = 1,
+  ASSOC_COMPLETE = 2,
+  /**
+   * Firmware event indicating auth frames are sent.
+   */
+  FW_AUTH_STARTED = 3,
+  /**
+   * Firmware event indicating assoc frames are sent.
+   */
+  FW_ASSOC_STARTED = 4,
+  /**
+   * Firmware event indicating reassoc frames are sent.
+   */
+  FW_RE_ASSOC_STARTED = 5,
+  DRIVER_SCAN_REQUESTED = 6,
+  DRIVER_SCAN_RESULT_FOUND = 7,
+  DRIVER_SCAN_COMPLETE = 8,
+  BACKGROUND_SCAN_STARTED = 9,
+  BACKGROUND_SCAN_COMPLETE = 10,
+  DISASSOCIATION_REQUESTED = 11,
+  RE_ASSOCIATION_REQUESTED = 12,
+  ROAM_REQUESTED = 13,
+  /**
+   * Received beacon from AP (event enabled  only in verbose mode).
+   */
+  BEACON_RECEIVED = 14,
+  /**
+   * Firmware has triggered a roam scan (not g-scan).
+   */
+  ROAM_SCAN_STARTED = 15,
+  /**
+   * Firmware has completed a roam scan (not g-scan).
+   */
+  ROAM_SCAN_COMPLETE = 16,
+  /**
+   * Firmware has started searching for roam candidates (with reason =xx).
+   */
+  ROAM_SEARCH_STARTED = 17,
+  /**
+   * Firmware has stopped searching for roam candidates (with reason =xx).
+   */
+  ROAM_SEARCH_STOPPED = 18,
+  /**
+   * Received channel switch anouncement from AP.
+   */
+  CHANNEL_SWITCH_ANOUNCEMENT = 20,
+  /**
+   * Firmware start transmit eapol frame, with  EAPOL index 1-4.
+   */
+  FW_EAPOL_FRAME_TRANSMIT_START = 21,
+  /**
+   * Firmware gives up eapol frame, with rate, success/failure and number
+   * retries.
+   */
+  FW_EAPOL_FRAME_TRANSMIT_STOP = 22,
+  /**
+   * Kernel queue EAPOL for transmission  in driver with EAPOL index 1-4.
+   */
+  DRIVER_EAPOL_FRAME_TRANSMIT_REQUESTED = 23,
+  /**
+   * With rate, regardless of the fact that EAPOL frame is accepted or
+   * rejected by firmware.
+   */
+  FW_EAPOL_FRAME_RECEIVED = 24,
+  /**
+   * With rate, and eapol index, driver has received EAPOL frame and will
+   * queue it up to wpa_supplicant.
+   */
+  DRIVER_EAPOL_FRAME_RECEIVED = 26,
+  /**
+   * With success/failure, parameters
+   */
+  BLOCK_ACK_NEGOTIATION_COMPLETE = 27,
+  BT_COEX_BT_SCO_START = 28,
+  BT_COEX_BT_SCO_STOP = 29,
+  /**
+   * For paging/scan etc., when BT starts transmiting twice per BT slot.
+   */
+  BT_COEX_BT_SCAN_START = 30,
+  BT_COEX_BT_SCAN_STOP = 31,
+  BT_COEX_BT_HID_START = 32,
+  BT_COEX_BT_HID_STOP = 33,
+  /**
+   * Firmware sends auth frame in roaming to next candidate.
+   */
+  ROAM_AUTH_STARTED = 34,
+  /**
+   * Firmware receive auth confirm from ap
+   */
+  ROAM_AUTH_COMPLETE = 35,
+  /**
+   * Firmware sends assoc/reassoc frame in roaming to next candidate.
+   */
+  ROAM_ASSOC_STARTED = 36,
+  /**
+   * Firmware receive assoc/reassoc confirm from ap.
+   */
+  ROAM_ASSOC_COMPLETE = 37,
+  /**
+   * Firmware sends stop BACKGROUND_SCAN
+   */
+  BACKGROUND_SCAN_STOP = 38,
+  /**
+   * Firmware indicates BACKGROUND_SCAN scan cycle started.
+   */
+  BACKGROUND_SCAN_CYCLE_STARTED = 39,
+  /**
+   * Firmware indicates BACKGROUND_SCAN scan cycle completed.
+   */
+  BACKGROUND_SCAN_CYCLE_COMPLETED = 40,
+  /**
+   * Firmware indicates BACKGROUND_SCAN scan start for a particular bucket.
+   */
+  BACKGROUND_SCAN_BUCKET_STARTED = 41,
+  /**
+   * Firmware indicates BACKGROUND_SCAN scan completed for for a particular bucket.
+   */
+  BACKGROUND_SCAN_BUCKET_COMPLETED = 42,
+  /**
+   * Event received from firmware about BACKGROUND_SCAN scan results being available.
+   */
+  BACKGROUND_SCAN_RESULTS_AVAILABLE = 43,
+  /**
+   * Event received from firmware with BACKGROUND_SCAN capabilities.
+   */
+  BACKGROUND_SCAN_CAPABILITIES = 44,
+  /**
+   * Event received from firmware when eligible candidate is found.
+   */
+  ROAM_CANDIDATE_FOUND = 45,
+  /**
+   * Event received from firmware when roam scan configuration gets
+   * enabled or disabled.
+   */
+  ROAM_SCAN_CONFIG = 46,
+  /**
+   * Firmware/driver timed out authentication.
+   */
+  AUTH_TIMEOUT = 47,
+  /**
+   * Firmware/driver timed out association.
+   */
+  ASSOC_TIMEOUT = 48,
+  /**
+   * Firmware/driver encountered allocation failure.
+   */
+  MEM_ALLOC_FAILURE = 49,
+  /**
+   * Driver added a PNO network in firmware.
+   */
+  DRIVER_PNO_ADD = 50,
+  /**
+   * Driver removed a PNO network in firmware.
+   */
+  DRIVER_PNO_REMOVE = 51,
+  /**
+   * Driver received PNO networks found indication from firmware.
+   */
+  DRIVER_PNO_NETWORK_FOUND = 52,
+  /**
+   * Driver triggered a scan for PNO networks.
+   */
+  DRIVER_PNO_SCAN_REQUESTED = 53,
+  /**
+   * Driver received scan results  of PNO networks.
+   */
+  DRIVER_PNO_SCAN_RESULT_FOUND = 54,
+  /**
+   * Driver updated scan results from  PNO networks to cfg80211.
+   */
+  DRIVER_PNO_SCAN_COMPLETE = 55,
+};
+
+/**
+ * Parameters of the various events are a sequence of TLVs
+ * (type, length, value). The types for different TLV's are defined below.
+ */
+enum WifiDebugRingEntryEventTlvType : uint16_t {
+  /**
+   * Take a byte stream as parameter.
+   */
+  VENDOR_SPECIFIC = 0,
+  /**
+   * Takes a MAC address as parameter.
+   */
+  BSSID = 1,
+  /**
+   * Takes a MAC address as parameter.
+   */
+  ADDR = 2,
+  /**
+   * Takes an SSID as parameter.
+   */
+  SSID = 3,
+  /**
+   * Takes an integer as parameter.
+   */
+  STATUS = 4,
+  /**
+   * Takes a |WifiChannelInfo| struct as parameter.
+   */
+  CHANNEL_SPEC = 5,
+  /**
+   * Takes a MAC address as parameter.
+   */
+  ADDR_1 = 6,
+  /**
+   * Takes a MAC address as parameter.
+   */
+  ADDR_2 = 7,
+  /**
+   * Takes a MAC address as parameter.
+   */
+  ADDR_3 = 8,
+  /**
+   * Takes a MAC address as parameter.
+   */
+  ADDR_4 = 9,
+  /**
+   * Takes a TSF value as parameter.
+   */
+  TSF = 10,
+  /**
+   * Takes one or more specific 802.11 IEs parameter IEs are in turn
+   * indicated in TLV format as per 802.11, spec.
+   */
+  IE = 11,
+  /**
+   * Takes a string interface name as parameter.
+   */
+  IFACE_NAME = 12,
+  /**
+   * Takes a integer reason code as per 802.11 as parameter.
+   */
+  REASON_CODE = 13,
+  /**
+   * Takes an integer representing wifi rate in 1 mbps as parameter.
+   */
+  RATE_MBPS = 14,
+  /**
+   * Takes an integer as parameter.
+   */
+  REQUEST_ID = 15,
+  /**
+   * Takes an integer as parameter.
+   */
+  BUCKET_ID = 16,
+  /**
+   * Takes a |BackgroundScanParameters| struct as parameter.
+   */
+  BACKGROUND_SCAN_PARAMS = 17,
+  /**
+   * Takes a |BackgroundScanCapabilities| struct as parameter.
+   */
+  BACKGROUND_SCAN_CAPABILITIES = 18,
+  /**
+   * Takes an integer as parameter.
+   */
+  SCAN_ID = 19,
+  /**
+   * Takes an integer as parameter.
+   */
+  RSSI = 20,
+  /**
+   * Takes a |WifiChannelInMhz| as parameter.
+   */
+  CHANNEL = 21,
+  /**
+   * Takes an integer as parameter.
+   */
+  LINK_ID = 22,
+  /**
+   * Takes an integer as parameter.
+   */
+  LINK_ROLE = 23,
+  /**
+   * Takes an integer as parameter.
+   */
+  LINK_STATE = 24,
+  /**
+   * Takes an integer as parameter.
+   */
+  LINK_TYPE = 25,
+  /**
+   * Takes an integer as parameter.
+   */
+  TSCO = 26,
+  /**
+   * Takes an integer as parameter.
+   */
+  RSCO = 27,
+  /**
+   * Takes an integer as parameter.
+   * M1=1, M2=2, M3=3, M=4,
+   */
+  EAPOL_MESSAGE_TYPE = 28,
+};
+
+/**
+ * Used to describe a specific TLV in an event entry.
+ */
+struct WifiDebugRingEntryEventTlv {
+  WifiDebugRingEntryEventTlvType type;
+  /**
+   * All possible types of values that can be held in the TLV.
+   * Note: This should ideally be a union. But, since this HIDL package
+   * is going to be used by a java client, we cannot have unions in this
+   * package.
+   */
+  /* TODO(b/32207606): This can be moved to vendor extension. */
+  vec<uint8_t> vendorSpecific;
+  Bssid bssid;
+  MacAddress addr;
+  Ssid ssid;
+  WifiChannelInfo channelSpec;
+  uint64_t tsf;
+  vec<WifiInformationElement> ie;
+  string ifaceName;
+  StaBackgroundScanParameters bgScanParams;
+  StaBackgroundScanCapabilities bgScanCapabilities;
+  Rssi rssi;
+  WifiChannelInMhz channel;
+  uint32_t integerVal;
+};
+
+/**
+ * Used to describe a connect event ring entry.
+ */
+struct WifiDebugRingEntryConnectivityEvent {
+  /**
+   * Ring entry header.
+   */
+  WifiDebugRingEntryHeader header;
+  /**
+   * Type of connection event.
+   */
+  WifiDebugRingEntryEventType event;
+  /**
+   * Separate parameter structure per event to be provided and optional data.
+   * The event data is expected to include an official android part, with some
+   * parameter as transmit rate, num retries, num scan result found, etc.
+   * event data can include a vendor proprietary part which is understood by
+   * the vendor only.
+   */
+  vec<WifiDebugRingEntryEventTlv> tlvs;
+};
+
+/**
+ * Used to describe a power event ring entry.
+ */
+struct WifiDebugRingEntryPowerEvent {
+  /**
+   * Ring entry header.
+   */
+  WifiDebugRingEntryHeader header;
+  /**
+   * Type of power event.
+   */
+  WifiDebugRingEntryEventType event;
+  /**
+   * Separate parameter structure per event to be provided and optional data.
+   * The event data is expected to include an official android part, with some
+   * parameter as transmit rate, num retries, num scan result found, etc.
+   * event data can include a vendor proprietary part which is understood by
+   * the vendor only.
+   */
+  vec<WifiDebugRingEntryEventTlv> tlvs;
+};
+
+/**
+ * Used to describe a wakelock event ring entry.
+ */
+struct WifiDebugRingEntryWakelockEvent {
+  /**
+   * Ring entry header.
+   */
+  WifiDebugRingEntryHeader header;
+  /**
+   * true = wake lock acquired.
+   * false = wake lock released.
+   */
+  bool wasAcquired;
+  /**
+   * Reason why this wake lock is taken.
+   * This is a vendor defined reason and can only be understood by the
+   * vendor.
+   */
+  uint32_t vendorSpecificReason;
+  /**
+   * Wake lock name.
+   */
+  string wakelockName;
+};
+
+/**
+ * Used to describe a vendor specific data ring entry.
+ */
+struct WifiDebugRingEntryVendorData {
+  /**
+   * Ring entry header.
+   */
+  WifiDebugRingEntryHeader header;
+  /**
+   * This is a blob that will only be understood by the
+   * vendor.
+   */
+  vec<uint8_t> vendorData;
+};
+
+/**
+ * Flags describing each debug ring buffer.
+ */
+enum WifiDebugRingBufferFlags : uint32_t {
+  HAS_BINARY_ENTRIES = 1 << 0,
+  HAS_ASCII_ENTRIES = 1 << 1,
+  HAS_PER_PACKET_ENTRIES = 1 << 2,
+};
+
+/**
+ * Struct describing each debug ring buffer supported by
+ * the device.
+ */
+struct WifiDebugRingBufferStatus {
+  /**
+   * Name of this debug ring buffer.
+   */
+  string ringName;
+  /**
+   * Combination of |WifiDebugRingBufferFlags| values.
+   */
+  uint32_t flags;
+  /**
+   * Unique integer representing the ring.
+   */
+  WifiRingBufferId ringId;
+  /**
+   * Total memory size allocated for the buffer.
+   */
+  uint32_t sizeInBytes;
+  /**
+   * Amount of free space in the buffer.
+   */
+  uint32_t freeSizeInBytes;
+  /**
+   * Verbose level for ring buffer.
+   */
+  uint32_t verboseLevel;
+};
+
+/**
+ * Verbose logging level to set for each debug ring buffer supported
+ * by the device.
+ */
+enum WifiDebugRingBufferVerboseLevel : uint32_t {
+  /**
+   * Level 0 corresponds to no collection, and it makes log handler
+   * stop by no more events from driver.
+   */
+  NONE = 0,
+  /**
+   * Level 1 correspond to normal log level, with minimal user impact.
+   * This is the default value.
+   */
+  DEFAULT = 1,
+  /**
+   * Level 2 is enabled when user is lazily trying to reproduce a problem,
+   * wifi performances and power can be impacted but device should not
+   * otherwise be significantly impacted.
+   */
+  VERBOSE = 2,
+  /**
+   * Level 3 is used when trying to actively debug a problem.
+   * This will cause sever performance degradation.
+   */
+  EXCESSIVE = 3
+};
+
+/**
+ * Enum describing the fate of the TX packets.
+ */
+enum WifiDebugTxPacketFate : uint32_t {
+  /**
+   * Sent over air and ACKed.
+   */
+  ACKED,
+  /**
+   * Sent over air but not ACKed. (Normal for broadcast/multicast.)
+   */
+  SENT,
+  /**
+   * Queued within firmware, but not yet sent over air.
+   */
+  FW_QUEUED,
+  /**
+   * Dropped by firmware as invalid. E.g. bad source address, bad checksum,
+   * or invalid for current state.
+   */
+  FW_DROP_INVALID,
+  /**
+   * Dropped by firmware due to lack of buffer space.
+   */
+  FW_DROP_NOBUFS,
+  /**
+   * Dropped by firmware for any other reason. Includes frames that  were sent
+   * by driver to firmware, but unaccounted for by  firmware.
+   */
+  FW_DROP_OTHER,
+  /**
+   * Queued within driver, not yet sent to firmware.
+   */
+  DRV_QUEUED,
+  /**
+   * Dropped by driver as invalid. E.g. bad source address, or invalid for
+   * current state.
+   */
+  DRV_DROP_INVALID,
+  /**
+   * Dropped by driver due to lack of buffer space.
+   */
+  DRV_DROP_NOBUFS,
+  /**
+   * Dropped by driver for any other reason.
+   */
+  DRV_DROP_OTHER,
+};
+
+/**
+ * Enum describing the fate of the TX packets.
+ */
+enum WifiDebugRxPacketFate : uint32_t {
+  /**
+   * Valid and delivered to network stack (e.g., netif_rx()).
+   */
+  SUCCESS,
+  /**
+   * Queued within firmware, but not yet sent to driver.
+   */
+  FW_QUEUED,
+  /**
+   * Dropped by firmware due to host-programmable filters.
+   */
+  FW_DROP_FILTER,
+  /**
+   * Dropped by firmware as invalid. E.g. bad checksum, decrypt failed,
+   * or invalid for current state.
+   */
+  FW_DROP_INVALID,
+  /**
+   * Dropped by firmware due to lack of buffer space.
+   */
+  FW_DROP_NOBUFS,
+  /**
+   * Dropped by firmware for any other reason.
+   */
+  FW_DROP_OTHER,
+  /**
+   * Queued within driver, not yet delivered to network stack.
+   */
+  DRV_QUEUED,
+  /**
+   * Dropped by driver due to filter rules.
+   */
+  DRV_DROP_FILTER,
+  /**
+   * Dropped by driver as invalid. E.g. not permitted in current state.
+   */
+  DRV_DROP_INVALID,
+  /**
+   * Dropped by driver due to lack of buffer space.
+   */
+  DRV_DROP_NOBUFS,
+  /**
+   * Dropped by driver for any other reason.
+   */
+  DRV_DROP_OTHER,
+};
+
+/**
+ * Type of frame transmitted/received.
+ */
+enum WifiDebugPacketFateFrameType : uint32_t {
+  UNKNOWN,
+  ETHERNET_II,
+  MGMT_80211,
+};
+
+/**
+ * Information regarding the frame transmitted/received.
+ */
+struct WifiDebugPacketFateFrameInfo {
+  /**
+   * The type of MAC-layer frame that this frame_info holds.
+   * - For data frames, use FRAME_TYPE_ETHERNET_II.
+   * - For management frames, use FRAME_TYPE_80211_MGMT.
+   * - If the type of the frame is unknown, use FRAME_TYPE_UNKNOWN.
+   */
+  WifiDebugPacketFateFrameType frameType;
+  /**
+   * The number of bytes included in |frameContent|.
+   * If the frame  contents are missing (e.g. RX frame dropped in firmware),
+   * |frameLen| must be set to 0.
+   */
+  uint64_t frameLen;
+  /**
+   * Host clock when this frame was received by the driver (either  outbound
+   * from the host network stack, or inbound from the firmware).
+   * - The timestamp must be taken from a clock which includes time the host
+   *   spent suspended (e.g. ktime_get_boottime()).
+   * - If no host timestamp is available (e.g. RX frame was dropped in firmware),
+   *   this field must be set to 0.
+   */
+  TimeStampInUs driverTimestampUsec;
+  /**
+   * Firmware clock when this frame was received by the firmware
+   * (either outbound from the host, or inbound from a remote  station).
+   * - The timestamp must be taken from a clock which includes time firmware
+   *   spent suspended (if applicable).
+   * - If no firmware timestamp is available (e.g. TX frame was dropped by
+   *   driver), this field must be set to 0.
+   * - Consumers of |frameInfo| must not assume any synchronization between
+   *   driver and firmware clocks.
+   */
+  TimeStampInUs firmwareTimestampUsec;
+  /**
+   * Actual frame content. This is the raw bytes of the corresponding packet.
+   * - Should be provided for TX frames originated by the host.
+   * - Should be provided for RX frames received by the driver.
+   * - Optionally provided for TX frames originated by firmware.
+   *   (At discretion of HAL implementation.)
+   * - Optionally provided for RX frames dropped in firmware.
+   *   (At discretion of HAL implementation.)
+   * - If frame content is not provided, |frameLen| must be set to 0.
+   */
+  vec<uint8_t> frameContent;
+};
+
+/**
+ * Struct describing packet fate report for each Rx frame.
+ */
+struct WifiDebugTxPacketFateReport {
+  WifiDebugTxPacketFate fate;
+  WifiDebugPacketFateFrameInfo frameInf;
+};
+
+/**
+ * Struct describing packet fate report for each Rx frame.
+ */
+struct WifiDebugRxPacketFateReport {
+  WifiDebugRxPacketFate fate;
+  WifiDebugPacketFateFrameInfo frameInfo;
+};
+
+/**
+ * Struct capturing the count of all rx packets that caused
+ * host wakeup.
+ */
+struct WifiDebugHostWakeReasonRxPacketDetails {
+  /**
+   * Total rx unicast packet which woke up host.
+   */
+  uint32_t rxUnicastCnt;
+  /**
+   * Total rx multicast packet which woke up host.
+   */
+  uint32_t rxMulticastCnt;
+  /**
+   * Total rx broadcast packet which woke up host.
+   */
+  uint32_t rxBroadcastCnt;
+};
+
+/**
+ * Struct capturing the count of all rx multicast packets that caused
+ * host wakeup.
+ */
+struct WifiDebugHostWakeReasonRxMulticastPacketDetails {
+  /**
+   * Rx wake packet was ipv4 multicast.
+   */
+  uint32_t ipv4RxMulticastAddrCnt;
+  /**
+   * Rx wake packet was ipv6 multicast.
+   */
+  uint32_t ipv6RxMulticastAddrCnt;
+  /**
+   * Rx wake packet was non-ipv4 and non-ipv6.
+   */
+  uint32_t otherRxMulticastAddrCnt;
+};
+
+/**
+ * Struct capturing the count of all rx ICMP packets that caused
+ * host wakeup.
+ */
+struct WifiDebugHostWakeReasonRxIcmpPacketDetails {
+  /**
+   * Wake icmp packet count.
+   */
+  uint32_t icmpPkt;
+  /**
+   * Wake icmp6 packet count.
+   */
+  uint32_t icmp6Pkt;
+  /**
+   * Wake icmp6 RA packet count.
+   */
+  uint32_t icmp6Ra;
+  /**
+   * Wake icmp6 NA packet count.
+   */
+  uint32_t icmp6Na;
+  /**
+   * Wake icmp6 NS packet count.
+   */
+  uint32_t icmp6Ns;
+};
+
+/**
+ * Structure capturing the count of all the wireless related host wakeup.
+ * This is used to capture all the reasons why the host processor
+ * (WLAN driver) was woken up by the WLAN firmware.
+ * These stats may be used to debug any power issues caused due to frequent
+ * wakeup of the host processor by the WLAN firmware.
+ */
+struct WifiDebugHostWakeReasonStats {
+  /**
+   * Total count of cmd/event wakes.
+   * These must account for all wakeups due to WLAN management
+   * commands/events received over the air.
+   */
+  uint32_t totalCmdEventWakeCnt;
+  /**
+   * Vector of wake counts per cmd/event type.
+   * The number of command types and their meaning is only understood by the
+   * vendor.
+   */
+  vec<uint32_t> cmdEventWakeCntPerType;
+  /**
+   * Total count of drive/fw wakes.
+   * These must account for all wakeups due to local driver/firmware
+   * interactions. These include all vendor implementation specific
+   * interactions like any heart-beat monitoring, Bus management, etc.
+   */
+  uint32_t totalDriverFwLocalWakeCnt;
+  /**
+   * Vector of wake counts per driver/firmware interaction type.
+   * The number of command types and their meaning is only understood by the
+   * vendor.
+   */
+  vec<uint32_t> driverFwLocalWakeCntPerType;
+  /**
+   * Total data rx packets, that woke up host.
+   */
+  uint32_t totalRxPacketWakeCnt;
+  WifiDebugHostWakeReasonRxPacketDetails rxPktWakeDetails;
+  WifiDebugHostWakeReasonRxMulticastPacketDetails rxMulticastPkWakeDetails;
+  WifiDebugHostWakeReasonRxIcmpPacketDetails rxIcmpPkWakeDetails;
+};
diff --git a/wifi/supplicant/1.0/Android.bp b/wifi/supplicant/1.0/Android.bp
index 08c6f9a..0f399a0 100644
--- a/wifi/supplicant/1.0/Android.bp
+++ b/wifi/supplicant/1.0/Android.bp
@@ -126,13 +126,15 @@
     generated_headers: ["android.hardware.wifi.supplicant@1.0_genc++_headers"],
     export_generated_headers: ["android.hardware.wifi.supplicant@1.0_genc++_headers"],
     shared_libs: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
         "libcutils",
     ],
     export_shared_lib_headers: [
-        "libhidl",
+        "libhidlbase",
+        "libhidltransport",
         "libhwbinder",
         "libutils",
     ],
diff --git a/wifi/supplicant/1.0/ISupplicantStaIface.hal b/wifi/supplicant/1.0/ISupplicantStaIface.hal
index a68e961..868758e 100644
--- a/wifi/supplicant/1.0/ISupplicantStaIface.hal
+++ b/wifi/supplicant/1.0/ISupplicantStaIface.hal
@@ -25,6 +25,30 @@
  */
 interface ISupplicantStaIface extends ISupplicantIface {
   /**
+   * Access Network Query Protocol info ID elements
+   * for IEEE Std 802.11u-2011.
+   */
+  enum AnqpInfoId : uint32_t {
+    VENUE_NAME = 258,
+    ROAMING_CONSORTIUM = 261,
+    IP_ADDR_TYPE_AVAILABILITY = 262,
+    NAI_REALM = 263,
+    ANQP_3GPP_CELLULAR_NETWORK = 264,
+    DOMAIN_NAME = 268
+  };
+
+  /**
+   * Access Network Query Protocol subtype elements
+   * for Hotspot 2.0.
+   */
+  enum Hs20AnqpSubtypes : uint32_t {
+    OPERATOR_FRIENDLY_NAME = 2,
+    WAN_METRICS = 4,
+    CONNECTION_CAPABILITY = 5,
+    OSU_PROVIDERS_LIST = 8,
+  };
+
+  /**
    * Register for callbacks from this interface.
    *
    * These callbacks are invoked for events that are specific to this interface.
@@ -133,4 +157,40 @@
    */
   initiateTdlsTeardown(MacAddress macAddress)
       generates (SupplicantStatus status);
+
+  /**
+   * Initiate ANQP (for IEEE 802.11u Interworking/Hotspot 2.0) queries with the
+   * specified access point.
+   * The ANQP data fetched must be returned in the
+   * |ISupplicantStaIfaceCallback.onAnqpQueryDone| callback.
+   *
+   * @param macAddress MAC address of the access point.
+   * @param infoElements List of information elements to query for.
+   * @param subtypes List of HS20 subtypes to query for.
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|,
+   *         |SupplicantStatusCode.FAILURE_IFACE_INVALID|
+   */
+  initiateAnqpQuery(MacAddress macAddress,
+                    vec<AnqpInfoId> infoElements,
+                    vec<Hs20AnqpSubtypes> subTypes)
+      generates (SupplicantStatus status);
+
+  /**
+   * Initiate the Hotspot 2.0 icon query with the specified accesss point.
+   * The icon data fetched must be returned in the
+   * |ISupplicantStaIfaceCallback.onHs20IconQueryDone| callback.
+   *
+   * @param macAddress MAC address of the access point.
+   * @param fileName Name of the file to request from the access point.
+   * @return status Status of the operation.
+   *         Possible status codes:
+   *         |SupplicantStatusCode.SUCCESS|,
+   *         |SupplicantStatusCode.FAILURE_UNKNOWN|,
+   *         |SupplicantStatusCode.FAILURE_IFACE_INVALID|
+   */
+  initiateHs20IconQuery(MacAddress macAddress, string fileName)
+      generates (SupplicantStatus status);
 };
diff --git a/wifi/supplicant/1.0/ISupplicantStaIfaceCallback.hal b/wifi/supplicant/1.0/ISupplicantStaIfaceCallback.hal
index 77423ed..4c66eba 100644
--- a/wifi/supplicant/1.0/ISupplicantStaIfaceCallback.hal
+++ b/wifi/supplicant/1.0/ISupplicantStaIfaceCallback.hal
@@ -105,6 +105,40 @@
   };
 
   /**
+   * OSU Method. Refer to section 4.8.1.3 of the Hotspot 2.0 spec.
+   */
+  enum OsuMethod : uint8_t {
+    OMA_DM = 0,
+    SOAP_XML_SPP = 1
+  };
+
+  /**
+   * ANQP data for IEEE Std 802.11u-2011.
+   * The format of the data within these elements follows the IEEE
+   * Std 802.11u-2011 standard.
+   */
+  struct AnqpData {
+    vec<uint8_t> venueName;
+    vec<uint8_t> roamingConsortium;
+    vec<uint8_t> ipAddrTypeAvailability;
+    vec<uint8_t> naiRealm;
+    vec<uint8_t> anqp3gppCellularNetwork;
+    vec<uint8_t> domainName;
+  };
+
+  /**
+   * ANQP data for Hotspot 2.0.
+   * The format of the data within these elements follows the Hotspot 2.0
+   * standard.
+   */
+  struct Hs20AnqpData {
+    vec<uint8_t> operatorFriendlyName;
+    vec<uint8_t> wanMetrics;
+    vec<uint8_t> connectionCapability;
+    vec<uint8_t> osuProvidersList;
+  };
+
+  /**
    * Used to indicate that a new network has been added.
    *
    * @param id Network ID allocated to the corresponding network.
@@ -138,4 +172,49 @@
    */
   oneway onStateChanged(
       State newState, Bssid bssid, SupplicantNetworkId id, Ssid ssid);
+
+  /**
+   * Used to indicate the result of ANQP (either for IEEE 802.11u Interworking
+   * or Hotspot 2.0) query.
+   *
+   * @param macAddress MAC address of the access point.
+   * @param data ANQP data fetched from the access point.
+   *        All the fields in this struct must be empty if the query failed.
+   * @param hs20Data ANQP data fetched from the Hotspot 2.0 access point.
+   *        All the fields in this struct must be empty if the query failed.
+   */
+  oneway onAnqpQueryDone(MacAddress macAddress,
+                         AnqpData data,
+                         Hs20AnqpData hs20Data);
+
+  /**
+   * Used to indicate the result of Hotspot 2.0 Icon query.
+   *
+   * @param macAddress MAC address of the access point.
+   * @param fileName Name of the file that was requested.
+   * @param data Icon data fetched from the access point.
+   *        Must be empty if the query failed.
+   */
+  oneway onHs20IconQueryDone(MacAddress macAddress,
+                             string fileName,
+                             vec<uint8_t> data);
+
+  /**
+   * Used to indicate a Hotspot 2.0 subscription remediation event.
+   *
+   * @param osuMethod OSU method.
+   * @param url URL of the server.
+   */
+  oneway onHs20SubscriptionRemediation(OsuMethod osuMethod, string url);
+
+  /**
+   * Used to indicate a Hotspot 2.0 imminent deauth notice.
+   * @param reasonCode Code to indicate the deauth reason.
+   *        Refer to section 3.2.1.2 of the Hotspot 2.0 spec.
+   * @param reAuthDelayInSec Delay before reauthenticating.
+   * @param url URL of the server.
+   */
+  oneway onHs20DeauthImminentNotice(uint32_t reasonCode,
+                                    uint32_t reAuthDelayInSec,
+                                    string url);
 };