diff --git a/include/hardware/ble_advertiser.h b/include/hardware/ble_advertiser.h
index 45282aa..013e426 100644
--- a/include/hardware/ble_advertiser.h
+++ b/include/hardware/ble_advertiser.h
@@ -34,41 +34,71 @@
   uint8_t scan_request_notification_enable;
 };
 
+struct PeriodicAdvertisingParameters {
+  uint8_t enable;
+  uint16_t min_interval;
+  uint16_t max_interval;
+  uint16_t periodic_advertising_properties;
+};
+
 class BleAdvertiserInterface {
  public:
   virtual ~BleAdvertiserInterface() = default;
 
   /** Callback invoked when multi-adv operation has completed */
-  using Callback = base::Callback<void(uint8_t /* status */)>;
+  using StatusCallback = base::Callback<void(uint8_t /* status */)>;
+  using IdStatusCallback =
+      base::Callback<void(uint8_t /* advertiser_id */, uint8_t /* status */)>;
+  using IdTxPowerStatusCallback =
+      base::Callback<void(uint8_t /* advertiser_id */, int8_t /* tx_power */, uint8_t /* status */)>;
+  using ParametersCallback =
+      base::Callback<void(uint8_t /* status */, int8_t /* tx_power */)>;
 
   /** Registers an advertiser with the stack */
-  virtual void RegisterAdvertiser(
-      base::Callback<void(uint8_t /* advertiser_id */,
-                          uint8_t /* status */)>) = 0;
+  virtual void RegisterAdvertiser(IdStatusCallback) = 0;
 
   /* Set the parameters as per spec, user manual specified values */
-  virtual void SetParameters(
-      uint8_t advertiser_id, uint16_t advertising_event_properties,
-      uint32_t min_interval, uint32_t max_interval, int chnl_map, int tx_power,
-      uint8_t primary_advertising_phy, uint8_t secondary_advertising_phy,
-      uint8_t scan_request_notification_enable, Callback cb) = 0;
+  virtual void SetParameters(uint8_t advertiser_id, AdvertiseParameters params,
+                             ParametersCallback cb) = 0;
 
   /* Setup the data */
   virtual void SetData(int advertiser_id, bool set_scan_rsp,
-                       std::vector<uint8_t> data, Callback cb) = 0;
+                       std::vector<uint8_t> data, StatusCallback cb) = 0;
 
   /* Enable the advertising instance */
-  virtual void Enable(uint8_t advertiser_id, bool enable, Callback cb,
-                      int timeout_s, Callback timeout_cb) = 0;
+  virtual void Enable(uint8_t advertiser_id, bool enable, StatusCallback cb,
+                      int timeout_s, StatusCallback timeout_cb) = 0;
 
   /*  Unregisters an advertiser */
   virtual void Unregister(uint8_t advertiser_id) = 0;
 
-  virtual void StartAdvertising(uint8_t advertiser_id, Callback cb,
+  virtual void StartAdvertising(uint8_t advertiser_id, StatusCallback cb,
                                 AdvertiseParameters params,
                                 std::vector<uint8_t> advertise_data,
                                 std::vector<uint8_t> scan_response_data,
-                                int timeout_s, Callback timeout_cb) = 0;
+                                int timeout_s, StatusCallback timeout_cb) = 0;
+
+  /** Start the advertising set. This include registering, setting all
+   * parameters and data, and enabling it. |register_cb| is called when the set
+   * is advertising. |timeout_cb| is called when the timeout_s have passed */
+  virtual void StartAdvertisingSet(
+      IdTxPowerStatusCallback register_cb, AdvertiseParameters params,
+      std::vector<uint8_t> advertise_data,
+      std::vector<uint8_t> scan_response_data,
+      PeriodicAdvertisingParameters periodic_params,
+      std::vector<uint8_t> periodic_data, int timeout_s,
+      IdStatusCallback timeout_cb) = 0;
+
+  virtual void SetPeriodicAdvertisingParameters(
+      int advertiser_id, PeriodicAdvertisingParameters parameters,
+      StatusCallback cb) = 0;
+
+  virtual void SetPeriodicAdvertisingData(int advertiser_id,
+                                          std::vector<uint8_t> data,
+                                          StatusCallback cb) = 0;
+
+  virtual void SetPeriodicAdvertisingEnable(int advertiser_id, bool enable,
+                                            StatusCallback cb) = 0;
 };
 
 #endif /* ANDROID_INCLUDE_BLE_ADVERTISER_H */
diff --git a/include/hardware/ble_scanner.h b/include/hardware/ble_scanner.h
index 20b36fd..4ab0a77 100644
--- a/include/hardware/ble_scanner.h
+++ b/include/hardware/ble_scanner.h
@@ -23,13 +23,6 @@
 #include "bt_gatt_client.h"
 #include "bt_gatt_types.h"
 
-/** Callback invoked when batchscan storage config operation has completed */
-typedef void (*batchscan_cfg_storage_callback)(int client_if, int status);
-
-/** Callback invoked when batchscan enable / disable operation has completed */
-typedef void (*batchscan_enable_disable_callback)(int action, int client_if,
-                                                  int status);
-
 /** Callback invoked when batchscan reports are obtained */
 typedef void (*batchscan_reports_callback)(int client_if, int status,
                                            int report_format, int num_records,
@@ -42,37 +35,19 @@
 typedef void (*track_adv_event_callback)(
     btgatt_track_adv_info_t *p_track_adv_info);
 
-/** Callback invoked when scan parameter setup has completed */
-typedef void (*scan_parameter_setup_completed_callback)(int client_if,
-                                                        btgattc_error_t status);
-
 /** Callback for scan results */
-typedef void (*scan_result_callback)(bt_bdaddr_t *bda, int rssi,
+typedef void (*scan_result_callback)(uint16_t event_type, uint8_t addr_type,
+                                     bt_bdaddr_t *bda, uint8_t primary_phy,
+                                     uint8_t secondary_phy,
+                                     uint8_t advertising_sid, int8_t tx_power,
+                                     int8_t rssi, uint16_t periodic_adv_int,
                                      std::vector<uint8_t> adv_data);
 
-/** Callback invoked when a scan filter configuration command has completed */
-typedef void (*scan_filter_cfg_callback)(int action, int client_if, int status,
-                                         int filt_type, int avbl_space);
-
-/** Callback invoked when scan param has been added, cleared, or deleted */
-typedef void (*scan_filter_param_callback)(int action, int client_if,
-                                           int status, int avbl_space);
-
-/** Callback invoked when a scan filter configuration command has completed */
-typedef void (*scan_filter_status_callback)(int enable, int client_if,
-                                            int status);
-
 typedef struct {
   scan_result_callback scan_result_cb;
-  batchscan_cfg_storage_callback batchscan_cfg_storage_cb;
-  batchscan_enable_disable_callback batchscan_enb_disable_cb;
   batchscan_reports_callback batchscan_reports_cb;
   batchscan_threshold_callback batchscan_threshold_cb;
   track_adv_event_callback track_adv_event_cb;
-  scan_parameter_setup_completed_callback scan_parameter_setup_completed_cb;
-  scan_filter_cfg_callback scan_filter_cfg_cb;
-  scan_filter_param_callback scan_filter_param_cb;
-  scan_filter_status_callback scan_filter_status_cb;
 } btgatt_scanner_callbacks_t;
 
 class BleScannerInterface {
@@ -82,6 +57,19 @@
   using RegisterCallback =
       base::Callback<void(uint8_t /* scanner_id */, uint8_t /* status */)>;
 
+  using Callback = base::Callback<void(uint8_t /* status */)>;
+
+  using EnableCallback =
+      base::Callback<void(uint8_t /* action */, uint8_t /* status */)>;
+
+  using FilterParamSetupCallback =
+      base::Callback<void(uint8_t /* avbl_space */, uint8_t /* action_type */,
+                          uint8_t /* status */)>;
+
+  using FilterConfigCallback =
+      base::Callback<void(uint8_t /* filt_type */, uint8_t /* avbl_space */,
+                          uint8_t /* action */, uint8_t /* status */)>;
+
   /** Registers a scanner with the stack */
   virtual void RegisterScanner(RegisterCallback) = 0;
 
@@ -94,39 +82,42 @@
   /** Setup scan filter params */
   virtual void ScanFilterParamSetup(
       uint8_t client_if, uint8_t action, uint8_t filt_index,
-      std::unique_ptr<btgatt_filt_param_setup_t> filt_param) = 0;
+      std::unique_ptr<btgatt_filt_param_setup_t> filt_param,
+      FilterParamSetupCallback cb) = 0;
 
   /** Configure a scan filter condition  */
-  virtual void ScanFilterAddRemove(int client_if, int action, int filt_type,
-                                   int filt_index, int company_id,
-                                   int company_id_mask, const bt_uuid_t *p_uuid,
+  virtual void ScanFilterAddRemove(int action, int filt_type, int filt_index,
+                                   int company_id, int company_id_mask,
+                                   const bt_uuid_t *p_uuid,
                                    const bt_uuid_t *p_uuid_mask,
                                    const bt_bdaddr_t *bd_addr, char addr_type,
                                    std::vector<uint8_t> data,
-                                   std::vector<uint8_t> p_mask) = 0;
+                                   std::vector<uint8_t> p_mask,
+                                   FilterConfigCallback cb) = 0;
 
   /** Clear all scan filter conditions for specific filter index*/
-  virtual void ScanFilterClear(int client_if, int filt_index) = 0;
+  virtual void ScanFilterClear(int filt_index, FilterConfigCallback cb) = 0;
 
   /** Enable / disable scan filter feature*/
-  virtual void ScanFilterEnable(int client_if, bool enable) = 0;
+  virtual void ScanFilterEnable(bool enable, EnableCallback cb) = 0;
 
   /** Sets the LE scan interval and window in units of N*0.625 msec */
-  virtual void SetScanParameters(int client_if, int scan_interval,
-                                 int scan_window) = 0;
+  virtual void SetScanParameters(int scan_interval, int scan_window,
+                                 Callback cb) = 0;
 
   /* Configure the batchscan storage */
   virtual void BatchscanConfigStorage(int client_if, int batch_scan_full_max,
                                       int batch_scan_trunc_max,
-                                      int batch_scan_notify_threshold) = 0;
+                                      int batch_scan_notify_threshold,
+                                      Callback cb) = 0;
 
   /* Enable batchscan */
-  virtual void BatchscanEnable(int client_if, int scan_mode, int scan_interval,
-                               int scan_window, int addr_type,
-                               int discard_rule) = 0;
+  virtual void BatchscanEnable(int scan_mode, int scan_interval,
+                               int scan_window, int addr_type, int discard_rule,
+                               Callback cb) = 0;
 
   /* Disable batchscan */
-  virtual void BatchscanDisable(int client_if) = 0;
+  virtual void BatchscanDisable(Callback cb) = 0;
 
   /* Read out batchscan reports */
   virtual void BatchscanReadReports(int client_if, int scan_mode) = 0;
diff --git a/include/hardware/bluetooth.h b/include/hardware/bluetooth.h
index 9870913..5d69ab3 100644
--- a/include/hardware/bluetooth.h
+++ b/include/hardware/bluetooth.h
@@ -163,6 +163,11 @@
     uint16_t total_trackable_advertisers;
     bool extended_scan_support;
     bool debug_logging_supported;
+    bool le_2m_phy_supported;
+    bool le_coded_phy_supported;
+    bool le_extended_advertising_supported;
+    bool le_periodic_advertising_supported;
+    uint16_t le_maximum_advertising_data_length;
 }bt_local_le_features_t;
 
 /* Bluetooth Adapter and Remote Device property types */
diff --git a/include/hardware/bt_av.h b/include/hardware/bt_av.h
index 66a8643..91ae2ac 100644
--- a/include/hardware/bt_av.h
+++ b/include/hardware/bt_av.h
@@ -69,7 +69,15 @@
 } btav_a2dp_codec_index_t;
 
 typedef enum {
+  // Disable the codec.
+  // NOTE: This value can be used only during initialization when
+  // function btav_source_interface_t::init() is called.
+  BTAV_A2DP_CODEC_PRIORITY_DISABLED = -1,
+
+  // Reset the codec priority to its default value.
   BTAV_A2DP_CODEC_PRIORITY_DEFAULT = 0,
+
+  // Highest codec priority.
   BTAV_A2DP_CODEC_PRIORITY_HIGHEST = 1000 * 1000
 } btav_a2dp_codec_priority_t;
 
@@ -156,7 +164,7 @@
     btav_audio_source_config_callback audio_config_cb;
 } btav_source_callbacks_t;
 
-/** BT-AV A2DP Source callback structure. */
+/** BT-AV A2DP Sink callback structure. */
 typedef struct {
     /** set to sizeof(btav_sink_callbacks_t) */
     size_t      size;
@@ -183,9 +191,10 @@
     /** set to sizeof(btav_source_interface_t) */
     size_t          size;
     /**
-     * Register the BtAv callbacks
+     * Register the BtAv callbacks.
      */
-    bt_status_t (*init)( btav_source_callbacks_t* callbacks );
+    bt_status_t (*init)(btav_source_callbacks_t* callbacks,
+                std::vector<btav_a2dp_codec_config_t> codec_priorities);
 
     /** connect to headset */
     bt_status_t (*connect)( bt_bdaddr_t *bd_addr );
diff --git a/include/hardware/camera3.h b/include/hardware/camera3.h
index a7df0ee..cec2ab3 100644
--- a/include/hardware/camera3.h
+++ b/include/hardware/camera3.h
@@ -1479,6 +1479,13 @@
      *      android.lens.opticalStabilizationMode (if it is supported)
      *      android.scaler.cropRegion
      *      android.statistics.faceDetectMode (if it is supported)
+     *   6. To reduce the amount of data passed across process boundaries at
+     *      high frame rate, within one batch, camera framework only propagates
+     *      the last shutter notify and the last capture results (including partial
+     *      results and final result) to the app. The shutter notifies and capture
+     *      results for the other requests in the batch are derived by
+     *      the camera framework. As a result, the HAL can return empty metadata
+     *      except for the last result in the batch.
      *
      * For more details about high speed stream requirements, see
      * android.control.availableHighSpeedVideoConfigurations and CONSTRAINED_HIGH_SPEED_VIDEO
@@ -1597,6 +1604,13 @@
      *   value of this is 0.
      *   For all streams passed via configure_streams(), the HAL must write
      *   over this field with its usage flags.
+     *
+     *   From Android O, the usage flag for an output stream may be bitwise
+     *   combination of usage flags for multiple consumers, for the purpose of
+     *   sharing one camera stream between those consumers. The HAL must fail
+     *   configure_streams call with -EINVAL if the combined flags cannot be
+     *   supported due to imcompatible buffer format, dataSpace, or other hardware
+     *   limitations.
      */
     uint32_t usage;
 
diff --git a/include/hardware/gnss-base.h b/include/hardware/gnss-base.h
index afeb834..e56020d 100644
--- a/include/hardware/gnss-base.h
+++ b/include/hardware/gnss-base.h
@@ -1,5 +1,6 @@
 // This file is autogenerated by hidl-gen. Do not edit manually.
 // Source: android.hardware.gnss@1.0
+// Root: android.hardware:hardware/interfaces
 
 #ifndef HIDL_GENERATED_ANDROID_HARDWARE_GNSS_V1_0_EXPORTED_CONSTANTS_H_
 #define HIDL_GENERATED_ANDROID_HARDWARE_GNSS_V1_0_EXPORTED_CONSTANTS_H_
@@ -27,7 +28,10 @@
     GPS_LOCATION_HAS_ALTITUDE = 2, // 0x0002
     GPS_LOCATION_HAS_SPEED = 4, // 0x0004
     GPS_LOCATION_HAS_BEARING = 8, // 0x0008
-    GPS_LOCATION_HAS_ACCURACY = 16, // 0x0010
+    GPS_LOCATION_HAS_HORIZONTAL_ACCURACY = 16, // 0x0010
+    GPS_LOCATION_HAS_VERTICAL_ACCURACY = 32, // 0x0020
+    GPS_LOCATION_HAS_SPEED_ACCURACY = 64, // 0x0040
+    GPS_LOCATION_HAS_BEARING_ACCURACY = 128, // 0x0080
 };
 
 enum {
@@ -132,6 +136,7 @@
     GNSS_SV_FLAGS_HAS_EPHEMERIS_DATA = 1, // (1 << 0)
     GNSS_SV_FLAGS_HAS_ALMANAC_DATA = 2, // (1 << 1)
     GNSS_SV_FLAGS_USED_IN_FIX = 4, // (1 << 2)
+    GNSS_SV_FLAGS_HAS_CARRIER_FREQUENCY = 8, // (1 << 3)
 };
 
 enum {
@@ -176,6 +181,7 @@
     GNSS_MEASUREMENT_HAS_CARRIER_CYCLES = 1024u, // (1 << 10)
     GNSS_MEASUREMENT_HAS_CARRIER_PHASE = 2048u, // (1 << 11)
     GNSS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY = 4096u, // (1 << 12)
+    GNSS_MEASUREMENT_HAS_AUTOMATIC_GAIN_CONTROL = 8192u, // (1 << 13)
 };
 
 enum {
@@ -200,6 +206,8 @@
     GNSS_MEASUREMENT_STATE_GAL_E1C_2ND_CODE_LOCK = 2048u, // (1 << 11)
     GNSS_MEASUREMENT_STATE_GAL_E1B_PAGE_SYNC = 4096u, // (1 << 12)
     GNSS_MEASUREMENT_STATE_SBAS_SYNC = 8192u, // (1 << 13)
+    GNSS_MEASUREMENT_STATE_TOW_KNOWN = 16384u, // (1 << 14)
+    GNSS_MEASUREMENT_STATE_GLO_TOD_KNOWN = 32768u, // (1 << 15)
 };
 
 enum {
diff --git a/include/hardware/gps.h b/include/hardware/gps.h
index 2f719ce..4e108b3 100644
--- a/include/hardware/gps.h
+++ b/include/hardware/gps.h
@@ -60,6 +60,7 @@
 #define GNSS_NAVIGATION_MESSAGE_TYPE_GPS_L2CNAV GNSS_NAVIGATION_MESSAGE_TYPE_GNSS_L2CNAV
 #define GNSS_NAVIGATION_MESSAGE_TYPE_GPS_L5CNAV GNSS_NAVIGATION_MESSAGE_TYPE_GNSS_L5CNAV
 #define GNSS_NAVIGATION_MESSAGE_TYPE_GPS_CNAV2 GNSS_NAVIGATION_MESSAGE_TYPE_GNSS_CNAV2
+#define GPS_LOCATION_HAS_ACCURACY GPS_LOCATION_HAS_HORIZONTAL_ACCURACY
 
 /**
  * The id of this module
diff --git a/include/hardware/keymaster_defs.h b/include/hardware/keymaster_defs.h
index 5800019..7d1b348 100644
--- a/include/hardware/keymaster_defs.h
+++ b/include/hardware/keymaster_defs.h
@@ -150,6 +150,11 @@
                                                       included in attestation */
     KM_TAG_ATTESTATION_ID_MEID = KM_BYTES | 715,   /* Used to provide the device's MEID to be
                                                       included in attestation */
+    KM_TAG_ATTESTATION_ID_MANUFACTURER = KM_BYTES | 716, /* Used to provide the device's
+                                                            manufacturer name to be included in
+                                                            attestation */
+    KM_TAG_ATTESTATION_ID_MODEL = KM_BYTES | 717,  /* Used to provide the device's model name to be
+                                                      included in attestation */
 
     /* Tags used only to provide data to or receive data from operations */
     KM_TAG_ASSOCIATED_DATA = KM_BYTES | 1000, /* Used to provide associated data for AEAD modes. */
@@ -291,7 +296,6 @@
     KM_PURPOSE_SIGN = 2,       /* Usable with RSA, EC and HMAC keys. */
     KM_PURPOSE_VERIFY = 3,     /* Usable with RSA, EC and HMAC keys. */
     KM_PURPOSE_DERIVE_KEY = 4, /* Usable with EC keys. */
-    KM_PURPOSE_WRAP_KEY = 5,   /* Usable with wrapping keys. */
 } keymaster_purpose_t;
 
 typedef struct {
diff --git a/include/hardware/nfc-base.h b/include/hardware/nfc-base.h
index c9ae962..6b63ad2 100644
--- a/include/hardware/nfc-base.h
+++ b/include/hardware/nfc-base.h
@@ -1,5 +1,6 @@
 // This file is autogenerated by hidl-gen. Do not edit manually.
 // Source: android.hardware.nfc@1.0
+// Root: android.hardware:hardware/interfaces
 
 #ifndef HIDL_GENERATED_ANDROID_HARDWARE_NFC_V1_0_EXPORTED_CONSTANTS_H_
 #define HIDL_GENERATED_ANDROID_HARDWARE_NFC_V1_0_EXPORTED_CONSTANTS_H_
diff --git a/include/hardware/sensors-base.h b/include/hardware/sensors-base.h
index 80ea3a7..b0f6223 100644
--- a/include/hardware/sensors-base.h
+++ b/include/hardware/sensors-base.h
@@ -1,5 +1,6 @@
 // This file is autogenerated by hidl-gen. Do not edit manually.
 // Source: android.hardware.sensors@1.0
+// Root: android.hardware:hardware/interfaces
 
 #ifndef HIDL_GENERATED_ANDROID_HARDWARE_SENSORS_V1_0_EXPORTED_CONSTANTS_H_
 #define HIDL_GENERATED_ANDROID_HARDWARE_SENSORS_V1_0_EXPORTED_CONSTANTS_H_
diff --git a/modules/Android.mk b/modules/Android.mk
index 2a58b3e..462081d 100644
--- a/modules/Android.mk
+++ b/modules/Android.mk
@@ -1,4 +1,14 @@
-hardware_modules := gralloc hwcomposer \
-	usbaudio audio_remote_submix camera usbcamera sensors \
-	input vehicle thermal vr
+hardware_modules := \
+    audio_remote_submix \
+    camera \
+    gralloc \
+    hwcomposer \
+    input \
+    radio \
+    sensors \
+    thermal \
+    usbaudio \
+    usbcamera \
+    vehicle \
+    vr
 include $(call all-named-subdir-makefiles,$(hardware_modules))
diff --git a/modules/README.android b/modules/README.android
index 57abb72..7ffc0f4 100644
--- a/modules/README.android
+++ b/modules/README.android
@@ -4,13 +4,13 @@
 libhardware.so eventually should contain *just* the HAL hub
 (hardware.c), everything in it should be rewritten as modules.
 
-Modules are .so in /system/libs/hw/ and have a well defined naming
+Modules are .so in /vendor/lib/hw/ and have a well defined naming
 convention:
 
-    /system/libs/hw/<*_HARDWARE_MODULE_ID>.<ro.product.board>.so
-    /system/libs/hw/<*_HARDWARE_MODULE_ID>.<ro.board.platform>.so
-    /system/libs/hw/<*_HARDWARE_MODULE_ID>.<ro.arch>.so
-    /system/libs/hw/<*_HARDWARE_MODULE_ID>.default.so
+    /vendor/lib/hw/<*_HARDWARE_MODULE_ID>.<ro.product.board>.so
+    /vendor/lib/hw/<*_HARDWARE_MODULE_ID>.<ro.board.platform>.so
+    /vendor/lib/hw/<*_HARDWARE_MODULE_ID>.<ro.arch>.so
+    /vendor/lib/hw/<*_HARDWARE_MODULE_ID>.default.so
 
 They also have a well defined interface which lives in include/hardware/.
 
diff --git a/modules/audio/Android.bp b/modules/audio/Android.bp
index 69e99f9..bd23b03 100644
--- a/modules/audio/Android.bp
+++ b/modules/audio/Android.bp
@@ -21,6 +21,7 @@
 cc_library_shared {
     name: "audio.primary.default",
     relative_install_path: "hw",
+    proprietary: true,
     srcs: ["audio_hw.c"],
     shared_libs: [
         "liblog",
@@ -38,6 +39,7 @@
 cc_library_shared {
     name: "audio.stub.default",
     relative_install_path: "hw",
+    proprietary: true,
     srcs: ["audio_hw.c"],
     shared_libs: [
         "liblog",
@@ -51,6 +53,7 @@
 cc_library_shared {
     name: "audio_policy.stub",
     relative_install_path: "hw",
+    proprietary: true,
     srcs: ["audio_policy.c"],
     shared_libs: [
         "liblog",
diff --git a/modules/audio_remote_submix/Android.mk b/modules/audio_remote_submix/Android.mk
index d0c8ffc..c9e851f 100644
--- a/modules/audio_remote_submix/Android.mk
+++ b/modules/audio_remote_submix/Android.mk
@@ -18,6 +18,7 @@
 
 LOCAL_MODULE := audio.r_submix.default
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_SRC_FILES := \
 	audio_hw.cpp
 LOCAL_C_INCLUDES += \
diff --git a/modules/consumerir/Android.bp b/modules/consumerir/Android.bp
index bbce6b1..2bbdc04 100644
--- a/modules/consumerir/Android.bp
+++ b/modules/consumerir/Android.bp
@@ -15,6 +15,7 @@
 cc_library_shared {
     name: "consumerir.default",
     relative_install_path: "hw",
+    proprietary: true,
     srcs: ["consumerir.c"],
     shared_libs: [
         "liblog",
diff --git a/modules/fingerprint/Android.bp b/modules/fingerprint/Android.bp
index a66f9f9..ba749e4 100644
--- a/modules/fingerprint/Android.bp
+++ b/modules/fingerprint/Android.bp
@@ -15,6 +15,7 @@
 cc_library_shared {
     name: "fingerprint.default",
     relative_install_path: "hw",
+    proprietary: true,
     srcs: ["fingerprint.c"],
     shared_libs: ["liblog"],
 }
diff --git a/modules/gralloc/Android.mk b/modules/gralloc/Android.mk
index 092e851..cdd8d07 100644
--- a/modules/gralloc/Android.mk
+++ b/modules/gralloc/Android.mk
@@ -20,6 +20,7 @@
 include $(CLEAR_VARS)
 
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_SHARED_LIBRARIES := liblog libcutils
 
 LOCAL_SRC_FILES := 	\
diff --git a/modules/hwcomposer/Android.mk b/modules/hwcomposer/Android.mk
index 35c0fae..da0f6db 100644
--- a/modules/hwcomposer/Android.mk
+++ b/modules/hwcomposer/Android.mk
@@ -20,6 +20,7 @@
 include $(CLEAR_VARS)
 
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_SHARED_LIBRARIES := liblog libEGL
 LOCAL_SRC_FILES := hwcomposer.cpp
 LOCAL_MODULE := hwcomposer.default
diff --git a/modules/input/evdev/Android.mk b/modules/input/evdev/Android.mk
index 9a5d092..be4db6b 100644
--- a/modules/input/evdev/Android.mk
+++ b/modules/input/evdev/Android.mk
@@ -45,6 +45,7 @@
 
 LOCAL_MODULE := input.evdev.default
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 
 LOCAL_SRC_FILES := \
     EvdevModule.cpp
diff --git a/modules/local_time/Android.bp b/modules/local_time/Android.bp
index df32325..643afa5 100644
--- a/modules/local_time/Android.bp
+++ b/modules/local_time/Android.bp
@@ -24,6 +24,7 @@
 cc_library_shared {
     name: "local_time.default",
     relative_install_path: "hw",
+    proprietary: true,
     srcs: ["local_time_hw.c"],
     shared_libs: [
         "liblog",
diff --git a/modules/nfc-nci/Android.bp b/modules/nfc-nci/Android.bp
index fc73761..90d2a28 100644
--- a/modules/nfc-nci/Android.bp
+++ b/modules/nfc-nci/Android.bp
@@ -15,6 +15,7 @@
 cc_library_shared {
     name: "nfc_nci.default",
     relative_install_path: "hw",
+    proprietary: true,
     srcs: ["nfc_nci_example.c"],
     shared_libs: [
         "liblog",
diff --git a/modules/nfc/Android.bp b/modules/nfc/Android.bp
index bd93bb5..5f174f4 100644
--- a/modules/nfc/Android.bp
+++ b/modules/nfc/Android.bp
@@ -15,6 +15,7 @@
 cc_library_shared {
     name: "nfc.default",
     relative_install_path: "hw",
+    proprietary: true,
     srcs: ["nfc_pn544_example.c"],
     shared_libs: [
         "liblog",
diff --git a/modules/power/Android.bp b/modules/power/Android.bp
index 2b86c8b..f4c74ce 100644
--- a/modules/power/Android.bp
+++ b/modules/power/Android.bp
@@ -15,6 +15,7 @@
 cc_library_shared {
     name: "power.default",
     relative_install_path: "hw",
+    proprietary: true,
     srcs: ["power.c"],
     shared_libs: ["liblog"],
 }
diff --git a/modules/radio/Android.mk b/modules/radio/Android.mk
index 221424f..6f11169 100644
--- a/modules/radio/Android.mk
+++ b/modules/radio/Android.mk
@@ -21,6 +21,7 @@
 
 LOCAL_MODULE := radio.fm.default
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_SRC_FILES := radio_hw.c
 LOCAL_SHARED_LIBRARIES := liblog libcutils libradio_metadata
 LOCAL_MODULE_TAGS := optional
diff --git a/modules/radio/radio_hw.c b/modules/radio/radio_hw.c
index 150d173..4010507 100644
--- a/modules/radio/radio_hw.c
+++ b/modules/radio/radio_hw.c
@@ -501,6 +501,10 @@
         status = -EINVAL;
         goto exit;
     }
+    if (config->lower_limit > config->upper_limit) {
+        status = -EINVAL;
+        goto exit;
+    }
     send_command_l(stub_tuner, CMD_CANCEL, 0, NULL);
     send_command_l(stub_tuner, CMD_CONFIG, 500, (void *)config);
 
@@ -613,7 +617,12 @@
     metadata = info->metadata;
     *info = stub_tuner->program;
     info->metadata = metadata;
-    if (metadata != NULL && stub_tuner->program.metadata != NULL)
+    if (metadata == NULL) {
+        ALOGE("%s metadata is a nullptr", __func__);
+        status = -EINVAL;
+        goto exit;
+    }
+    if (stub_tuner->program.metadata != NULL)
         radio_metadata_add_metadata(&info->metadata, stub_tuner->program.metadata);
 
 exit:
diff --git a/modules/sensors/Android.mk b/modules/sensors/Android.mk
index 534e6e9..ca277e6 100644
--- a/modules/sensors/Android.mk
+++ b/modules/sensors/Android.mk
@@ -23,6 +23,7 @@
 LOCAL_MODULE := sensors.$(TARGET_DEVICE)
 
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 
 LOCAL_CFLAGS := -DLOG_TAG=\"MultiHal\"
 
diff --git a/modules/sensors/dynamic_sensor/Android.mk b/modules/sensors/dynamic_sensor/Android.mk
new file mode 100644
index 0000000..07bc5e8
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/Android.mk
@@ -0,0 +1,77 @@
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+COMMON_CFLAGS := -Wall -Werror -Wextra
+
+#
+# There are two ways to utilize the dynamic sensor module:
+#   1. Use as an extension in an existing hal: declare dependency on libdynamic_sensor_ext shared
+#      library in existing sensor hal.
+#   2. Use as a standalone sensor HAL and configure multihal to combine it with sensor hal that
+#      hosts other sensors: add dependency on sensors.dynamic_sensor_hal in device level makefile and
+#      write multihal configuration file accordingly.
+#
+# Please take only one of these two options to avoid conflict over hardware resource.
+#
+
+#
+# Option 1: sensor extension module
+#
+include $(CLEAR_VARS)
+LOCAL_MODULE := libdynamic_sensor_ext
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_OWNER := google
+
+LOCAL_CFLAGS += $(COMMON_CFLAGS) -DLOG_TAG=\"DynamicSensorExt\"
+
+LOCAL_SRC_FILES := \
+    BaseSensorObject.cpp \
+    DynamicSensorManager.cpp \
+    RingBuffer.cpp
+
+LOCAL_SHARED_LIBRARIES := \
+    libcutils \
+    libutils \
+    liblog
+
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
+
+include $(BUILD_SHARED_LIBRARY)
+
+#
+# Option 2: independent sensor hal
+#
+include $(CLEAR_VARS)
+LOCAL_MODULE := sensors.dynamic_sensor_hal
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_OWNER := google
+
+LOCAL_CFLAGS += $(COMMON_CFLAGS) -DLOG_TAG=\"DynamicSensorHal\"
+
+LOCAL_SRC_FILES := \
+    BaseSensorObject.cpp \
+    DynamicSensorManager.cpp \
+    RingBuffer.cpp \
+    sensors.cpp
+
+LOCAL_SHARED_LIBRARIES := \
+    libcutils \
+    libutils \
+    liblog \
+
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/modules/sensors/dynamic_sensor/BaseDynamicSensorDaemon.h b/modules/sensors/dynamic_sensor/BaseDynamicSensorDaemon.h
new file mode 100644
index 0000000..29cf7a4
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/BaseDynamicSensorDaemon.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SENSORHAL_EXT_BASE_DYNAMIC_SENSOR_DAEMON_H
+#define ANDROID_SENSORHAL_EXT_BASE_DYNAMIC_SENSOR_DAEMON_H
+
+#include <utils/RefBase.h>
+
+namespace android {
+namespace SensorHalExt {
+
+class DynamicSensorManager;
+
+class BaseDynamicSensorDaemon : public RefBase {
+public:
+    BaseDynamicSensorDaemon(DynamicSensorManager& manager) : mManager(manager) {}
+    virtual ~BaseDynamicSensorDaemon() = default;
+protected:
+    DynamicSensorManager& mManager;
+};
+
+} // namespace SensorHalExt
+} // namespace android
+
+#endif // ANDROID_SENSORHAL_EXT_BASE_DYNAMIC_SENSOR_DAEMON_H
+
diff --git a/modules/sensors/dynamic_sensor/BaseSensorObject.cpp b/modules/sensors/dynamic_sensor/BaseSensorObject.cpp
new file mode 100644
index 0000000..189e87f
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/BaseSensorObject.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BaseSensorObject.h"
+#include "SensorEventCallback.h"
+
+#include <utils/Log.h>
+#include <cstring>
+
+namespace android {
+namespace SensorHalExt {
+
+BaseSensorObject::BaseSensorObject() : mCallback(nullptr) {
+}
+
+bool BaseSensorObject::setEventCallback(SensorEventCallback* callback) {
+    if (mCallback != nullptr) {
+        ALOGE("callback is already assigned, cannot change.");
+        return false;
+    }
+    mCallback = callback;
+    return true;
+}
+
+void BaseSensorObject::getUuid(uint8_t* uuid) const {
+    // default uuid denoting uuid feature is not supported on this sensor.
+    memset(uuid, 0, 16);
+}
+
+int BaseSensorObject::flush() {
+    static const sensors_event_t event = {
+        .type = SENSOR_TYPE_META_DATA,
+        .timestamp = TIMESTAMP_AUTO_FILL  // timestamp will be filled at dispatcher
+    };
+    generateEvent(event);
+    return 0;
+}
+
+void BaseSensorObject::generateEvent(const sensors_event_t &e) {
+    if (mCallback) {
+        mCallback->submitEvent(this, e);
+    }
+}
+
+} // namespace SensorHalExt
+} // namespace android
+
diff --git a/modules/sensors/dynamic_sensor/BaseSensorObject.h b/modules/sensors/dynamic_sensor/BaseSensorObject.h
new file mode 100644
index 0000000..326e138
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/BaseSensorObject.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SENSORHAL_BASE_SENSOR_OBJECT_H
+#define ANDROID_SENSORHAL_BASE_SENSOR_OBJECT_H
+
+#include <utils/RefBase.h>
+#include <utils/Timers.h> // for nsecs_t
+#include <cstdint>
+
+struct sensor_t;
+struct sensors_event_t;
+
+namespace android {
+namespace SensorHalExt {
+
+class SensorEventCallback;
+
+class BaseSensorObject : virtual public RefBase {
+public:
+    BaseSensorObject();
+    virtual ~BaseSensorObject() = default;
+
+    // always called by DynamicSensorManager, callback must point to
+    // valid object throughout life cycle of BaseSensorObject
+    bool setEventCallback(SensorEventCallback* callback);
+
+    // virtual functions to get sensor information and operate sensor
+    virtual const sensor_t* getSensor() const = 0;
+
+    // get uuid of sensor, default implementation set it to all zero, means does not have a uuid.
+    virtual void getUuid(uint8_t* uuid) const;
+
+    // enable sensor
+    virtual int enable(bool enable) = 0;
+
+    // set sample period and batching period of sensor.
+    virtual int batch(nsecs_t samplePeriod, nsecs_t batchPeriod) = 0;
+
+    // flush sensor, default implementation will send a flush complete event back.
+    virtual int flush();
+
+protected:
+    // utility function for sub-class
+    void generateEvent(const sensors_event_t &e);
+private:
+    SensorEventCallback* mCallback;
+};
+
+} // namespace SensorHalExt
+} // namespace android
+
+#endif // ANDROID_SENSORHAL_BASE_SENSOR_OBJECT_H
+
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp b/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp
new file mode 100644
index 0000000..d33650c
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp
@@ -0,0 +1,283 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BaseDynamicSensorDaemon.h"
+#include "BaseSensorObject.h"
+#include "DynamicSensorManager.h"
+
+#include <utils/Log.h>
+#include <utils/SystemClock.h>
+
+#include <cassert>
+
+namespace android {
+namespace SensorHalExt {
+
+DynamicSensorManager* DynamicSensorManager::createInstance(
+        int handleBase, int handleCount, SensorEventCallback *callback) {
+    auto m = new DynamicSensorManager(handleBase, handleBase + handleCount - 1, callback);
+    return m;
+}
+
+DynamicSensorManager::DynamicSensorManager(
+        int handleBase, int handleMax, SensorEventCallback* callback) :
+        mHandleRange(handleBase, handleMax),
+        mCallback(callback),
+        mFifo(callback ? 0 : kFifoSize),
+        mNextHandle(handleBase+1) {
+    assert(handleBase > 0 && handleMax > handleBase + 1); // handleBase is reserved
+
+    mMetaSensor = (const sensor_t) {
+        "Dynamic Sensor Manager",
+        "Google",
+        1,                                          // version
+        handleBase,                                 // handle
+        SENSOR_TYPE_DYNAMIC_SENSOR_META,
+        1,                                          // maxRange
+        1,                                          // resolution
+        1e-6f,                                      // power, very small number instead of 0
+                                                    // to avoid sigularity in app
+        (int32_t)(1000),                            // minDelay
+        0,                                          // fifoReservedEventCount
+        0,                                          // fifoMaxEventCount
+        SENSOR_STRING_TYPE_DYNAMIC_SENSOR_META,
+        "",                                         // requiredPermission
+        (long)(1000),                               // maxDelay
+        SENSOR_FLAG_SPECIAL_REPORTING_MODE | SENSOR_FLAG_WAKE_UP,
+        { NULL, NULL }
+    };
+}
+
+DynamicSensorManager::~DynamicSensorManager() {
+    // free all daemons first
+    mDaemonVector.clear();
+}
+
+bool DynamicSensorManager::owns(int handle) const {
+    return handle >= mHandleRange.first && handle < mHandleRange.second;
+}
+
+int DynamicSensorManager::activate(int handle, bool enable) {
+    if (handle == mHandleRange.first) {
+        // ignored
+        return 0;
+    }
+
+    // in case there is a pending report, now it is time to remove it as it is no longer necessary.
+    {
+        std::lock_guard<std::mutex> lk(mLock);
+        mPendingReport.erase(handle);
+    }
+
+    return operateSensor(handle,
+            [&enable] (sp<BaseSensorObject> s)->int {
+                return s->enable(enable);
+            });
+}
+
+int DynamicSensorManager::batch(int handle, nsecs_t sample_period, nsecs_t batch_period) {
+    if (handle == mHandleRange.first) {
+        // ignored
+        return 0;
+    }
+    return operateSensor(handle,
+            [&sample_period, &batch_period] (sp<BaseSensorObject> s)->int {
+                return s->batch(sample_period, batch_period);
+            });
+}
+
+int DynamicSensorManager::setDelay(int handle, nsecs_t sample_period) {
+    return batch(handle, sample_period, 0);
+}
+
+int DynamicSensorManager::flush(int handle) {
+    if (handle == mHandleRange.first) {
+        // TODO: submit a flush complete here
+        static const sensors_event_t event = {
+            .type = SENSOR_TYPE_META_DATA,
+            .sensor = mHandleRange.first,
+            .timestamp = TIMESTAMP_AUTO_FILL,  // timestamp will be filled at dispatcher
+        };
+        submitEvent(nullptr, event);
+        return 0;
+    }
+    return operateSensor(handle, [] (sp<BaseSensorObject> s)->int {return s->flush();});
+}
+
+int DynamicSensorManager::poll(sensors_event_t * data, int count) {
+    assert(mCallback == nullptr);
+    std::lock_guard<std::mutex> lk(mFifoLock);
+    return mFifo.read(data, count);
+}
+
+bool DynamicSensorManager::registerSensor(sp<BaseSensorObject> sensor) {
+    std::lock_guard<std::mutex> lk(mLock);
+    if (mReverseMap.find(sensor.get()) != mReverseMap.end()) {
+        ALOGE("trying to add the same sensor twice, ignore");
+        return false;
+    }
+    int handle = getNextAvailableHandle();
+    if (handle < 0) {
+        ALOGE("Running out of handle, quit.");
+        return false;
+    }
+
+    // these emplace will always be successful
+    mMap.emplace(handle, sensor);
+    mReverseMap.emplace(sensor.get(), handle);
+    sensor->setEventCallback(this);
+
+    auto entry = mPendingReport.emplace(
+            std::piecewise_construct,
+            std::forward_as_tuple(handle),
+            std::forward_as_tuple(handle, sensor));
+    if (entry.second) {
+        submitEvent(nullptr, entry.first->second.generateConnectionEvent(mHandleRange.first));
+    }
+    return entry.second;
+}
+
+void DynamicSensorManager::unregisterSensor(sp<BaseSensorObject> sensor) {
+    std::lock_guard<std::mutex> lk(mLock);
+    auto i = mReverseMap.find(sensor.get());
+    if (i == mReverseMap.end()) {
+        ALOGE("cannot remove a non-exist sensor");
+        return;
+    }
+    int handle = i->second;
+    mReverseMap.erase(i);
+    mMap.erase(handle);
+
+    // will not clean up mPendingReport here, it will be cleaned up when at first activate call.
+    // sensorservice is guranteed to call activate upon arrival of dynamic sensor meta connection
+    // event.
+
+    // send disconnection event
+    sensors_event_t event;
+    ConnectionReport::fillDisconnectionEvent(&event, mHandleRange.first, handle);
+    submitEvent(nullptr, event);
+}
+
+int DynamicSensorManager::submitEvent(sp<BaseSensorObject> source, const sensors_event_t &e) {
+    int handle;
+    if (source == nullptr) {
+        handle = mHandleRange.first;
+    } else {
+        std::lock_guard<std::mutex> lk(mLock);
+        auto i = mReverseMap.find(source.get());
+        if (i == mReverseMap.end()) {
+            ALOGE("cannot submit event for sensor that has not been registered");
+            return NAME_NOT_FOUND;
+        }
+        handle = i->second;
+    }
+
+    // making a copy of events, prepare for editing
+    sensors_event_t event = e;
+    event.version = sizeof(event);
+
+    // special case of flush complete
+    if (event.type == SENSOR_TYPE_META_DATA) {
+        event.sensor = 0;
+        event.meta_data.sensor = handle;
+    } else {
+        event.sensor = handle;
+    }
+
+    // set timestamp if it is default value
+    if (event.timestamp == TIMESTAMP_AUTO_FILL) {
+        event.timestamp = elapsedRealtimeNano();
+    }
+
+    if (mCallback) {
+        // extention mode, calling callback directly
+        int ret;
+
+        ret = mCallback->submitEvent(nullptr, event);
+        if (ret < 0) {
+            ALOGE("DynamicSensorManager callback failed, ret: %d", ret);
+        }
+    } else {
+        // standalone mode, add event to internal buffer for poll() to pick up
+        std::lock_guard<std::mutex> lk(mFifoLock);
+        if (mFifo.write(&event, 1) < 0) {
+            ALOGE("DynamicSensorManager fifo full");
+        }
+    }
+    return 0;
+}
+
+int DynamicSensorManager::getNextAvailableHandle() {
+    if (mNextHandle == mHandleRange.second) {
+        return -1;
+    }
+    return mNextHandle++;
+}
+
+const sensor_t& DynamicSensorManager::getDynamicMetaSensor() const {
+    return mMetaSensor;
+}
+
+DynamicSensorManager::ConnectionReport::ConnectionReport(
+        int handle, sp<BaseSensorObject> sensor) :
+        mSensor(*(sensor->getSensor())),
+        mName(mSensor.name),
+        mVendor(mSensor.vendor),
+        mPermission(mSensor.requiredPermission),
+        mStringType(mSensor.stringType),
+        mGenerated(false) {
+    mSensor.name = mName.c_str();
+    mSensor.vendor = mVendor.c_str();
+    mSensor.requiredPermission = mPermission.c_str();
+    mSensor.stringType = mStringType.c_str();
+    mSensor.handle = handle;
+    memset(&mEvent, 0, sizeof(mEvent));
+    mEvent.version = sizeof(mEvent);
+    sensor->getUuid(mUuid);
+    ALOGV("Connection report init: name = %s, handle = %d", mSensor.name, mSensor.handle);
+}
+
+DynamicSensorManager::ConnectionReport::~ConnectionReport() {
+    ALOGV("Connection report dtor: name = %s, handle = %d", mSensor.name, mSensor.handle);
+}
+
+const sensors_event_t& DynamicSensorManager::ConnectionReport::
+        generateConnectionEvent(int metaHandle) {
+    if (!mGenerated) {
+        mEvent.sensor = metaHandle;
+        mEvent.type = SENSOR_TYPE_DYNAMIC_SENSOR_META;
+        mEvent.timestamp = elapsedRealtimeNano();
+        mEvent.dynamic_sensor_meta =
+                (dynamic_sensor_meta_event_t) {true, mSensor.handle, &mSensor, {0}};
+        memcpy(&mEvent.dynamic_sensor_meta.uuid, &mUuid, sizeof(mEvent.dynamic_sensor_meta.uuid));
+        mGenerated = true;
+    }
+    return mEvent;
+}
+
+void DynamicSensorManager::ConnectionReport::
+        fillDisconnectionEvent(sensors_event_t* event, int metaHandle, int handle) {
+    memset(event, 0, sizeof(sensors_event_t));
+    event->version = sizeof(sensors_event_t);
+    event->sensor = metaHandle;
+    event->type = SENSOR_TYPE_DYNAMIC_SENSOR_META;
+    event->timestamp = elapsedRealtimeNano();
+    event->dynamic_sensor_meta.connected = false;
+    event->dynamic_sensor_meta.handle = handle;
+}
+
+} // namespace SensorHalExt
+} // namespace android
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorManager.h b/modules/sensors/dynamic_sensor/DynamicSensorManager.h
new file mode 100644
index 0000000..b8fd472
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/DynamicSensorManager.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SENSORHAL_EXT_DYNAMIC_SENSOR_MANAGER_H
+#define ANDROID_SENSORHAL_EXT_DYNAMIC_SENSOR_MANAGER_H
+
+#include "SensorEventCallback.h"
+#include "RingBuffer.h"
+#include <hardware/sensors.h>
+#include <utils/RefBase.h>
+
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace android {
+namespace SensorHalExt {
+
+class BaseDynamicSensorDaemon;
+
+class DynamicSensorManager : public SensorEventCallback {
+public:
+    // handleBase is reserved for the dynamic sensor meta sensor.
+    // handleMax must be greater than handleBase + 1.
+    // This class has two operation mode depending on callback: 1) extension, 2) stand-alone.
+    // In extension mode, callback must not be nullptr. Sensor event generated will be submitted to
+    // buffer of primary sensor HAL implementation. In stand-alone mode, callback must be nullptr.
+    // Generated sensor events will be added into internal buffer waiting for poll() function to
+    // pick up.
+    //
+    static DynamicSensorManager* createInstance(
+            int handleBase, int handleCount, SensorEventCallback *callback);
+    virtual ~DynamicSensorManager();
+
+    // calls to add or remove sensor, called from sensor daemon
+    bool registerSensor(sp<BaseSensorObject> sensor);
+    void unregisterSensor(sp<BaseSensorObject> sensor);
+
+    // Determine if a sensor handle is in the range defined in constructor.
+    // It does not test if sensor handle is valid.
+    bool owns(int handle) const;
+
+    // handles sensor hal requests.
+    int activate(int handle, bool enable);
+    int batch(int handle, nsecs_t sample_period, nsecs_t batch_period);
+    int setDelay(int handle, nsecs_t sample_period);
+    int flush(int handle);
+    int poll(sensors_event_t * data, int count);
+
+    // SensorEventCallback
+    virtual int submitEvent(sp<BaseSensorObject>, const sensors_event_t &e) override;
+
+    // get meta sensor struct
+    const sensor_t& getDynamicMetaSensor() const;
+protected:
+    DynamicSensorManager(int handleBase, int handleMax, SensorEventCallback* callback);
+private:
+    // a helper class used for generate connection and disconnection report
+    class ConnectionReport {
+    public:
+        ConnectionReport() {}
+        ConnectionReport(int handle, sp<BaseSensorObject> sensor);
+        ~ConnectionReport();
+        const sensors_event_t& generateConnectionEvent(int metaHandle);
+        static void fillDisconnectionEvent(sensors_event_t* event, int metaHandle, int handle);
+    private:
+        sensor_t mSensor;
+        std::string mName;
+        std::string mVendor;
+        std::string mPermission;
+        std::string mStringType;
+        sensors_event_t mEvent;
+        uint8_t mUuid[16];
+        bool mGenerated;
+        DISALLOW_EVIL_CONSTRUCTORS(ConnectionReport);
+    };
+
+    // returns next available handle to use upon a new sensor connection, or -1 if we run out.
+    int getNextAvailableHandle();
+
+    // TF:  int foo(sp<BaseSensorObject> obj);
+    template <typename TF>
+    int operateSensor(int handle, TF f) const {
+        std::lock_guard<std::mutex> lk(mLock);
+        const auto i = mMap.find(handle);
+        if (i == mMap.end()) {
+            return BAD_VALUE;
+        }
+        sp<BaseSensorObject> s = i->second.promote();
+        if (s == nullptr) {
+            // sensor object is already gone
+            return BAD_VALUE;
+        }
+        return f(s);
+    }
+
+    // available sensor handle space
+    const std::pair<int, int> mHandleRange;
+    sensor_t mMetaSensor;
+
+    // immutable pointer to event callback, used in extention mode.
+    SensorEventCallback * const mCallback;
+
+    // RingBuffer used in standalone mode
+    static constexpr size_t kFifoSize = 4096; //4K events
+    mutable std::mutex mFifoLock;
+    RingBuffer mFifo;
+
+    // mapping between handle and SensorObjects
+    mutable std::mutex mLock;
+    int mNextHandle;
+    std::unordered_map<int, wp<BaseSensorObject> > mMap;
+    std::unordered_map<void *, int> mReverseMap;
+    mutable std::unordered_map<int, ConnectionReport> mPendingReport;
+
+    // daemons
+    std::vector<sp<BaseDynamicSensorDaemon>> mDaemonVector;
+};
+
+} // namespace SensorHalExt
+} // namespace android
+
+#endif // ANDROID_SENSORHAL_EXT_DYNAMIC_SENSOR_MANAGER_H
diff --git a/modules/sensors/dynamic_sensor/RingBuffer.cpp b/modules/sensors/dynamic_sensor/RingBuffer.cpp
new file mode 100644
index 0000000..5857a7c
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/RingBuffer.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "RingBuffer.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace android {
+
+RingBuffer::RingBuffer(size_t size)
+    : mSize(size),
+      mData((sensors_event_t *)malloc(sizeof(sensors_event_t) * mSize)),
+      mReadPos(0),
+      mWritePos(0) {
+}
+
+RingBuffer::~RingBuffer() {
+    free(mData);
+    mData = NULL;
+}
+
+ssize_t RingBuffer::write(const sensors_event_t *ev, size_t size) {
+    Mutex::Autolock autoLock(mLock);
+
+    size_t numAvailableToRead = mWritePos - mReadPos;
+    size_t numAvailableToWrite = mSize - numAvailableToRead;
+
+    if (size > numAvailableToWrite) {
+        size = numAvailableToWrite;
+    }
+
+    size_t writePos = (mWritePos % mSize);
+    size_t copy = mSize - writePos;
+
+    if (copy > size) {
+        copy = size;
+    }
+
+    memcpy(&mData[writePos], ev, copy * sizeof(sensors_event_t));
+
+    if (size > copy) {
+        memcpy(mData, &ev[copy], (size - copy) * sizeof(sensors_event_t));
+    }
+
+    mWritePos += size;
+
+    if (numAvailableToRead == 0 && size > 0) {
+        mNotEmptyCondition.broadcast();
+    }
+
+    return size;
+}
+
+ssize_t RingBuffer::read(sensors_event_t *ev, size_t size) {
+    Mutex::Autolock autoLock(mLock);
+
+    size_t numAvailableToRead;
+    for (;;) {
+        numAvailableToRead = mWritePos - mReadPos;
+        if (numAvailableToRead > 0) {
+            break;
+        }
+
+        mNotEmptyCondition.wait(mLock);
+    }
+
+    if (size > numAvailableToRead) {
+        size = numAvailableToRead;
+    }
+
+    size_t readPos = (mReadPos % mSize);
+    size_t copy = mSize - readPos;
+
+    if (copy > size) {
+        copy = size;
+    }
+
+    memcpy(ev, &mData[readPos], copy * sizeof(sensors_event_t));
+
+    if (size > copy) {
+        memcpy(&ev[copy], mData, (size - copy) * sizeof(sensors_event_t));
+    }
+
+    mReadPos += size;
+
+    return size;
+}
+
+}  // namespace android
+
diff --git a/modules/sensors/dynamic_sensor/RingBuffer.h b/modules/sensors/dynamic_sensor/RingBuffer.h
new file mode 100644
index 0000000..aa6b8c9
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/RingBuffer.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RING_BUFFER_H_
+
+#define RING_BUFFER_H_
+
+#include <media/stagefright/foundation/ABase.h>
+
+#include <hardware/sensors.h>
+#include <utils/threads.h>
+
+namespace android {
+
+class RingBuffer {
+public:
+    explicit RingBuffer(size_t size);
+    ~RingBuffer();
+
+    ssize_t write(const sensors_event_t *ev, size_t size);
+    ssize_t read(sensors_event_t *ev, size_t size);
+
+private:
+    Mutex mLock;
+    Condition mNotEmptyCondition;
+
+    size_t mSize;
+    sensors_event_t *mData;
+    size_t mReadPos, mWritePos;
+
+    DISALLOW_EVIL_CONSTRUCTORS(RingBuffer);
+};
+
+}  // namespace android
+
+#endif  // RING_BUFFER_H_
diff --git a/modules/sensors/dynamic_sensor/SensorEventCallback.h b/modules/sensors/dynamic_sensor/SensorEventCallback.h
new file mode 100644
index 0000000..b98cd7f
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/SensorEventCallback.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SENSORHAL_DSE_SENSOR_EVENT_CALLBACK_H
+#define ANDROID_SENSORHAL_DSE_SENSOR_EVENT_CALLBACK_H
+
+#include <hardware/sensors.h>
+#include <utils/RefBase.h>
+
+namespace android {
+namespace SensorHalExt {
+
+class BaseSensorObject;
+
+// if timestamp in sensors_event_t has this value, it will be filled at dispatcher.
+constexpr int64_t TIMESTAMP_AUTO_FILL = -1;
+
+class SensorEventCallback {
+public:
+    virtual int submitEvent(sp<BaseSensorObject> sensor, const sensors_event_t &e) = 0;
+    virtual ~SensorEventCallback() = default;
+};
+
+} // namespace SensorHalExt
+} // namespace android
+
+#endif // ANDROID_SENSORHAL_DSE_SENSOR_EVENT_CALLBACK_H
diff --git a/modules/sensors/dynamic_sensor/sensors.cpp b/modules/sensors/dynamic_sensor/sensors.cpp
new file mode 100644
index 0000000..7c203b2
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/sensors.cpp
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "DynamicSensorManager.h"
+#include "sensors.h"
+
+#include <cutils/properties.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <utils/Log.h>
+
+#include <errno.h>
+#include <string.h>
+using namespace android;
+
+////////////////////////////////////////////////////////////////////////////////
+
+SensorContext::SensorContext(const struct hw_module_t *module) {
+    memset(&device, 0, sizeof(device));
+
+    device.common.tag = HARDWARE_DEVICE_TAG;
+    device.common.version = SENSORS_DEVICE_API_VERSION_1_3;
+    device.common.module = const_cast<hw_module_t *>(module);
+    device.common.close = CloseWrapper;
+    device.activate = ActivateWrapper;
+    device.setDelay = SetDelayWrapper;
+    device.poll = PollWrapper;
+    device.batch = BatchWrapper;
+    device.flush = FlushWrapper;
+
+    // initialize dynamic sensor manager
+    int32_t base = property_get_int32("sensor.dynamic_sensor_hal.handle_base", kDynamicHandleBase);
+    int32_t count =
+            property_get_int32("sensor.dynamic_sensor_hal.handle_count", kMaxDynamicHandleCount);
+    mDynamicSensorManager.reset(DynamicSensorManager::createInstance(base, count, nullptr));
+}
+
+int SensorContext::close() {
+    delete this;
+    return 0;
+}
+
+int SensorContext::activate(int handle, int enabled) {
+    return mDynamicSensorManager->activate(handle, enabled);
+}
+
+int SensorContext::setDelay(int handle, int64_t delayNs) {
+    return mDynamicSensorManager->setDelay(handle, delayNs);
+}
+
+int SensorContext::poll(sensors_event_t *data, int count) {
+    return mDynamicSensorManager->poll(data, count);
+}
+
+int SensorContext::batch(
+        int handle,
+        int64_t sampling_period_ns,
+        int64_t max_report_latency_ns) {
+    return mDynamicSensorManager->batch(handle, sampling_period_ns, max_report_latency_ns);
+}
+
+int SensorContext::flush(int handle) {
+    return mDynamicSensorManager->flush(handle);
+}
+
+// static
+int SensorContext::CloseWrapper(struct hw_device_t *dev) {
+    return reinterpret_cast<SensorContext *>(dev)->close();
+}
+
+// static
+int SensorContext::ActivateWrapper(
+        struct sensors_poll_device_t *dev, int handle, int enabled) {
+    return reinterpret_cast<SensorContext *>(dev)->activate(handle, enabled);
+}
+
+// static
+int SensorContext::SetDelayWrapper(
+        struct sensors_poll_device_t *dev, int handle, int64_t delayNs) {
+    return reinterpret_cast<SensorContext *>(dev)->setDelay(handle, delayNs);
+}
+
+// static
+int SensorContext::PollWrapper(
+        struct sensors_poll_device_t *dev, sensors_event_t *data, int count) {
+    return reinterpret_cast<SensorContext *>(dev)->poll(data, count);
+}
+
+// static
+int SensorContext::BatchWrapper(
+        struct sensors_poll_device_1 *dev,
+        int handle,
+        int flags,
+        int64_t sampling_period_ns,
+        int64_t max_report_latency_ns) {
+    (void) flags;
+    return reinterpret_cast<SensorContext *>(dev)->batch(
+            handle, sampling_period_ns, max_report_latency_ns);
+}
+
+// static
+int SensorContext::FlushWrapper(struct sensors_poll_device_1 *dev, int handle) {
+    return reinterpret_cast<SensorContext *>(dev)->flush(handle);
+}
+
+size_t SensorContext::getSensorList(sensor_t const **list) {
+    *list = &(mDynamicSensorManager->getDynamicMetaSensor());
+    return 1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+static sensor_t const *sensor_list;
+
+static int open_sensors(
+        const struct hw_module_t *module,
+        const char *,
+        struct hw_device_t **dev) {
+    SensorContext *ctx = new SensorContext(module);
+    ctx->getSensorList(&sensor_list);
+    *dev = &ctx->device.common;
+    return 0;
+}
+
+static struct hw_module_methods_t sensors_module_methods = {
+    .open = open_sensors
+};
+
+static int get_sensors_list(
+        struct sensors_module_t *,
+        struct sensor_t const **list) {
+    *list = sensor_list;
+    return 1;
+}
+
+static int set_operation_mode(unsigned int mode) {
+    return (mode) ? -EINVAL : 0;
+}
+
+struct sensors_module_t HAL_MODULE_INFO_SYM = {
+    .common = {
+            .tag = HARDWARE_MODULE_TAG,
+            .version_major = 1,
+            .version_minor = 0,
+            .id = SENSORS_HARDWARE_MODULE_ID,
+            .name = "Google Dynamic Sensor Manager",
+            .author = "Google",
+            .methods = &sensors_module_methods,
+            .dso  = NULL,
+            .reserved = {0},
+    },
+    .get_sensors_list = get_sensors_list,
+    .set_operation_mode = set_operation_mode,
+};
diff --git a/modules/sensors/dynamic_sensor/sensors.h b/modules/sensors/dynamic_sensor/sensors.h
new file mode 100644
index 0000000..be42b67
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/sensors.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2015 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 SENSORS_H_
+#define SENSORS_H_
+
+#include <hardware/hardware.h>
+#include <hardware/sensors.h>
+#include <media/stagefright/foundation/ABase.h>
+#include <utils/RefBase.h>
+
+#include <memory>
+#include <unordered_set>
+#include <vector>
+
+namespace android {
+    namespace SensorHalExt {
+        class DynamicSensorManager;
+    } // namespace BaseSensorObject
+} // namespace android
+
+using android::SensorHalExt::DynamicSensorManager;
+
+class SensorContext {
+public:
+    struct sensors_poll_device_1 device;
+
+    explicit SensorContext(const struct hw_module_t *module);
+
+    size_t getSensorList(sensor_t const **list);
+
+private:
+
+    int close();
+    int activate(int handle, int enabled);
+    int setDelay(int handle, int64_t delayNs);
+    int poll(sensors_event_t *data, int count);
+
+    int batch(int handle, int64_t sampling_period_ns,
+              int64_t max_report_latency_ns);
+
+    int flush(int handle);
+
+    // static wrappers
+    static int CloseWrapper(struct hw_device_t *dev);
+
+    static int ActivateWrapper(
+            struct sensors_poll_device_t *dev, int handle, int enabled);
+
+    static int SetDelayWrapper(
+            struct sensors_poll_device_t *dev, int handle, int64_t delayNs);
+
+    static int PollWrapper(
+            struct sensors_poll_device_t *dev, sensors_event_t *data, int count);
+
+    static int BatchWrapper(
+            struct sensors_poll_device_1 *dev,
+            int handle,
+            int flags,
+            int64_t sampling_period_ns,
+            int64_t max_report_latency_ns);
+
+    static int FlushWrapper(struct sensors_poll_device_1 *dev, int handle);
+
+    // default ~16 million handles for dynamic sensor use, can be overriden by system property
+    static constexpr int32_t kDynamicHandleBase = 0x10000;
+    static constexpr int32_t kDynamicHandleEnd = 0x1000000;
+    static constexpr int32_t kMaxDynamicHandleCount = kDynamicHandleEnd - kDynamicHandleBase;
+
+    std::unique_ptr<DynamicSensorManager> mDynamicSensorManager;
+
+    DISALLOW_EVIL_CONSTRUCTORS(SensorContext);
+};
+
+#endif  // SENSORS_H_
diff --git a/modules/soundtrigger/Android.mk b/modules/soundtrigger/Android.mk
index bb58053..8250f9b 100644
--- a/modules/soundtrigger/Android.mk
+++ b/modules/soundtrigger/Android.mk
@@ -19,6 +19,7 @@
 
 LOCAL_MODULE := sound_trigger.stub.default
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_SRC_FILES := sound_trigger_hw.c
 LOCAL_SHARED_LIBRARIES := liblog libcutils
 LOCAL_MODULE_TAGS := optional
diff --git a/modules/thermal/Android.mk b/modules/thermal/Android.mk
index 80ad78a..ff51145 100644
--- a/modules/thermal/Android.mk
+++ b/modules/thermal/Android.mk
@@ -18,6 +18,7 @@
 
 LOCAL_MODULE := thermal.default
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_SRC_FILES := thermal.c
 LOCAL_SHARED_LIBRARIES := liblog libcutils
 LOCAL_MODULE_TAGS := optional
diff --git a/modules/tv_input/Android.bp b/modules/tv_input/Android.bp
index beac132..509198d 100644
--- a/modules/tv_input/Android.bp
+++ b/modules/tv_input/Android.bp
@@ -15,6 +15,7 @@
 cc_library_shared {
     name: "tv_input.default",
     relative_install_path: "hw",
+    proprietary: true,
     shared_libs: [
         "libcutils",
         "liblog",
diff --git a/modules/usbaudio/Android.mk b/modules/usbaudio/Android.mk
index 9df1e79..b36bf9f 100644
--- a/modules/usbaudio/Android.mk
+++ b/modules/usbaudio/Android.mk
@@ -18,6 +18,7 @@
 
 LOCAL_MODULE := audio.usb.default
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_SRC_FILES := \
 	audio_hal.c
 LOCAL_C_INCLUDES += \
diff --git a/modules/vehicle/Android.mk b/modules/vehicle/Android.mk
index a666bc6..9fd49da 100644
--- a/modules/vehicle/Android.mk
+++ b/modules/vehicle/Android.mk
@@ -19,6 +19,7 @@
 LOCAL_MODULE := vehicle.default
 
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_C_INCLUDES := hardware/libhardware
 LOCAL_SRC_FILES := vehicle.c timeUtil.cpp
 LOCAL_SHARED_LIBRARIES := liblog libcutils libutils
diff --git a/modules/vibrator/Android.bp b/modules/vibrator/Android.bp
index f9afd45..3c4aebf 100644
--- a/modules/vibrator/Android.bp
+++ b/modules/vibrator/Android.bp
@@ -18,6 +18,7 @@
     // HAL module implementation stored in
     // hw/<VIBRATOR_HARDWARE_MODULE_ID>.default.so
     relative_install_path: "hw",
+    proprietary: true,
     include_dirs: ["hardware/libhardware"],
     srcs: ["vibrator.c"],
     shared_libs: ["liblog"],
diff --git a/modules/vibrator/vibrator.c b/modules/vibrator/vibrator.c
index c3c2951..92c46e2 100644
--- a/modules/vibrator/vibrator.c
+++ b/modules/vibrator/vibrator.c
@@ -32,16 +32,20 @@
 
 static const char THE_DEVICE[] = "/sys/class/timed_output/vibrator/enable";
 
-static int vibra_exists() {
+static bool device_exists(const char *file) {
     int fd;
 
-    fd = TEMP_FAILURE_RETRY(open(THE_DEVICE, O_RDWR));
+    fd = TEMP_FAILURE_RETRY(open(file, O_RDWR));
     if(fd < 0) {
-        return 0;
+        return false;
     }
 
     close(fd);
-    return 1;
+    return true;
+}
+
+static bool vibra_exists() {
+    return device_exists(THE_DEVICE);
 }
 
 static int write_value(const char *file, const char *value)
@@ -102,9 +106,13 @@
     return write_value(file_str, value);
 }
 
-static int vibra_led_exists()
+static bool vibra_led_exists()
 {
-    return !write_led_file("trigger", "transient");
+    int fd;
+    char file_str[50];
+
+    snprintf(file_str, sizeof(file_str), "%s/%s", LED_DEVICE, "activate");
+    return device_exists(file_str);
 }
 
 static int vibra_led_on(vibrator_device_t* vibradev __unused, unsigned int timeout_ms)
diff --git a/modules/vr/Android.mk b/modules/vr/Android.mk
index 43c8e92..e04c0da 100644
--- a/modules/vr/Android.mk
+++ b/modules/vr/Android.mk
@@ -18,6 +18,7 @@
 
 LOCAL_MODULE := vr.default
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_SRC_FILES := vr.c
 LOCAL_SHARED_LIBRARIES := libcutils
 LOCAL_MODULE_TAGS := optional
diff --git a/tests/vehicle/README b/tests/vehicle/README
index b8fc7d4..42d2210 100644
--- a/tests/vehicle/README
+++ b/tests/vehicle/README
@@ -49,13 +49,13 @@
 $ mmm hardware/libhardware
 
 This will generate the following binaries that we care about:
-i) out/target/product/XXX/system/lib/hw/vehicle.default.so
+i) out/target/product/XXX/vendor/lib/hw/vehicle.default.so
 ii) out/target/product/XXX/data/nativetest/vehicle_tests
 iii) out/target/product/XXX/system/bin/vehicle-hal-tool
 
 The location for the first shared library would be:
-$ adb push out/target/product/XXX/system/lib/hw/vehicle.default.so
-/system/lib/hw
+$ adb push out/target/product/XXX/vendor/lib/hw/vehicle.default.so
+/vendor/lib/hw
 You can also use 'adb sync' if you like, although this is the easiest least
 hassle way of putting it in place.