From 2ac7393bd8223e3b708fedb6c2b58753c0f7cb35 Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Fri, 10 Sep 2021 13:25:25 -0700
Subject: dynamic_sensor: Add stubbed sensor multi-HAL 2.1 support.

Bug: 195964858
Test: Verified the dynamic sensor sub-HAL initializes and non-dynamic
 sensors can sample.
Test: See details in testing done comment in
 https://googleplex-android-review.git.corp.google.com/15806307 .
Change-Id: I59934814cc61c7319731eb840ff2132a8c5ce241
---
 modules/sensors/dynamic_sensor/Android.bp          |  13 ++-
 .../dynamic_sensor/DynamicSensorsSubHal.cpp        | 117 +++++++++++++++++++++
 .../sensors/dynamic_sensor/DynamicSensorsSubHal.h  |  69 ++++++++++++
 3 files changed, 198 insertions(+), 1 deletion(-)
 create mode 100644 modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
 create mode 100644 modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h

diff --git a/modules/sensors/dynamic_sensor/Android.bp b/modules/sensors/dynamic_sensor/Android.bp
index 1ebc04d2..3f424b51 100644
--- a/modules/sensors/dynamic_sensor/Android.bp
+++ b/modules/sensors/dynamic_sensor/Android.bp
@@ -108,7 +108,18 @@ cc_library_shared {
 
     cflags: ["-DLOG_TAG=\"DynamicSensorHal\""],
 
-    srcs: ["sensors.cpp"],
+    srcs: [
+        "DynamicSensorsSubHal.cpp",
+        "sensors.cpp",
+    ],
+    shared_libs: [
+        "android.hardware.sensors@2.0",
+        "android.hardware.sensors@2.1",
+        "libhidlbase",
+    ],
+    header_libs: [
+        "android.hardware.sensors@2.X-multihal.header",
+    ],
 }
 
 //
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
new file mode 100644
index 00000000..df636a3b
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2021 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 "DynamicSensorsSubHal.h"
+
+#include <hardware/sensors-base.h>
+#include <log/log.h>
+
+using ::android::hardware::sensors::V1_0::Result;
+template<class T> using Return = ::android::hardware::Return<T>;
+using ::android::hardware::Void;
+
+namespace android {
+namespace SensorHalExt {
+
+// ISensors.
+Return<Result> DynamicSensorsSubHal::setOperationMode(OperationMode mode) {
+    return (mode == static_cast<OperationMode>(SENSOR_HAL_NORMAL_MODE) ?
+            Result::OK : Result::BAD_VALUE);
+}
+
+Return<Result> DynamicSensorsSubHal::activate(int32_t sensor_handle __unused,
+                                              bool enabled __unused) {
+    ALOGE("DynamicSensorsSubHal::activate not supported.");
+
+    return Result::INVALID_OPERATION;
+}
+
+Return<Result> DynamicSensorsSubHal::batch(
+        int32_t sensor_handle __unused, int64_t sampling_period_ns __unused,
+        int64_t max_report_latency_ns __unused) {
+    ALOGE("DynamicSensorsSubHal::batch not supported.");
+
+    return Result::INVALID_OPERATION;
+}
+
+Return<Result> DynamicSensorsSubHal::flush(int32_t sensor_handle __unused) {
+    ALOGE("DynamicSensorsSubHal::flush not supported.");
+
+    return Result::INVALID_OPERATION;
+}
+
+Return<void> DynamicSensorsSubHal::registerDirectChannel(
+        const SharedMemInfo& mem __unused,
+        registerDirectChannel_cb callback __unused) {
+    ALOGE("DynamicSensorsSubHal::registerDirectChannel not supported.");
+
+    return Void();
+}
+
+Return<Result> DynamicSensorsSubHal::unregisterDirectChannel(
+        int32_t channel_handle __unused) {
+    ALOGE("DynamicSensorsSubHal::unregisterDirectChannel not supported.");
+
+    return Result::INVALID_OPERATION;
+}
+
+Return<void> DynamicSensorsSubHal::configDirectReport(
+        int32_t sensor_handle __unused, int32_t channel_handle __unused,
+        RateLevel rate __unused, configDirectReport_cb callback __unused) {
+    ALOGE("DynamicSensorsSubHal::configDirectReport not supported.");
+
+    return Void();
+}
+
+Return<void> DynamicSensorsSubHal::getSensorsList_2_1(
+        getSensorsList_2_1_cb callback __unused) {
+    ALOGD("DynamicSensorsSubHal::getSensorsList_2_1 invoked.");
+
+    return Void();
+}
+
+Return<Result> DynamicSensorsSubHal::injectSensorData_2_1(
+        const Event& event __unused) {
+    ALOGE("DynamicSensorsSubHal::injectSensorData_2_1 not supported.");
+
+    return Result::INVALID_OPERATION;
+}
+
+Return<void> DynamicSensorsSubHal::debug(
+        const hidl_handle& handle __unused,
+        const hidl_vec<hidl_string>& args __unused) {
+    return Void();
+}
+
+// ISensorsSubHal.
+Return<Result> DynamicSensorsSubHal::initialize(
+        const sp<IHalProxyCallback>& hal_proxy_callback __unused) {
+    ALOGD("DynamicSensorsSubHal::initialize invoked.");
+
+    return Result::OK;
+}
+
+} // namespace SensorHalExt
+} // namespace android
+
+using ::android::hardware::sensors::V2_1::implementation::ISensorsSubHal;
+ISensorsSubHal* sensorsHalGetSubHal_2_1(uint32_t* version) {
+    static android::SensorHalExt::DynamicSensorsSubHal subHal;
+
+    *version = SUB_HAL_2_1_VERSION;
+    return &subHal;
+}
+
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
new file mode 100644
index 00000000..36ed9f5a
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2021 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_SENSORS_SUB_HAL_H
+#define ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
+
+#include <V2_1/SubHal.h>
+
+namespace android {
+namespace SensorHalExt {
+
+class DynamicSensorsSubHal :
+        public ::android::hardware::sensors::V2_1::implementation::ISensorsSubHal {
+    using Event = ::android::hardware::sensors::V2_1::Event;
+    using hidl_handle = ::android::hardware::hidl_handle;
+    using hidl_string = ::android::hardware::hidl_string;
+    template<class T> using hidl_vec = ::android::hardware::hidl_vec<T>;
+    using IHalProxyCallback =
+        ::android::hardware::sensors::V2_1::implementation::IHalProxyCallback;
+    using OperationMode = ::android::hardware::sensors::V1_0::OperationMode;
+    using RateLevel = ::android::hardware::sensors::V1_0::RateLevel;
+    using Result = ::android::hardware::sensors::V1_0::Result;
+    template<class T> using Return = ::android::hardware::Return<T>;
+    using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
+
+public:
+    // ISensors.
+    Return<Result> setOperationMode(OperationMode mode) override;
+    Return<Result> activate(int32_t sensor_handle, bool enabled) override;
+    Return<Result> batch(int32_t sensor_handle, int64_t sampling_period_ns,
+                         int64_t max_report_latency_ns) override;
+    Return<Result> flush(int32_t sensor_handle) override;
+    Return<void> registerDirectChannel(
+            const SharedMemInfo& mem,
+            registerDirectChannel_cb callback) override;
+    Return<Result> unregisterDirectChannel(int32_t channel_handle) override;
+    Return<void> configDirectReport(
+            int32_t sensor_handle, int32_t channel_handle, RateLevel rate,
+            configDirectReport_cb callback) override;
+    Return<void> getSensorsList_2_1(getSensorsList_2_1_cb callback) override;
+    Return<Result> injectSensorData_2_1(const Event& event) override;
+    Return<void> debug(
+            const hidl_handle& handle,
+            const hidl_vec<hidl_string>& args) override;
+
+    // ISensorsSubHal.
+    const std::string getName() override { return "Dynamic-SubHAL"; }
+    Return<Result> initialize(
+            const sp<IHalProxyCallback>& hal_proxy_callback) override;
+};
+
+} // namespace SensorHalExt
+} // namespace android
+
+#endif // ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
+
-- 
cgit v1.2.3


From 28b58c62b5db41da83366e4b4fe3e0ef9ed32a22 Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Tue, 14 Sep 2021 15:58:22 -0700
Subject: dynamic_sensor: Add sensor manager init to sub-HAL 2.1.

Bug: 195964858
Test: Verified dynamic sensor manager is present in sensor list.
Test: Test: See details in testing done comment in
 https://googleplex-android-review.git.corp.google.com/15831086 .
Change-Id: Ia34596d79f8a6c6985b35dcae75126e456f6009e
---
 .../dynamic_sensor/DynamicSensorsSubHal.cpp        | 39 +++++++++++++++++++++-
 .../sensors/dynamic_sensor/DynamicSensorsSubHal.h  | 12 +++++++
 2 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
index df636a3b..2db58842 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
@@ -16,16 +16,30 @@
 
 #include "DynamicSensorsSubHal.h"
 
+#include <cutils/properties.h>
 #include <hardware/sensors-base.h>
 #include <log/log.h>
 
 using ::android::hardware::sensors::V1_0::Result;
+using ::android::hardware::sensors::V2_1::SensorInfo;
+using ::android::hardware::sensors::V2_1::SensorType;
 template<class T> using Return = ::android::hardware::Return<T>;
 using ::android::hardware::Void;
 
 namespace android {
 namespace SensorHalExt {
 
+DynamicSensorsSubHal::DynamicSensorsSubHal() {
+    // 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 /* callback */));
+}
+
 // ISensors.
 Return<Result> DynamicSensorsSubHal::setOperationMode(OperationMode mode) {
     return (mode == static_cast<OperationMode>(SENSOR_HAL_NORMAL_MODE) ?
@@ -77,9 +91,32 @@ Return<void> DynamicSensorsSubHal::configDirectReport(
 }
 
 Return<void> DynamicSensorsSubHal::getSensorsList_2_1(
-        getSensorsList_2_1_cb callback __unused) {
+        getSensorsList_2_1_cb callback) {
+    const sensor_t& sensor_info = mDynamicSensorManager->getDynamicMetaSensor();
+    std::vector<SensorInfo> sensors;
+
     ALOGD("DynamicSensorsSubHal::getSensorsList_2_1 invoked.");
 
+    // get the dynamic sensor info
+    sensors.resize(1);
+    sensors[0].sensorHandle = sensor_info.handle;
+    sensors[0].name = sensor_info.name;
+    sensors[0].vendor = sensor_info.vendor;
+    sensors[0].version = 1;
+    sensors[0].type = static_cast<SensorType>(sensor_info.type);
+    sensors[0].typeAsString = sensor_info.stringType;
+    sensors[0].maxRange = sensor_info.maxRange;
+    sensors[0].resolution = sensor_info.resolution;
+    sensors[0].power = sensor_info.power;
+    sensors[0].minDelay = sensor_info.minDelay;
+    sensors[0].fifoReservedEventCount = sensor_info.fifoReservedEventCount;
+    sensors[0].fifoMaxEventCount = sensor_info.fifoMaxEventCount;
+    sensors[0].requiredPermission = sensor_info.requiredPermission;
+    sensors[0].maxDelay = sensor_info.maxDelay;
+    sensors[0].flags = sensor_info.flags;
+
+    callback(sensors);
+
     return Void();
 }
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
index 36ed9f5a..ab5d2999 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
@@ -17,6 +17,8 @@
 #ifndef ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 #define ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 
+#include "DynamicSensorManager.h"
+
 #include <V2_1/SubHal.h>
 
 namespace android {
@@ -37,6 +39,8 @@ class DynamicSensorsSubHal :
     using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
 
 public:
+    DynamicSensorsSubHal();
+
     // ISensors.
     Return<Result> setOperationMode(OperationMode mode) override;
     Return<Result> activate(int32_t sensor_handle, bool enabled) override;
@@ -60,6 +64,14 @@ public:
     const std::string getName() override { return "Dynamic-SubHAL"; }
     Return<Result> initialize(
             const sp<IHalProxyCallback>& hal_proxy_callback) override;
+
+private:
+    static constexpr int32_t kDynamicHandleBase = 0;
+    static constexpr int32_t kDynamicHandleEnd = 0x1000000;
+    static constexpr int32_t kMaxDynamicHandleCount = kDynamicHandleEnd -
+                                                      kDynamicHandleBase;
+
+    std::unique_ptr<DynamicSensorManager> mDynamicSensorManager;
 };
 
 } // namespace SensorHalExt
-- 
cgit v1.2.3


From 3482ca5bf73ca6afd10eb49dfc7cfb49609b3eae Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Thu, 16 Sep 2021 22:58:51 +0000
Subject: Revert "dynamic_sensor: Add sensor manager init to sub-HAL 2.1."

This reverts commit 28b58c62b5db41da83366e4b4fe3e0ef9ed32a22.

Reason for revert: 200210164

Change-Id: I6be2c972a29ec7943dbdf450ef3e491065b011a6
---
 .../dynamic_sensor/DynamicSensorsSubHal.cpp        | 39 +---------------------
 .../sensors/dynamic_sensor/DynamicSensorsSubHal.h  | 12 -------
 2 files changed, 1 insertion(+), 50 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
index 2db58842..df636a3b 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
@@ -16,30 +16,16 @@
 
 #include "DynamicSensorsSubHal.h"
 
-#include <cutils/properties.h>
 #include <hardware/sensors-base.h>
 #include <log/log.h>
 
 using ::android::hardware::sensors::V1_0::Result;
-using ::android::hardware::sensors::V2_1::SensorInfo;
-using ::android::hardware::sensors::V2_1::SensorType;
 template<class T> using Return = ::android::hardware::Return<T>;
 using ::android::hardware::Void;
 
 namespace android {
 namespace SensorHalExt {
 
-DynamicSensorsSubHal::DynamicSensorsSubHal() {
-    // 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 /* callback */));
-}
-
 // ISensors.
 Return<Result> DynamicSensorsSubHal::setOperationMode(OperationMode mode) {
     return (mode == static_cast<OperationMode>(SENSOR_HAL_NORMAL_MODE) ?
@@ -91,32 +77,9 @@ Return<void> DynamicSensorsSubHal::configDirectReport(
 }
 
 Return<void> DynamicSensorsSubHal::getSensorsList_2_1(
-        getSensorsList_2_1_cb callback) {
-    const sensor_t& sensor_info = mDynamicSensorManager->getDynamicMetaSensor();
-    std::vector<SensorInfo> sensors;
-
+        getSensorsList_2_1_cb callback __unused) {
     ALOGD("DynamicSensorsSubHal::getSensorsList_2_1 invoked.");
 
-    // get the dynamic sensor info
-    sensors.resize(1);
-    sensors[0].sensorHandle = sensor_info.handle;
-    sensors[0].name = sensor_info.name;
-    sensors[0].vendor = sensor_info.vendor;
-    sensors[0].version = 1;
-    sensors[0].type = static_cast<SensorType>(sensor_info.type);
-    sensors[0].typeAsString = sensor_info.stringType;
-    sensors[0].maxRange = sensor_info.maxRange;
-    sensors[0].resolution = sensor_info.resolution;
-    sensors[0].power = sensor_info.power;
-    sensors[0].minDelay = sensor_info.minDelay;
-    sensors[0].fifoReservedEventCount = sensor_info.fifoReservedEventCount;
-    sensors[0].fifoMaxEventCount = sensor_info.fifoMaxEventCount;
-    sensors[0].requiredPermission = sensor_info.requiredPermission;
-    sensors[0].maxDelay = sensor_info.maxDelay;
-    sensors[0].flags = sensor_info.flags;
-
-    callback(sensors);
-
     return Void();
 }
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
index ab5d2999..36ed9f5a 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
@@ -17,8 +17,6 @@
 #ifndef ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 #define ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 
-#include "DynamicSensorManager.h"
-
 #include <V2_1/SubHal.h>
 
 namespace android {
@@ -39,8 +37,6 @@ class DynamicSensorsSubHal :
     using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
 
 public:
-    DynamicSensorsSubHal();
-
     // ISensors.
     Return<Result> setOperationMode(OperationMode mode) override;
     Return<Result> activate(int32_t sensor_handle, bool enabled) override;
@@ -64,14 +60,6 @@ public:
     const std::string getName() override { return "Dynamic-SubHAL"; }
     Return<Result> initialize(
             const sp<IHalProxyCallback>& hal_proxy_callback) override;
-
-private:
-    static constexpr int32_t kDynamicHandleBase = 0;
-    static constexpr int32_t kDynamicHandleEnd = 0x1000000;
-    static constexpr int32_t kMaxDynamicHandleCount = kDynamicHandleEnd -
-                                                      kDynamicHandleBase;
-
-    std::unique_ptr<DynamicSensorManager> mDynamicSensorManager;
 };
 
 } // namespace SensorHalExt
-- 
cgit v1.2.3


From c7038f8a783edfbcc199402a1e3b870a092fbdc7 Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Mon, 20 Sep 2021 16:54:59 -0700
Subject: dynamic_sensor: Add sensor manager init to sub-HAL 2.1.

Bug: 195964858
Test: Verified dynamic sensor manager is present in sensor list and that
 no SELinux violations occur.
Test: See details in testing done comment in
 https://googleplex-android-review.git.corp.google.com/15874906 .
Change-Id: I5d587dc46bdec66c3162bf222d36b285b8d2ca3d
---
 .../dynamic_sensor/DummyDynamicAccelDaemon.cpp     |  2 +-
 .../dynamic_sensor/DynamicSensorsSubHal.cpp        | 35 +++++++++++++++++++++-
 .../sensors/dynamic_sensor/DynamicSensorsSubHal.h  | 12 ++++++++
 3 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp b/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp
index a1a47e81..0cc8a393 100644
--- a/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp
+++ b/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp
@@ -28,7 +28,7 @@
 #include <netinet/in.h>
 #include <algorithm>            //std::max
 
-#define SYSPROP_PREFIX                  "dynamic_sensor.dummy"
+#define SYSPROP_PREFIX                  "vendor.dynamic_sensor.mock"
 #define FILE_NAME_BASE                  "dummy_accel_file"
 #define FILE_NAME_REGEX                 ("^" FILE_NAME_BASE "[0-9]$")
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
index df636a3b..9f9a9fef 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
@@ -20,12 +20,22 @@
 #include <log/log.h>
 
 using ::android::hardware::sensors::V1_0::Result;
+using ::android::hardware::sensors::V2_1::SensorInfo;
+using ::android::hardware::sensors::V2_1::SensorType;
 template<class T> using Return = ::android::hardware::Return<T>;
 using ::android::hardware::Void;
 
 namespace android {
 namespace SensorHalExt {
 
+DynamicSensorsSubHal::DynamicSensorsSubHal() {
+    // initialize dynamic sensor manager
+    mDynamicSensorManager.reset(
+            DynamicSensorManager::createInstance(kDynamicHandleBase,
+                                                 kMaxDynamicHandleCount,
+                                                 nullptr /* callback */));
+}
+
 // ISensors.
 Return<Result> DynamicSensorsSubHal::setOperationMode(OperationMode mode) {
     return (mode == static_cast<OperationMode>(SENSOR_HAL_NORMAL_MODE) ?
@@ -77,9 +87,32 @@ Return<void> DynamicSensorsSubHal::configDirectReport(
 }
 
 Return<void> DynamicSensorsSubHal::getSensorsList_2_1(
-        getSensorsList_2_1_cb callback __unused) {
+        getSensorsList_2_1_cb callback) {
+    const sensor_t& sensor_info = mDynamicSensorManager->getDynamicMetaSensor();
+    std::vector<SensorInfo> sensors;
+
     ALOGD("DynamicSensorsSubHal::getSensorsList_2_1 invoked.");
 
+    // get the dynamic sensor info
+    sensors.resize(1);
+    sensors[0].sensorHandle = sensor_info.handle;
+    sensors[0].name = sensor_info.name;
+    sensors[0].vendor = sensor_info.vendor;
+    sensors[0].version = 1;
+    sensors[0].type = static_cast<SensorType>(sensor_info.type);
+    sensors[0].typeAsString = sensor_info.stringType;
+    sensors[0].maxRange = sensor_info.maxRange;
+    sensors[0].resolution = sensor_info.resolution;
+    sensors[0].power = sensor_info.power;
+    sensors[0].minDelay = sensor_info.minDelay;
+    sensors[0].fifoReservedEventCount = sensor_info.fifoReservedEventCount;
+    sensors[0].fifoMaxEventCount = sensor_info.fifoMaxEventCount;
+    sensors[0].requiredPermission = sensor_info.requiredPermission;
+    sensors[0].maxDelay = sensor_info.maxDelay;
+    sensors[0].flags = sensor_info.flags;
+
+    callback(sensors);
+
     return Void();
 }
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
index 36ed9f5a..ab5d2999 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
@@ -17,6 +17,8 @@
 #ifndef ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 #define ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 
+#include "DynamicSensorManager.h"
+
 #include <V2_1/SubHal.h>
 
 namespace android {
@@ -37,6 +39,8 @@ class DynamicSensorsSubHal :
     using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
 
 public:
+    DynamicSensorsSubHal();
+
     // ISensors.
     Return<Result> setOperationMode(OperationMode mode) override;
     Return<Result> activate(int32_t sensor_handle, bool enabled) override;
@@ -60,6 +64,14 @@ public:
     const std::string getName() override { return "Dynamic-SubHAL"; }
     Return<Result> initialize(
             const sp<IHalProxyCallback>& hal_proxy_callback) override;
+
+private:
+    static constexpr int32_t kDynamicHandleBase = 0;
+    static constexpr int32_t kDynamicHandleEnd = 0x1000000;
+    static constexpr int32_t kMaxDynamicHandleCount = kDynamicHandleEnd -
+                                                      kDynamicHandleBase;
+
+    std::unique_ptr<DynamicSensorManager> mDynamicSensorManager;
 };
 
 } // namespace SensorHalExt
-- 
cgit v1.2.3


From 1d509cf815c5e3319ce4303eabe863b6b8dcf3a1 Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Wed, 22 Sep 2021 17:53:58 +0000
Subject: Revert "dynamic_sensor: Add sensor manager init to sub-HAL 2.1."

Revert submission 15874906-bug_195964858.2

Reason for revert: b/200815351
Reverted Changes:
I76a60f7fb:Allow the sensor HAL to access dynamic sensor prop...
I5d587dc46:dynamic_sensor: Add sensor manager init to sub-HAL...

Change-Id: I26b95614bb276e5c2a686de78d73ab48767176a3
---
 .../dynamic_sensor/DummyDynamicAccelDaemon.cpp     |  2 +-
 .../dynamic_sensor/DynamicSensorsSubHal.cpp        | 35 +---------------------
 .../sensors/dynamic_sensor/DynamicSensorsSubHal.h  | 12 --------
 3 files changed, 2 insertions(+), 47 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp b/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp
index 0cc8a393..a1a47e81 100644
--- a/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp
+++ b/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp
@@ -28,7 +28,7 @@
 #include <netinet/in.h>
 #include <algorithm>            //std::max
 
-#define SYSPROP_PREFIX                  "vendor.dynamic_sensor.mock"
+#define SYSPROP_PREFIX                  "dynamic_sensor.dummy"
 #define FILE_NAME_BASE                  "dummy_accel_file"
 #define FILE_NAME_REGEX                 ("^" FILE_NAME_BASE "[0-9]$")
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
index 9f9a9fef..df636a3b 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
@@ -20,22 +20,12 @@
 #include <log/log.h>
 
 using ::android::hardware::sensors::V1_0::Result;
-using ::android::hardware::sensors::V2_1::SensorInfo;
-using ::android::hardware::sensors::V2_1::SensorType;
 template<class T> using Return = ::android::hardware::Return<T>;
 using ::android::hardware::Void;
 
 namespace android {
 namespace SensorHalExt {
 
-DynamicSensorsSubHal::DynamicSensorsSubHal() {
-    // initialize dynamic sensor manager
-    mDynamicSensorManager.reset(
-            DynamicSensorManager::createInstance(kDynamicHandleBase,
-                                                 kMaxDynamicHandleCount,
-                                                 nullptr /* callback */));
-}
-
 // ISensors.
 Return<Result> DynamicSensorsSubHal::setOperationMode(OperationMode mode) {
     return (mode == static_cast<OperationMode>(SENSOR_HAL_NORMAL_MODE) ?
@@ -87,32 +77,9 @@ Return<void> DynamicSensorsSubHal::configDirectReport(
 }
 
 Return<void> DynamicSensorsSubHal::getSensorsList_2_1(
-        getSensorsList_2_1_cb callback) {
-    const sensor_t& sensor_info = mDynamicSensorManager->getDynamicMetaSensor();
-    std::vector<SensorInfo> sensors;
-
+        getSensorsList_2_1_cb callback __unused) {
     ALOGD("DynamicSensorsSubHal::getSensorsList_2_1 invoked.");
 
-    // get the dynamic sensor info
-    sensors.resize(1);
-    sensors[0].sensorHandle = sensor_info.handle;
-    sensors[0].name = sensor_info.name;
-    sensors[0].vendor = sensor_info.vendor;
-    sensors[0].version = 1;
-    sensors[0].type = static_cast<SensorType>(sensor_info.type);
-    sensors[0].typeAsString = sensor_info.stringType;
-    sensors[0].maxRange = sensor_info.maxRange;
-    sensors[0].resolution = sensor_info.resolution;
-    sensors[0].power = sensor_info.power;
-    sensors[0].minDelay = sensor_info.minDelay;
-    sensors[0].fifoReservedEventCount = sensor_info.fifoReservedEventCount;
-    sensors[0].fifoMaxEventCount = sensor_info.fifoMaxEventCount;
-    sensors[0].requiredPermission = sensor_info.requiredPermission;
-    sensors[0].maxDelay = sensor_info.maxDelay;
-    sensors[0].flags = sensor_info.flags;
-
-    callback(sensors);
-
     return Void();
 }
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
index ab5d2999..36ed9f5a 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
@@ -17,8 +17,6 @@
 #ifndef ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 #define ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 
-#include "DynamicSensorManager.h"
-
 #include <V2_1/SubHal.h>
 
 namespace android {
@@ -39,8 +37,6 @@ class DynamicSensorsSubHal :
     using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
 
 public:
-    DynamicSensorsSubHal();
-
     // ISensors.
     Return<Result> setOperationMode(OperationMode mode) override;
     Return<Result> activate(int32_t sensor_handle, bool enabled) override;
@@ -64,14 +60,6 @@ public:
     const std::string getName() override { return "Dynamic-SubHAL"; }
     Return<Result> initialize(
             const sp<IHalProxyCallback>& hal_proxy_callback) override;
-
-private:
-    static constexpr int32_t kDynamicHandleBase = 0;
-    static constexpr int32_t kDynamicHandleEnd = 0x1000000;
-    static constexpr int32_t kMaxDynamicHandleCount = kDynamicHandleEnd -
-                                                      kDynamicHandleBase;
-
-    std::unique_ptr<DynamicSensorManager> mDynamicSensorManager;
 };
 
 } // namespace SensorHalExt
-- 
cgit v1.2.3


From 3c7a12d8f1764df734f74b486e57acf1f629dd5e Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Fri, 24 Sep 2021 05:48:24 -0700
Subject: dynamic_sensor: Add sensor manager init to sub-HAL 2.1.

Bug: 195964858
Test: Verified dynamic sensor manager is present in sensor list and that
 no SELinux violations occur on sc-v2-dev and master.

$ make -j28 && \
         vendor/google/tools/flashall -w -s 14281FDEE000A5 --disable_verity && \
         sleep 90 && adb root
.
.
.
$ adb shell sensor_test list | grep "sensor_test\|Type\|Dynamic"
sensor_test version 74
Type     Subtype  Name
32       0        Dynamic Sensor Manager
$ adb logcat -d | grep avc | grep sensor
$

Change-Id: Ib3da287e4f4118ad6b19498248e263f8c1662b3a
---
 .../sensors/dynamic_sensor/ConnectionDetector.cpp  | 18 +++++++----
 .../sensors/dynamic_sensor/ConnectionDetector.h    |  3 ++
 .../dynamic_sensor/DummyDynamicAccelDaemon.cpp     |  4 ++-
 .../dynamic_sensor/DynamicSensorsSubHal.cpp        | 35 +++++++++++++++++++++-
 .../sensors/dynamic_sensor/DynamicSensorsSubHal.h  | 12 ++++++++
 .../sensors/dynamic_sensor/HidRawSensorDaemon.cpp  |  1 +
 6 files changed, 66 insertions(+), 7 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/ConnectionDetector.cpp b/modules/sensors/dynamic_sensor/ConnectionDetector.cpp
index c51e9125..c009a707 100644
--- a/modules/sensors/dynamic_sensor/ConnectionDetector.cpp
+++ b/modules/sensors/dynamic_sensor/ConnectionDetector.cpp
@@ -57,8 +57,6 @@ SocketConnectionDetector::SocketConnectionDetector(BaseDynamicSensorDaemon *d, i
     std::ostringstream s;
     s << "socket:" << port;
     mDevice = s.str();
-
-    run("ddad_socket");
 }
 
 SocketConnectionDetector::~SocketConnectionDetector() {
@@ -67,6 +65,12 @@ SocketConnectionDetector::~SocketConnectionDetector() {
     }
 }
 
+void SocketConnectionDetector::Init() {
+    // run adds a strong reference to this object, so it can't be invoked from
+    // the constructor.
+    run("ddad_socket");
+}
+
 int SocketConnectionDetector::waitForConnection() {
     return ::accept(mListenFd, nullptr, nullptr);
 }
@@ -124,9 +128,6 @@ FileConnectionDetector::FileConnectionDetector (
         ALOGE("Cannot setup watch on dir %s", path.c_str());
         return;
     }
-
-    // mLooper != null && mInotifyFd added to looper
-    run("ddad_file");
 }
 
 FileConnectionDetector::~FileConnectionDetector() {
@@ -138,6 +139,13 @@ FileConnectionDetector::~FileConnectionDetector() {
     }
 }
 
+void FileConnectionDetector::Init() {
+    // mLooper != null && mInotifyFd added to looper
+    // run adds a strong reference to this object, so it can't be invoked from
+    // the constructor.
+    run("ddad_file");
+}
+
 bool FileConnectionDetector::matches(const std::string &name) const {
     return std::regex_match(name, mRegex);
 }
diff --git a/modules/sensors/dynamic_sensor/ConnectionDetector.h b/modules/sensors/dynamic_sensor/ConnectionDetector.h
index 0ee1df29..75fbb0bc 100644
--- a/modules/sensors/dynamic_sensor/ConnectionDetector.h
+++ b/modules/sensors/dynamic_sensor/ConnectionDetector.h
@@ -34,6 +34,7 @@ class ConnectionDetector : virtual public RefBase {
 public:
     ConnectionDetector(BaseDynamicSensorDaemon *d) : mDaemon(d) { }
     virtual ~ConnectionDetector() = default;
+    virtual void Init() {}
 protected:
     BaseDynamicSensorDaemon* mDaemon;
 };
@@ -45,6 +46,7 @@ class SocketConnectionDetector : public ConnectionDetector, public Thread {
 public:
     SocketConnectionDetector(BaseDynamicSensorDaemon *d, int port);
     virtual ~SocketConnectionDetector();
+    void Init() override;
 private:
     // implement virtual of Thread
     virtual bool threadLoop();
@@ -62,6 +64,7 @@ public:
     FileConnectionDetector(
             BaseDynamicSensorDaemon *d, const std::string &path, const std::string &regex);
     virtual ~FileConnectionDetector();
+    void Init() override;
 private:
     static constexpr int POLL_IDENT = 1;
     // implement virtual of Thread
diff --git a/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp b/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp
index a1a47e81..10771e32 100644
--- a/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp
+++ b/modules/sensors/dynamic_sensor/DummyDynamicAccelDaemon.cpp
@@ -28,7 +28,7 @@
 #include <netinet/in.h>
 #include <algorithm>            //std::max
 
-#define SYSPROP_PREFIX                  "dynamic_sensor.dummy"
+#define SYSPROP_PREFIX                  "vendor.dynamic_sensor.mock"
 #define FILE_NAME_BASE                  "dummy_accel_file"
 #define FILE_NAME_REGEX                 ("^" FILE_NAME_BASE "[0-9]$")
 
@@ -43,11 +43,13 @@ DummyDynamicAccelDaemon::DummyDynamicAccelDaemon(DynamicSensorManager& manager)
     if (strcmp(property, "") != 0) {
         mFileDetector = new FileConnectionDetector(
                 this, std::string(property), std::string(FILE_NAME_REGEX));
+        mFileDetector->Init();
     }
 
     property_get(SYSPROP_PREFIX ".socket", property, "");
     if (strcmp(property, "") != 0) {
         mSocketDetector = new SocketConnectionDetector(this, atoi(property));
+        mSocketDetector->Init();
     }
 }
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
index df636a3b..9f9a9fef 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
@@ -20,12 +20,22 @@
 #include <log/log.h>
 
 using ::android::hardware::sensors::V1_0::Result;
+using ::android::hardware::sensors::V2_1::SensorInfo;
+using ::android::hardware::sensors::V2_1::SensorType;
 template<class T> using Return = ::android::hardware::Return<T>;
 using ::android::hardware::Void;
 
 namespace android {
 namespace SensorHalExt {
 
+DynamicSensorsSubHal::DynamicSensorsSubHal() {
+    // initialize dynamic sensor manager
+    mDynamicSensorManager.reset(
+            DynamicSensorManager::createInstance(kDynamicHandleBase,
+                                                 kMaxDynamicHandleCount,
+                                                 nullptr /* callback */));
+}
+
 // ISensors.
 Return<Result> DynamicSensorsSubHal::setOperationMode(OperationMode mode) {
     return (mode == static_cast<OperationMode>(SENSOR_HAL_NORMAL_MODE) ?
@@ -77,9 +87,32 @@ Return<void> DynamicSensorsSubHal::configDirectReport(
 }
 
 Return<void> DynamicSensorsSubHal::getSensorsList_2_1(
-        getSensorsList_2_1_cb callback __unused) {
+        getSensorsList_2_1_cb callback) {
+    const sensor_t& sensor_info = mDynamicSensorManager->getDynamicMetaSensor();
+    std::vector<SensorInfo> sensors;
+
     ALOGD("DynamicSensorsSubHal::getSensorsList_2_1 invoked.");
 
+    // get the dynamic sensor info
+    sensors.resize(1);
+    sensors[0].sensorHandle = sensor_info.handle;
+    sensors[0].name = sensor_info.name;
+    sensors[0].vendor = sensor_info.vendor;
+    sensors[0].version = 1;
+    sensors[0].type = static_cast<SensorType>(sensor_info.type);
+    sensors[0].typeAsString = sensor_info.stringType;
+    sensors[0].maxRange = sensor_info.maxRange;
+    sensors[0].resolution = sensor_info.resolution;
+    sensors[0].power = sensor_info.power;
+    sensors[0].minDelay = sensor_info.minDelay;
+    sensors[0].fifoReservedEventCount = sensor_info.fifoReservedEventCount;
+    sensors[0].fifoMaxEventCount = sensor_info.fifoMaxEventCount;
+    sensors[0].requiredPermission = sensor_info.requiredPermission;
+    sensors[0].maxDelay = sensor_info.maxDelay;
+    sensors[0].flags = sensor_info.flags;
+
+    callback(sensors);
+
     return Void();
 }
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
index 36ed9f5a..ab5d2999 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
@@ -17,6 +17,8 @@
 #ifndef ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 #define ANDROID_SENSORHAL_EXT_DYNAMIC_SENSORS_SUB_HAL_H
 
+#include "DynamicSensorManager.h"
+
 #include <V2_1/SubHal.h>
 
 namespace android {
@@ -37,6 +39,8 @@ class DynamicSensorsSubHal :
     using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
 
 public:
+    DynamicSensorsSubHal();
+
     // ISensors.
     Return<Result> setOperationMode(OperationMode mode) override;
     Return<Result> activate(int32_t sensor_handle, bool enabled) override;
@@ -60,6 +64,14 @@ public:
     const std::string getName() override { return "Dynamic-SubHAL"; }
     Return<Result> initialize(
             const sp<IHalProxyCallback>& hal_proxy_callback) override;
+
+private:
+    static constexpr int32_t kDynamicHandleBase = 0;
+    static constexpr int32_t kDynamicHandleEnd = 0x1000000;
+    static constexpr int32_t kMaxDynamicHandleCount = kDynamicHandleEnd -
+                                                      kDynamicHandleBase;
+
+    std::unique_ptr<DynamicSensorManager> mDynamicSensorManager;
 };
 
 } // namespace SensorHalExt
diff --git a/modules/sensors/dynamic_sensor/HidRawSensorDaemon.cpp b/modules/sensors/dynamic_sensor/HidRawSensorDaemon.cpp
index 6bf34bc8..4b447ac1 100644
--- a/modules/sensors/dynamic_sensor/HidRawSensorDaemon.cpp
+++ b/modules/sensors/dynamic_sensor/HidRawSensorDaemon.cpp
@@ -39,6 +39,7 @@ HidRawSensorDaemon::HidRawSensorDaemon(DynamicSensorManager& manager)
         : BaseDynamicSensorDaemon(manager) {
     mDetector = new FileConnectionDetector(
             this, std::string(DEV_PATH), std::string(DEV_NAME_REGEX));
+    mDetector->Init();
 }
 
 BaseSensorVector HidRawSensorDaemon::createSensor(const std::string &deviceKey) {
-- 
cgit v1.2.3


From 7b29add5f73449e3fdcb462f030b7f44c985815e Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Tue, 28 Sep 2021 05:50:43 -0700
Subject: dynamic_sensor: Notify multi-HAL 2.1 of connected sensors.

Bug: 195964858
Test: Paired a Sony PS4 controller and verified it is present in sensor
 list as an accelerometer. It can't be sampled, but the LSM6DSR
 accelerometer may still be sampled.
Change-Id: I182291cebdf84e5f6cd44d16debd6a07c4bc5281
---
 modules/sensors/dynamic_sensor/Android.bp          |  5 ++
 .../dynamic_sensor/DynamicSensorsSubHal.cpp        | 80 +++++++++++++++++++++-
 .../sensors/dynamic_sensor/DynamicSensorsSubHal.h  |  8 +++
 3 files changed, 91 insertions(+), 2 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/Android.bp b/modules/sensors/dynamic_sensor/Android.bp
index 3f424b51..bad60481 100644
--- a/modules/sensors/dynamic_sensor/Android.bp
+++ b/modules/sensors/dynamic_sensor/Android.bp
@@ -114,11 +114,16 @@ cc_library_shared {
     ],
     shared_libs: [
         "android.hardware.sensors@2.0",
+        "android.hardware.sensors@2.0-ScopedWakelock",
         "android.hardware.sensors@2.1",
         "libhidlbase",
     ],
+    static_libs: [
+        "android.hardware.sensors@1.0-convert",
+    ],
     header_libs: [
         "android.hardware.sensors@2.X-multihal.header",
+        "android.hardware.sensors@2.X-shared-utils",
     ],
 }
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
index 9f9a9fef..4f0cc481 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
@@ -14,12 +14,19 @@
  * limitations under the License.
  */
 
+#include "BaseSensorObject.h"
 #include "DynamicSensorsSubHal.h"
 
+#include <convertV2_1.h>
 #include <hardware/sensors-base.h>
 #include <log/log.h>
 
+#include <chrono>
+#include <thread>
+
 using ::android::hardware::sensors::V1_0::Result;
+using ::android::hardware::sensors::V2_0::implementation::ScopedWakelock;
+using ::android::hardware::sensors::V2_1::implementation::convertFromSensorEvent;
 using ::android::hardware::sensors::V2_1::SensorInfo;
 using ::android::hardware::sensors::V2_1::SensorType;
 template<class T> using Return = ::android::hardware::Return<T>;
@@ -33,7 +40,7 @@ DynamicSensorsSubHal::DynamicSensorsSubHal() {
     mDynamicSensorManager.reset(
             DynamicSensorManager::createInstance(kDynamicHandleBase,
                                                  kMaxDynamicHandleCount,
-                                                 nullptr /* callback */));
+                                                 this /* callback */));
 }
 
 // ISensors.
@@ -131,12 +138,81 @@ Return<void> DynamicSensorsSubHal::debug(
 
 // ISensorsSubHal.
 Return<Result> DynamicSensorsSubHal::initialize(
-        const sp<IHalProxyCallback>& hal_proxy_callback __unused) {
+        const sp<IHalProxyCallback>& hal_proxy_callback) {
     ALOGD("DynamicSensorsSubHal::initialize invoked.");
 
+    mHalProxyCallback = hal_proxy_callback;
+
     return Result::OK;
 }
 
+// SensorEventCallback.
+int DynamicSensorsSubHal::submitEvent(SP(BaseSensorObject) sensor,
+                                      const sensors_event_t& e) {
+    std::vector<Event> events;
+    Event hal_event;
+    bool wakeup;
+
+    if (e.type == SENSOR_TYPE_DYNAMIC_SENSOR_META) {
+        const dynamic_sensor_meta_event_t* sensor_meta;
+
+        sensor_meta = static_cast<const dynamic_sensor_meta_event_t*>(
+                &(e.dynamic_sensor_meta));
+        if (sensor_meta->connected != 0) {
+            // The sensor framework must be notified of the connected sensor
+            // through the callback before handling the sensor added event. If
+            // it isn't, it will assert when looking up the sensor handle when
+            // processing the sensor added event.
+            //
+            // TODO (b/201529167): Fix dynamic sensors addition / removal when
+            //                     converting to AIDL.
+            // The sensor framework runs in a separate process from the sensor
+            // HAL, and it processes events in a dedicated thread, so it's
+            // possible the event handling can be done before the callback is
+            // run. Thus, a delay is added after sending notification of the
+            // connected sensor.
+            onSensorConnected(sensor_meta->handle, sensor_meta->sensor);
+            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+       }
+    }
+
+    convertFromSensorEvent(e, &hal_event);
+    events.push_back(hal_event);
+    if (sensor && sensor->getSensor()) {
+        wakeup = sensor->getSensor()->flags & SENSOR_FLAG_WAKE_UP;
+    } else {
+        wakeup = false;
+    }
+    ScopedWakelock wakelock = mHalProxyCallback->createScopedWakelock(wakeup);
+    mHalProxyCallback->postEvents(events, std::move(wakelock));
+
+    return 0;
+}
+
+void DynamicSensorsSubHal::onSensorConnected(
+        int handle, const sensor_t* sensor_info) {
+    hidl_vec<SensorInfo> sensor_list;
+
+    sensor_list.resize(1);
+    sensor_list[0].sensorHandle = handle;
+    sensor_list[0].name = sensor_info->name;
+    sensor_list[0].vendor = sensor_info->vendor;
+    sensor_list[0].version = 1;
+    sensor_list[0].type = static_cast<SensorType>(sensor_info->type);
+    sensor_list[0].typeAsString = sensor_info->stringType;
+    sensor_list[0].maxRange = sensor_info->maxRange;
+    sensor_list[0].resolution = sensor_info->resolution;
+    sensor_list[0].power = sensor_info->power;
+    sensor_list[0].minDelay = sensor_info->minDelay;
+    sensor_list[0].fifoReservedEventCount = sensor_info->fifoReservedEventCount;
+    sensor_list[0].fifoMaxEventCount = sensor_info->fifoMaxEventCount;
+    sensor_list[0].requiredPermission = sensor_info->requiredPermission;
+    sensor_list[0].maxDelay = sensor_info->maxDelay;
+    sensor_list[0].flags = sensor_info->flags;
+
+    mHalProxyCallback->onDynamicSensorsConnected_2_1(sensor_list);
+}
+
 } // namespace SensorHalExt
 } // namespace android
 
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
index ab5d2999..e9a46d68 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h
@@ -25,6 +25,7 @@ namespace android {
 namespace SensorHalExt {
 
 class DynamicSensorsSubHal :
+        public SensorEventCallback,
         public ::android::hardware::sensors::V2_1::implementation::ISensorsSubHal {
     using Event = ::android::hardware::sensors::V2_1::Event;
     using hidl_handle = ::android::hardware::hidl_handle;
@@ -65,13 +66,20 @@ public:
     Return<Result> initialize(
             const sp<IHalProxyCallback>& hal_proxy_callback) override;
 
+    // SensorEventCallback.
+    int submitEvent(SP(BaseSensorObject) sensor,
+                    const sensors_event_t& e) override;
+
 private:
     static constexpr int32_t kDynamicHandleBase = 0;
     static constexpr int32_t kDynamicHandleEnd = 0x1000000;
     static constexpr int32_t kMaxDynamicHandleCount = kDynamicHandleEnd -
                                                       kDynamicHandleBase;
 
+    void onSensorConnected(int handle, const sensor_t* sensor_info);
+
     std::unique_ptr<DynamicSensorManager> mDynamicSensorManager;
+    sp<IHalProxyCallback> mHalProxyCallback;
 };
 
 } // namespace SensorHalExt
-- 
cgit v1.2.3


From 43bc7bccdc3e4ee224d5c22ef8f18b0f2fbeb1e0 Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Thu, 30 Sep 2021 06:50:43 -0700
Subject: dynamic_sensor: Add multi-HAL 2.1 sampling support.

Bug: 195964858
Test: Paired a Sony PS4 controller and verified it can be sampled as an
 accelerometer. The first subscription always returns all 0's, but
 subsequent subscriptions return proper accel samples.
Change-Id: I4bbc4695c988f600a62502f9fccabaa68f42c72b
---
 .../dynamic_sensor/DynamicSensorsSubHal.cpp        | 34 +++++++++++++++-------
 1 file changed, 24 insertions(+), 10 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
index 4f0cc481..d9e31824 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
@@ -35,6 +35,21 @@ using ::android::hardware::Void;
 namespace android {
 namespace SensorHalExt {
 
+static Result ResultFromStatus(status_t err) {
+    switch (err) {
+        case ::android::OK:
+            return Result::OK;
+        case ::android::PERMISSION_DENIED:
+            return Result::PERMISSION_DENIED;
+        case ::android::NO_MEMORY:
+            return Result::NO_MEMORY;
+        case ::android::BAD_VALUE:
+            return Result::BAD_VALUE;
+        default:
+            return Result::INVALID_OPERATION;
+    }
+}
+
 DynamicSensorsSubHal::DynamicSensorsSubHal() {
     // initialize dynamic sensor manager
     mDynamicSensorManager.reset(
@@ -49,19 +64,18 @@ Return<Result> DynamicSensorsSubHal::setOperationMode(OperationMode mode) {
             Result::OK : Result::BAD_VALUE);
 }
 
-Return<Result> DynamicSensorsSubHal::activate(int32_t sensor_handle __unused,
-                                              bool enabled __unused) {
-    ALOGE("DynamicSensorsSubHal::activate not supported.");
-
-    return Result::INVALID_OPERATION;
+Return<Result> DynamicSensorsSubHal::activate(int32_t sensor_handle,
+                                              bool enabled) {
+    int rc = mDynamicSensorManager->activate(sensor_handle, enabled);
+    return ResultFromStatus(rc);
 }
 
 Return<Result> DynamicSensorsSubHal::batch(
-        int32_t sensor_handle __unused, int64_t sampling_period_ns __unused,
-        int64_t max_report_latency_ns __unused) {
-    ALOGE("DynamicSensorsSubHal::batch not supported.");
-
-    return Result::INVALID_OPERATION;
+        int32_t sensor_handle, int64_t sampling_period_ns,
+        int64_t max_report_latency_ns) {
+    int rc = mDynamicSensorManager->batch(sensor_handle, sampling_period_ns,
+                                          max_report_latency_ns);
+    return ResultFromStatus(rc);
 }
 
 Return<Result> DynamicSensorsSubHal::flush(int32_t sensor_handle __unused) {
-- 
cgit v1.2.3


From 35964ba0768558fe61fd225a51015c1b56656ddc Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Mon, 4 Oct 2021 15:17:32 -0700
Subject: dynamic_sensor: Add multi-HAL 2.1 flush support.

Bug: 201730055
Test: Verified that flush, batch, and activate sensor VTS tests pass.
Change-Id: I6721d9f8976b3ef9f6af02b2320833025b479ee6
---
 modules/sensors/dynamic_sensor/BaseSensorObject.cpp  |  1 +
 .../sensors/dynamic_sensor/DynamicSensorManager.cpp  | 20 ++++++++++++--------
 .../sensors/dynamic_sensor/DynamicSensorManager.h    |  1 +
 .../sensors/dynamic_sensor/DynamicSensorsSubHal.cpp  |  7 +++----
 4 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/BaseSensorObject.cpp b/modules/sensors/dynamic_sensor/BaseSensorObject.cpp
index 4ec76b27..69fc7d86 100644
--- a/modules/sensors/dynamic_sensor/BaseSensorObject.cpp
+++ b/modules/sensors/dynamic_sensor/BaseSensorObject.cpp
@@ -42,6 +42,7 @@ void BaseSensorObject::getUuid(uint8_t* uuid) const {
 int BaseSensorObject::flush() {
     static const sensors_event_t event = {
         .type = SENSOR_TYPE_META_DATA,
+        .meta_data.what = META_DATA_FLUSH_COMPLETE,
         .timestamp = TIMESTAMP_AUTO_FILL  // timestamp will be filled at dispatcher
     };
     generateEvent(event);
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp b/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp
index 37b43132..be1a0044 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp
+++ b/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp
@@ -76,7 +76,7 @@ bool DynamicSensorManager::owns(int handle) const {
 
 int DynamicSensorManager::activate(int handle, bool enable) {
     if (handle == mHandleRange.first) {
-        // ignored
+        mMetaSensorActive = enable;
         return 0;
     }
 
@@ -109,13 +109,17 @@ int DynamicSensorManager::setDelay(int handle, nsecs_t sample_period) {
 
 int DynamicSensorManager::flush(int handle) {
     if (handle == mHandleRange.first) {
-        // submit a flush complete here
-        static const sensors_event_t event = {
-            .sensor = mHandleRange.first,
-            .type = SENSOR_TYPE_META_DATA,
-            .timestamp = TIMESTAMP_AUTO_FILL,  // timestamp will be filled at dispatcher
-        };
-        submitEvent(nullptr, event);
+        if (mMetaSensorActive) {
+            static const sensors_event_t event = {
+                .sensor = mHandleRange.first,
+                .type = SENSOR_TYPE_META_DATA,
+                .meta_data.what = META_DATA_FLUSH_COMPLETE,
+                .timestamp = TIMESTAMP_AUTO_FILL,  // timestamp will be filled at dispatcher
+            };
+            submitEvent(nullptr, event);
+        } else {
+            return -EINVAL;
+        }
         return 0;
     }
     return operateSensor(handle, [] (sp<BaseSensorObject> s)->int {return s->flush();});
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorManager.h b/modules/sensors/dynamic_sensor/DynamicSensorManager.h
index b6f39da6..634c5234 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorManager.h
+++ b/modules/sensors/dynamic_sensor/DynamicSensorManager.h
@@ -111,6 +111,7 @@ private:
     // available sensor handle space
     const std::pair<int, int> mHandleRange;
     sensor_t mMetaSensor;
+    bool mMetaSensorActive = false;
 
     // immutable pointer to event callback, used in extention mode.
     SensorEventCallback * const mCallback;
diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
index d9e31824..d5a9b3c0 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
+++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.cpp
@@ -78,10 +78,9 @@ Return<Result> DynamicSensorsSubHal::batch(
     return ResultFromStatus(rc);
 }
 
-Return<Result> DynamicSensorsSubHal::flush(int32_t sensor_handle __unused) {
-    ALOGE("DynamicSensorsSubHal::flush not supported.");
-
-    return Result::INVALID_OPERATION;
+Return<Result> DynamicSensorsSubHal::flush(int32_t sensor_handle) {
+    int rc = mDynamicSensorManager->flush(sensor_handle);
+    return ResultFromStatus(rc);
 }
 
 Return<void> DynamicSensorsSubHal::registerDirectChannel(
-- 
cgit v1.2.3


From 24ead9d84a9d9ef077f4d44995e2add9a79a206d Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Wed, 3 Nov 2021 15:32:49 -0700
Subject: dynamic_sensor: Don't hold mgr lock when operating sensor.

Bug: 205041452
Test: Verified that multiple subscriptions can be made with sensor_test
 to a dynamic sensor without hanging.
Change-Id: Ie7671df8294bee04a0ebe1940242c2a83105f897
---
 .../sensors/dynamic_sensor/DynamicSensorManager.h   | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/DynamicSensorManager.h b/modules/sensors/dynamic_sensor/DynamicSensorManager.h
index 634c5234..264582ec 100644
--- a/modules/sensors/dynamic_sensor/DynamicSensorManager.h
+++ b/modules/sensors/dynamic_sensor/DynamicSensorManager.h
@@ -95,15 +95,18 @@ private:
     // 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;
+        sp<BaseSensorObject> s;
+        {
+            std::lock_guard<std::mutex> lk(mLock);
+            const auto i = mMap.find(handle);
+            if (i == mMap.end()) {
+                return BAD_VALUE;
+            }
+            s = i->second.promote();
+            if (s == nullptr) {
+                // sensor object is already gone
+                return BAD_VALUE;
+            }
         }
         return f(s);
     }
-- 
cgit v1.2.3


From f99f73ceebb4a0cfe7b8554194b9dc54f05a902f Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Mon, 22 Nov 2021 10:56:57 -0800
Subject: dynamic_sensor: Support report and power usage collections.

Bug: 207008609
Test: Verified dynamic sensor sampling.
Change-Id: If0bef3647d5c52f9bf1d92a2a0ead72e98c70b8c
---
 modules/sensors/dynamic_sensor/HidRawSensor.cpp    | 68 ++++++++++++++++++----
 modules/sensors/dynamic_sensor/HidRawSensor.h      |  4 ++
 modules/sensors/dynamic_sensor/HidSensorDef.h      | 30 +++++-----
 .../sensors/dynamic_sensor/HidUtils/HidParser.cpp  |  1 +
 .../sensors/dynamic_sensor/HidUtils/HidParser.h    |  1 +
 5 files changed, 79 insertions(+), 25 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/HidRawSensor.cpp b/modules/sensors/dynamic_sensor/HidRawSensor.cpp
index f3c8a27b..91aed0a5 100644
--- a/modules/sensors/dynamic_sensor/HidRawSensor.cpp
+++ b/modules/sensors/dynamic_sensor/HidRawSensor.cpp
@@ -784,8 +784,9 @@ bool HidRawSensor::detectAndroidCustomSensor(const std::string &description) {
 }
 
 bool HidRawSensor::findSensorControlUsage(const std::vector<HidParser::ReportPacket> &packets) {
+    using namespace Hid::Sensor::PowerStateUsage;
     using namespace Hid::Sensor::PropertyUsage;
-    using namespace Hid::Sensor::RawMinMax;
+    using namespace Hid::Sensor::ReportingStateUsage;
 
     //REPORTING_STATE
     const HidParser::ReportItem *reportingState
@@ -793,13 +794,31 @@ bool HidRawSensor::findSensorControlUsage(const std::vector<HidParser::ReportPac
 
     if (reportingState == nullptr
             || !reportingState->isByteAligned()
-            || reportingState->bitSize != 8
-            || reportingState->minRaw != REPORTING_STATE_MIN
-            || reportingState->maxRaw != REPORTING_STATE_MAX) {
+            || reportingState->bitSize != 8) {
         LOG_W << "Cannot find valid reporting state feature" << LOG_ENDL;
     } else {
         mReportingStateId = reportingState->id;
         mReportingStateOffset = reportingState->bitOffset / 8;
+
+        mReportingStateDisableIndex = -1;
+        mReportingStateEnableIndex = -1;
+        for (unsigned i = 0; i < reportingState->usageVector.size(); ++i) {
+            if (reportingState->usageVector[i] == REPORTING_STATE_NO_EVENTS) {
+                mReportingStateDisableIndex = i;
+            }
+            if (reportingState->usageVector[i] == REPORTING_STATE_ALL_EVENTS) {
+                mReportingStateEnableIndex = i;
+            }
+        }
+        if (mReportingStateDisableIndex < 0) {
+            LOG_W << "Cannot find reporting state to disable sensor"
+                  << LOG_ENDL;
+            mReportingStateId = -1;
+        }
+        if (mReportingStateEnableIndex < 0) {
+            LOG_W << "Cannot find reporting state to enable sensor" << LOG_ENDL;
+            mReportingStateId = -1;
+        }
     }
 
     //POWER_STATE
@@ -807,13 +826,31 @@ bool HidRawSensor::findSensorControlUsage(const std::vector<HidParser::ReportPac
             = find(packets, POWER_STATE, HidParser::REPORT_TYPE_FEATURE);
     if (powerState == nullptr
             || !powerState->isByteAligned()
-            || powerState->bitSize != 8
-            || powerState->minRaw != POWER_STATE_MIN
-            || powerState->maxRaw != POWER_STATE_MAX) {
+            || powerState->bitSize != 8) {
         LOG_W << "Cannot find valid power state feature" << LOG_ENDL;
     } else {
         mPowerStateId = powerState->id;
         mPowerStateOffset = powerState->bitOffset / 8;
+
+        mPowerStateOffIndex = -1;
+        mPowerStateOnIndex = -1;
+        for (unsigned i = 0; i < powerState->usageVector.size(); ++i) {
+            if (powerState->usageVector[i] == POWER_STATE_D4_POWER_OFF) {
+                mPowerStateOffIndex = i;
+            }
+            if (powerState->usageVector[i] == POWER_STATE_D0_FULL_POWER) {
+                mPowerStateOnIndex = i;
+            }
+        }
+        if (mPowerStateOffIndex < 0) {
+            LOG_W << "Cannot find power state to power off sensor"
+                  << LOG_ENDL;
+            mPowerStateId = -1;
+        }
+        if (mPowerStateOnIndex < 0) {
+            LOG_W << "Cannot find power state to power on sensor" << LOG_ENDL;
+            mPowerStateId = -1;
+        }
     }
 
     //REPORT_INTERVAL
@@ -846,7 +883,6 @@ void HidRawSensor::getUuid(uint8_t* uuid) const {
 }
 
 int HidRawSensor::enable(bool enable) {
-    using namespace Hid::Sensor::StateValue;
     SP(HidDevice) device = PROMOTE(mDevice);
 
     if (device == nullptr) {
@@ -864,7 +900,8 @@ int HidRawSensor::enable(bool enable) {
         uint8_t id = static_cast<uint8_t>(mPowerStateId);
         if (device->getFeature(id, &buffer)
                 && buffer.size() > mPowerStateOffset) {
-            buffer[mPowerStateOffset] = enable ? POWER_STATE_FULL_POWER : POWER_STATE_POWER_OFF;
+            buffer[mPowerStateOffset] =
+                    enable ? mPowerStateOnIndex : mPowerStateOffIndex;
             setPowerOk = device->setFeature(id, buffer);
         } else {
             LOG_E << "enable: changing POWER STATE failed" << LOG_ENDL;
@@ -878,7 +915,8 @@ int HidRawSensor::enable(bool enable) {
         if (device->getFeature(id, &buffer)
                 && buffer.size() > mReportingStateOffset) {
             buffer[mReportingStateOffset]
-                    = enable ? REPORTING_STATE_ALL_EVENT : REPORTING_STATE_NO_EVENT;
+                    = enable ? mReportingStateEnableIndex :
+                               mReportingStateDisableIndex;
             setReportingOk = device->setFeature(id, buffer);
         } else {
             LOG_E << "enable: changing REPORTING STATE failed" << LOG_ENDL;
@@ -1019,7 +1057,10 @@ std::string HidRawSensor::dump() const {
     ss << "  Power state ";
     if (mPowerStateId >= 0) {
         ss << "found, id: " << mPowerStateId
-              << " offset: " << mPowerStateOffset << LOG_ENDL;
+              << " offset: " << mPowerStateOffset
+              << " power off index: " << mPowerStateOffIndex
+              << " power on index: " << mPowerStateOnIndex
+              << LOG_ENDL;
     } else {
         ss << "not found" << LOG_ENDL;
     }
@@ -1027,7 +1068,10 @@ std::string HidRawSensor::dump() const {
     ss << "  Reporting state ";
     if (mReportingStateId >= 0) {
         ss << "found, id: " << mReportingStateId
-              << " offset: " << mReportingStateOffset << LOG_ENDL;
+              << " offset: " << mReportingStateOffset
+              << " disable index: " << mReportingStateDisableIndex
+              << " enable index: " << mReportingStateEnableIndex
+              << LOG_ENDL;
     } else {
         ss << "not found" << LOG_ENDL;
     }
diff --git a/modules/sensors/dynamic_sensor/HidRawSensor.h b/modules/sensors/dynamic_sensor/HidRawSensor.h
index 2dd32b61..201e72e9 100644
--- a/modules/sensors/dynamic_sensor/HidRawSensor.h
+++ b/modules/sensors/dynamic_sensor/HidRawSensor.h
@@ -138,9 +138,13 @@ private:
     // Features for control sensor
     int mReportingStateId;
     unsigned int mReportingStateOffset;
+    int mReportingStateDisableIndex;
+    int mReportingStateEnableIndex;
 
     int mPowerStateId;
     unsigned int mPowerStateOffset;
+    int mPowerStateOffIndex;
+    int mPowerStateOnIndex;
 
     int mReportIntervalId;
     unsigned int mReportIntervalOffset;
diff --git a/modules/sensors/dynamic_sensor/HidSensorDef.h b/modules/sensors/dynamic_sensor/HidSensorDef.h
index 2728b28a..8f47a850 100644
--- a/modules/sensors/dynamic_sensor/HidSensorDef.h
+++ b/modules/sensors/dynamic_sensor/HidSensorDef.h
@@ -77,24 +77,28 @@ enum {
 };
 } // namespace ReportUsage
 
-namespace RawMinMax {
+namespace ReportingStateUsage {
 enum {
-    REPORTING_STATE_MIN = 0,
-    REPORTING_STATE_MAX = 5,
-    POWER_STATE_MIN = 0,
-    POWER_STATE_MAX = 5,
+    REPORTING_STATE_NO_EVENTS = 0x0840,
+    REPORTING_STATE_ALL_EVENTS = 0x0841,
+    REPORTING_STATE_REPORT_THRESHOLD_EVENTS = 0x0842,
+    REPORTING_STATE_REPORT_WAKE_ON_NO_EVENTS = 0x0843,
+    REPORTING_STATE_REPORT_WAKE_ON_ALL_EVENTS = 0x0844,
+    REPORTING_STATE_REPORT_WAKE_ON_THRESHOLD_EVENTS = 0x0845,
 };
-} // namespace RawMinMax
+} // namespace ReportingStateUsage
 
-namespace StateValue {
+namespace PowerStateUsage {
 enum {
-    POWER_STATE_FULL_POWER = 1,
-    POWER_STATE_POWER_OFF = 5,
-
-    REPORTING_STATE_ALL_EVENT = 1,
-    REPORTING_STATE_NO_EVENT = 0,
+    POWER_STATE_UNDEFINED = 0x0850,
+    POWER_STATE_D0_FULL_POWER = 0x0851,
+    POWER_STATE_D1_LOW_POWER = 0x0852,
+    POWER_STATE_D2_STANDBY_POWER_WITH_WAKEUP = 0x0853,
+    POWER_STATE_D3_SLEEP_WITH_WAKEUP = 0x0854,
+    POWER_STATE_D4_POWER_OFF = 0x0855,
 };
-} // StateValue
+} // namespace PowerStateUsage
+
 } // namespace Sensor
 } // namespace Hid
 #endif // HID_SENSOR_DEF_H_
diff --git a/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp b/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp
index 264f13c2..704a1b39 100644
--- a/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp
+++ b/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp
@@ -248,6 +248,7 @@ std::vector<HidParser::ReportPacket> HidParser::convertGroupToPacket(
                 ReportItem digest = {
                     .usage = r.getFullUsage(),
                     .id = id,
+                    .usageVector = r.getUsageVector(),
                     .minRaw = logical.first,
                     .maxRaw = logical.second,
                     .a = scale,
diff --git a/modules/sensors/dynamic_sensor/HidUtils/HidParser.h b/modules/sensors/dynamic_sensor/HidUtils/HidParser.h
index 4ef5ec6c..20dcf637 100644
--- a/modules/sensors/dynamic_sensor/HidUtils/HidParser.h
+++ b/modules/sensors/dynamic_sensor/HidUtils/HidParser.h
@@ -89,6 +89,7 @@ struct HidParser::ReportItem {
     unsigned int usage;
     unsigned int id;
     int type; // feature, input or output
+    std::vector<unsigned int> usageVector;
 
     int64_t minRaw;
     int64_t maxRaw;
-- 
cgit v1.2.3


From 4cb45aba7f1bab4465e61b517b6784de4e98529e Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Mon, 29 Nov 2021 15:39:47 -0800
Subject: dynamic_sensor: Support non-8-bit sized HID report items.

Bug: 207008609
Test: Verified dynamic sensor sampling.
Test: Verified unit tests pass.
Change-Id: I797ccabadefa0dde59fd0f3e8541f9853d657f3f
---
 modules/sensors/dynamic_sensor/HidRawSensor.cpp    | 75 +++++++++++-----------
 modules/sensors/dynamic_sensor/HidRawSensor.h      | 10 +--
 modules/sensors/dynamic_sensor/HidUtils/Android.bp | 18 ++++++
 .../sensors/dynamic_sensor/HidUtils/HidParser.cpp  |  1 +
 .../sensors/dynamic_sensor/HidUtils/HidParser.h    |  1 +
 .../sensors/dynamic_sensor/HidUtils/HidUtils.cpp   | 72 +++++++++++++++++++++
 modules/sensors/dynamic_sensor/HidUtils/HidUtils.h | 29 +++++++++
 .../dynamic_sensor/HidUtils/test/CopyBitsTest.cpp  | 73 +++++++++++++++++++++
 8 files changed, 236 insertions(+), 43 deletions(-)
 create mode 100644 modules/sensors/dynamic_sensor/HidUtils/HidUtils.cpp
 create mode 100644 modules/sensors/dynamic_sensor/HidUtils/HidUtils.h
 create mode 100644 modules/sensors/dynamic_sensor/HidUtils/test/CopyBitsTest.cpp

diff --git a/modules/sensors/dynamic_sensor/HidRawSensor.cpp b/modules/sensors/dynamic_sensor/HidRawSensor.cpp
index 91aed0a5..531ab9d5 100644
--- a/modules/sensors/dynamic_sensor/HidRawSensor.cpp
+++ b/modules/sensors/dynamic_sensor/HidRawSensor.cpp
@@ -19,6 +19,8 @@
 #include <utils/Errors.h>
 #include "HidLog.h"
 
+#include <HidUtils.h>
+
 #include <algorithm>
 #include <cfloat>
 #include <codecvt>
@@ -792,13 +794,12 @@ bool HidRawSensor::findSensorControlUsage(const std::vector<HidParser::ReportPac
     const HidParser::ReportItem *reportingState
             = find(packets, REPORTING_STATE, HidParser::REPORT_TYPE_FEATURE);
 
-    if (reportingState == nullptr
-            || !reportingState->isByteAligned()
-            || reportingState->bitSize != 8) {
+    if (reportingState == nullptr) {
         LOG_W << "Cannot find valid reporting state feature" << LOG_ENDL;
     } else {
         mReportingStateId = reportingState->id;
-        mReportingStateOffset = reportingState->bitOffset / 8;
+        mReportingStateBitOffset = reportingState->bitOffset;
+        mReportingStateBitSize = reportingState->bitSize;
 
         mReportingStateDisableIndex = -1;
         mReportingStateEnableIndex = -1;
@@ -824,13 +825,12 @@ bool HidRawSensor::findSensorControlUsage(const std::vector<HidParser::ReportPac
     //POWER_STATE
     const HidParser::ReportItem *powerState
             = find(packets, POWER_STATE, HidParser::REPORT_TYPE_FEATURE);
-    if (powerState == nullptr
-            || !powerState->isByteAligned()
-            || powerState->bitSize != 8) {
+    if (powerState == nullptr) {
         LOG_W << "Cannot find valid power state feature" << LOG_ENDL;
     } else {
         mPowerStateId = powerState->id;
-        mPowerStateOffset = powerState->bitOffset / 8;
+        mPowerStateBitOffset = powerState->bitOffset;
+        mPowerStateBitSize = powerState->bitSize;
 
         mPowerStateOffIndex = -1;
         mPowerStateOnIndex = -1;
@@ -857,14 +857,12 @@ bool HidRawSensor::findSensorControlUsage(const std::vector<HidParser::ReportPac
     const HidParser::ReportItem *reportInterval
             = find(packets, REPORT_INTERVAL, HidParser::REPORT_TYPE_FEATURE);
     if (reportInterval == nullptr
-            || !reportInterval->isByteAligned()
-            || reportInterval->minRaw < 0
-            || (reportInterval->bitSize != 16 && reportInterval->bitSize != 32)) {
+            || reportInterval->minRaw < 0) {
         LOG_W << "Cannot find valid report interval feature" << LOG_ENDL;
     } else {
         mReportIntervalId = reportInterval->id;
-        mReportIntervalOffset = reportInterval->bitOffset / 8;
-        mReportIntervalSize = reportInterval->bitSize / 8;
+        mReportIntervalBitOffset = reportInterval->bitOffset;
+        mReportIntervalBitSize = reportInterval->bitSize;
 
         mFeatureInfo.minDelay = std::max(static_cast<int64_t>(1), reportInterval->minRaw) * 1000;
         mFeatureInfo.maxDelay = std::min(static_cast<int64_t>(1000000),
@@ -899,9 +897,11 @@ int HidRawSensor::enable(bool enable) {
         setPowerOk = false;
         uint8_t id = static_cast<uint8_t>(mPowerStateId);
         if (device->getFeature(id, &buffer)
-                && buffer.size() > mPowerStateOffset) {
-            buffer[mPowerStateOffset] =
-                    enable ? mPowerStateOnIndex : mPowerStateOffIndex;
+                && (8 * buffer.size()) >=
+                   (mPowerStateBitOffset + mPowerStateBitSize)) {
+            uint8_t index = enable ? mPowerStateOnIndex : mPowerStateOffIndex;
+            HidUtil::copyBits(&index, &(buffer[0]), buffer.size(),
+                              0, mPowerStateBitOffset, mPowerStateBitSize);
             setPowerOk = device->setFeature(id, buffer);
         } else {
             LOG_E << "enable: changing POWER STATE failed" << LOG_ENDL;
@@ -913,10 +913,12 @@ int HidRawSensor::enable(bool enable) {
         setReportingOk = false;
         uint8_t id = static_cast<uint8_t>(mReportingStateId);
         if (device->getFeature(id, &buffer)
-                && buffer.size() > mReportingStateOffset) {
-            buffer[mReportingStateOffset]
-                    = enable ? mReportingStateEnableIndex :
-                               mReportingStateDisableIndex;
+                && (8 * buffer.size()) >
+                   (mReportingStateBitOffset + mReportingStateBitSize)) {
+            uint8_t index = enable ? mReportingStateEnableIndex :
+                                     mReportingStateDisableIndex;
+            HidUtil::copyBits(&index, &(buffer[0]), buffer.size(),0,
+                              mReportingStateBitOffset, mReportingStateBitSize);
             setReportingOk = device->setFeature(id, buffer);
         } else {
             LOG_E << "enable: changing REPORTING STATE failed" << LOG_ENDL;
@@ -949,22 +951,15 @@ int HidRawSensor::batch(int64_t samplingPeriod, int64_t batchingPeriod) {
         ok = false;
         uint8_t id = static_cast<uint8_t>(mReportIntervalId);
         if (device->getFeature(id, &buffer)
-                && buffer.size() >= mReportIntervalOffset + mReportIntervalSize) {
+                && (8 * buffer.size()) >=
+                   (mReportIntervalBitOffset + mReportIntervalBitSize)) {
             int64_t periodMs = samplingPeriod / 1000000; //ns -> ms
-            switch (mReportIntervalSize) {
-                case sizeof(uint16_t):
-                    periodMs = std::min(periodMs, static_cast<int64_t>(UINT16_MAX));
-                    buffer[mReportIntervalOffset] = periodMs & 0xFF;
-                    buffer[mReportIntervalOffset + 1] = (periodMs >> 8) & 0xFF;
-                    break;
-                case sizeof(uint32_t):
-                    periodMs = std::min(periodMs, static_cast<int64_t>(UINT32_MAX));
-                    buffer[mReportIntervalOffset] = periodMs & 0xFF;
-                    buffer[mReportIntervalOffset + 1] = (periodMs >> 8) & 0xFF;
-                    buffer[mReportIntervalOffset + 2] = (periodMs >> 16) & 0xFF;
-                    buffer[mReportIntervalOffset + 3] = (periodMs >> 24) & 0xFF;
-                    break;
-            }
+            int64_t maxPeriodMs =
+                (1LL << std::min(mReportIntervalBitSize, 63U)) - 1;
+            periodMs = std::min(periodMs, maxPeriodMs);
+            HidUtil::copyBits(&periodMs, &(buffer[0]), buffer.size(),
+                              0, mReportIntervalBitOffset,
+                              mReportIntervalBitSize);
             ok = device->setFeature(id, buffer);
         }
     }
@@ -1057,7 +1052,8 @@ std::string HidRawSensor::dump() const {
     ss << "  Power state ";
     if (mPowerStateId >= 0) {
         ss << "found, id: " << mPowerStateId
-              << " offset: " << mPowerStateOffset
+              << " bit offset: " << mPowerStateBitOffset
+              << " bit size: " << mPowerStateBitSize
               << " power off index: " << mPowerStateOffIndex
               << " power on index: " << mPowerStateOnIndex
               << LOG_ENDL;
@@ -1068,7 +1064,8 @@ std::string HidRawSensor::dump() const {
     ss << "  Reporting state ";
     if (mReportingStateId >= 0) {
         ss << "found, id: " << mReportingStateId
-              << " offset: " << mReportingStateOffset
+              << " bit offset: " << mReportingStateBitOffset
+              << " bit size: " << mReportingStateBitSize
               << " disable index: " << mReportingStateDisableIndex
               << " enable index: " << mReportingStateEnableIndex
               << LOG_ENDL;
@@ -1079,8 +1076,8 @@ std::string HidRawSensor::dump() const {
     ss << "  Report interval ";
     if (mReportIntervalId >= 0) {
         ss << "found, id: " << mReportIntervalId
-              << " offset: " << mReportIntervalOffset
-              << " size: " << mReportIntervalSize << LOG_ENDL;
+              << " bit offset: " << mReportIntervalBitOffset
+              << " bit size: " << mReportIntervalBitSize << LOG_ENDL;
     } else {
         ss << "not found" << LOG_ENDL;
     }
diff --git a/modules/sensors/dynamic_sensor/HidRawSensor.h b/modules/sensors/dynamic_sensor/HidRawSensor.h
index 201e72e9..99ddfe30 100644
--- a/modules/sensors/dynamic_sensor/HidRawSensor.h
+++ b/modules/sensors/dynamic_sensor/HidRawSensor.h
@@ -137,18 +137,20 @@ private:
 
     // Features for control sensor
     int mReportingStateId;
-    unsigned int mReportingStateOffset;
+    unsigned int mReportingStateBitOffset;
+    unsigned int mReportingStateBitSize;
     int mReportingStateDisableIndex;
     int mReportingStateEnableIndex;
 
     int mPowerStateId;
-    unsigned int mPowerStateOffset;
+    unsigned int mPowerStateBitOffset;
+    unsigned int mPowerStateBitSize;
     int mPowerStateOffIndex;
     int mPowerStateOnIndex;
 
     int mReportIntervalId;
-    unsigned int mReportIntervalOffset;
-    unsigned int mReportIntervalSize;
+    unsigned int mReportIntervalBitOffset;
+    unsigned int mReportIntervalBitSize;
 
     // Input report translate table
     std::vector<ReportTranslateRecord> mTranslateTable;
diff --git a/modules/sensors/dynamic_sensor/HidUtils/Android.bp b/modules/sensors/dynamic_sensor/HidUtils/Android.bp
index bbed0327..5823c794 100644
--- a/modules/sensors/dynamic_sensor/HidUtils/Android.bp
+++ b/modules/sensors/dynamic_sensor/HidUtils/Android.bp
@@ -45,6 +45,7 @@ cc_library {
         "HidParser.cpp",
         "HidReport.cpp",
         "HidTree.cpp",
+        "HidUtils.cpp",
     ],
     export_include_dirs: ["."],
 
@@ -99,3 +100,20 @@ cc_test_host {
 
     local_include_dirs: ["test"],
 }
+
+//
+// Test for HidUtils
+//
+cc_test_host {
+    name: "hid_utils_test",
+    defaults: ["hid_defaults"],
+
+    srcs: ["test/CopyBitsTest.cpp"],
+
+    shared_libs: [
+        "libhidparser",
+    ],
+
+    local_include_dirs: ["test"],
+}
+
diff --git a/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp b/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp
index 704a1b39..28d87d97 100644
--- a/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp
+++ b/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp
@@ -317,4 +317,5 @@ std::ostream& operator<<(std::ostream &os, const HidParser::DigestVector &digest
     os << LOG_ENDL;
     return os;
 }
+
 } // namespace HidUtil
diff --git a/modules/sensors/dynamic_sensor/HidUtils/HidParser.h b/modules/sensors/dynamic_sensor/HidUtils/HidParser.h
index 20dcf637..cb4a92a8 100644
--- a/modules/sensors/dynamic_sensor/HidUtils/HidParser.h
+++ b/modules/sensors/dynamic_sensor/HidUtils/HidParser.h
@@ -174,6 +174,7 @@ struct HidParser::ReportPacket {
 };
 
 std::ostream& operator<<(std::ostream &os, const HidParser::DigestVector &digest2);
+
 } // namespace HidUtil
 
 #endif // HIDUTIL_HIDPARSER_H_
diff --git a/modules/sensors/dynamic_sensor/HidUtils/HidUtils.cpp b/modules/sensors/dynamic_sensor/HidUtils/HidUtils.cpp
new file mode 100644
index 00000000..0cce2a39
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/HidUtils/HidUtils.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2021 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 "HidUtils.h"
+#include <stdint.h>
+#include <algorithm>
+
+namespace HidUtil {
+
+void copyBits(const void *src, void *dst, size_t dst_size,
+              unsigned int src_bit_offset, unsigned int dst_bit_offset,
+              unsigned int bit_count) {
+    const uint8_t *p_src;
+    uint8_t       *p_dst;
+    uint8_t        dst_mask;
+    unsigned int   bits_rem;
+    unsigned int   bit_block_count;
+
+    // Do nothing if copying past the end of the destination buffer.
+    if ((static_cast<size_t>(dst_bit_offset) > (8 * dst_size)) ||
+        (static_cast<size_t>(bit_count) > (8 * dst_size)) ||
+        (static_cast<size_t>(dst_bit_offset + bit_count) > (8 * dst_size))) {
+        return;
+    }
+
+    // Copy bits from source to destination buffer.
+    p_src = static_cast<const uint8_t*>(src) + (src_bit_offset / 8);
+    src_bit_offset = src_bit_offset % 8;
+    p_dst = static_cast<uint8_t*>(dst) + (dst_bit_offset / 8);
+    dst_bit_offset = dst_bit_offset % 8;
+    bits_rem = bit_count;
+    while (bits_rem > 0) {
+        // Determine the size of the next block of bits to copy. The block must
+        // not cross a source or desintation byte boundary.
+        bit_block_count = std::min(bits_rem, 8 - src_bit_offset);
+        bit_block_count = std::min(bit_block_count, 8 - dst_bit_offset);
+
+        // Determine the destination bit block mask.
+        dst_mask = ((1 << bit_block_count) - 1) << dst_bit_offset;
+
+        // Copy the block of bits.
+        *p_dst = (*p_dst & ~dst_mask) |
+                 (((*p_src >> src_bit_offset) << dst_bit_offset) & dst_mask);
+
+        // Advance past the block of copied bits in the source.
+        src_bit_offset += bit_block_count;
+        p_src += src_bit_offset / 8;
+        src_bit_offset = src_bit_offset % 8;
+
+        // Advance past the block of copied bits in the destination.
+        dst_bit_offset += bit_block_count;
+        p_dst += dst_bit_offset / 8;
+        dst_bit_offset = dst_bit_offset % 8;
+
+        // Decrement the number of bits remaining.
+        bits_rem -= bit_block_count;
+    }
+}
+
+} // namespace HidUtil
diff --git a/modules/sensors/dynamic_sensor/HidUtils/HidUtils.h b/modules/sensors/dynamic_sensor/HidUtils/HidUtils.h
new file mode 100644
index 00000000..54aa31e9
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/HidUtils/HidUtils.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 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 HIDUTIL_HIDUTILS_H_
+#define HIDUTIL_HIDUTILS_H_
+
+#include <stddef.h>
+
+namespace HidUtil {
+
+void copyBits(const void *src, void *dst, size_t dst_size,
+              unsigned int src_bit_offset, unsigned int dst_bit_offset,
+              unsigned int bit_count);
+
+} // namespace HidUtil
+
+#endif // HIDUTIL_HIDUTILS_H_
diff --git a/modules/sensors/dynamic_sensor/HidUtils/test/CopyBitsTest.cpp b/modules/sensors/dynamic_sensor/HidUtils/test/CopyBitsTest.cpp
new file mode 100644
index 00000000..1b1ca709
--- /dev/null
+++ b/modules/sensors/dynamic_sensor/HidUtils/test/CopyBitsTest.cpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2021 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 "HidUtils.h"
+#include <gtest/gtest.h>
+
+using HidUtil::copyBits;
+
+TEST(CopyBitsTest, CopyBits) {
+    const struct {
+        uint32_t src;
+        uint32_t dst;
+        int src_bit_offset;
+        int dst_bit_offset;
+        int bit_count;
+        uint32_t expected_dst;
+    } kTestVectorList[] = {
+        { 0x00000005, 0x00000000,  0,  0,  8, 0x00000005 },
+        { 0x00000005, 0x00000000,  0,  4,  8, 0x00000050 },
+        { 0x0000000C, 0x00000020,  0,  4,  8, 0x000000C0 },
+        { 0x00000005, 0x0000F02F,  0,  4,  8, 0x0000F05F },
+        { 0x12345678, 0x87654321,  5, 11, 17, 0x8D159B21 },
+        { 0x12345678, 0x87654321, 11,  5, 17, 0x8748D141 },
+    };
+
+    for (auto test_vector : kTestVectorList) {
+        uint32_t dst = test_vector.dst;
+        copyBits(&(test_vector.src), &dst, sizeof(dst),
+                 test_vector.src_bit_offset, test_vector.dst_bit_offset,
+                 test_vector.bit_count);
+        EXPECT_EQ(test_vector.expected_dst, dst);
+    }
+}
+
+TEST(CopyBitsTest, Overflow) {
+    const struct {
+        uint32_t src;
+        uint32_t dst;
+        unsigned int src_bit_offset;
+        unsigned int dst_bit_offset;
+        unsigned int bit_count;
+        uint32_t expected_dst;
+    } kTestVectorList[] = {
+        { 0x000000FF, 0x00000000,  0,        0,        8, 0x000000FF },
+        { 0x000000FF, 0x00000000,  0,       24,        8, 0xFF000000 },
+        { 0x000000FF, 0x00000000,  0,       25,        8, 0x00000000 },
+        { 0x000000FF, 0x00000000,  0,       32,        8, 0x00000000 },
+        { 0x000000FF, 0x00000000,  0, UINT_MAX,        8, 0x00000000 },
+        { 0x000000FF, 0x00000000,  0,        8, UINT_MAX, 0x00000000 },
+    };
+
+    for (auto test_vector : kTestVectorList) {
+        uint32_t dst = test_vector.dst;
+        copyBits(&(test_vector.src), &dst, sizeof(dst),
+                 test_vector.src_bit_offset, test_vector.dst_bit_offset,
+                 test_vector.bit_count);
+        EXPECT_EQ(test_vector.expected_dst, dst);
+    }
+}
+
-- 
cgit v1.2.3


From dbf2545214d16eaed5901bd41c8c8e8871ef0168 Mon Sep 17 00:00:00 2001
From: Erik Staats <estaats@google.com>
Date: Thu, 2 Dec 2021 14:41:55 -0800
Subject: dynamic_sensor: Support recognizing head tracker sensor.

Bug: 207008609
Test: Verified dynamic sensor sampling with proposed standard Android
 head tracker.
Test: Verified dynamic sensor sampling with custom Android sensor.
Change-Id: Ia9b991d4a8f7de132cb8509bcc84c51f62e56b31
---
 modules/sensors/dynamic_sensor/HidRawSensor.cpp | 59 ++++++++++++++++++-------
 modules/sensors/dynamic_sensor/HidRawSensor.h   |  8 ++++
 2 files changed, 50 insertions(+), 17 deletions(-)

diff --git a/modules/sensors/dynamic_sensor/HidRawSensor.cpp b/modules/sensors/dynamic_sensor/HidRawSensor.cpp
index 531ab9d5..8aaf2d4f 100644
--- a/modules/sensors/dynamic_sensor/HidRawSensor.cpp
+++ b/modules/sensors/dynamic_sensor/HidRawSensor.cpp
@@ -492,13 +492,8 @@ bool HidRawSensor::populateFeatureValueFromFeatureReport(
                     }
                     break;
                 case SENSOR_DESCRIPTION:
-                    if (!r.isByteAligned() || r.bitSize != 16 || r.count < 1
-                            || (r.bitOffset / 8 + r.count * 2) > buffer.size() ) {
-                        // invalid description
-                        break;
-                    }
                     if (decodeString(r, buffer, &str)) {
-                        mFeatureInfo.isAndroidCustom = detectAndroidCustomSensor(str);
+                        detectSensorFromDescription(str);
                     }
                     break;
                 default:
@@ -583,26 +578,34 @@ bool HidRawSensor::validateFeatureValueAndBuildSensor() {
 
 bool HidRawSensor::decodeString(
         const HidParser::ReportItem &report, const std::vector<uint8_t> &buffer, std::string *d) {
-    if (!report.isByteAligned() || report.bitSize != 16 || report.count < 1) {
+    if (!report.isByteAligned() ||
+        (report.bitSize != 8 && report.bitSize != 16) || report.count < 1) {
         return false;
     }
 
+    size_t charSize = report.bitSize / 8;
     size_t offset = report.bitOffset / 8;
-    if (offset + report.count * 2 > buffer.size()) {
+    if (offset + report.count * charSize > buffer.size()) {
         return false;
     }
 
-    std::vector<uint16_t> data(report.count);
-    auto i = data.begin();
-    auto j = buffer.begin() + offset;
-    for ( ; i != data.end(); ++i, j += sizeof(uint16_t)) {
-        // hid specified little endian
-        *i = *j + (*(j + 1) << 8);
+    if (charSize == 1) {
+        *d = std::string(buffer.begin() + offset,
+                         buffer.begin() + offset + report.count);
+    } else {
+        std::vector<uint16_t> data(report.count);
+        auto i = data.begin();
+        auto j = buffer.begin() + offset;
+        for ( ; i != data.end(); ++i, j += sizeof(uint16_t)) {
+            // hid specified little endian
+            *i = *j + (*(j + 1) << 8);
+        }
+        std::wstring wstr(data.begin(), data.end());
+
+        std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
+        *d = converter.to_bytes(wstr);
     }
-    std::wstring wstr(data.begin(), data.end());
 
-    std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
-    *d = converter.to_bytes(wstr);
     return true;
 }
 
@@ -621,6 +624,28 @@ std::vector<std::string> split(const std::string &text, char sep) {
     return tokens;
 }
 
+void HidRawSensor::detectSensorFromDescription(const std::string &description) {
+    if (detectAndroidHeadTrackerSensor(description) ||
+        detectAndroidCustomSensor(description)) {
+        mFeatureInfo.isAndroidCustom = true;
+    }
+}
+
+bool HidRawSensor::detectAndroidHeadTrackerSensor(
+        const std::string &description) {
+    if (description.find("#AndroidHeadTracker#1.") != 0) {
+        return false;
+    }
+
+    mFeatureInfo.type = SENSOR_TYPE_DEVICE_PRIVATE_BASE;
+    mFeatureInfo.typeString = CUSTOM_TYPE_PREFIX + "headtracker";
+    mFeatureInfo.reportModeFlag = SENSOR_FLAG_CONTINUOUS_MODE;
+    mFeatureInfo.permission = "";
+    mFeatureInfo.isWakeUp = false;
+
+    return true;
+}
+
 bool HidRawSensor::detectAndroidCustomSensor(const std::string &description) {
     size_t nullPosition = description.find('\0');
     if (nullPosition == std::string::npos) {
diff --git a/modules/sensors/dynamic_sensor/HidRawSensor.h b/modules/sensors/dynamic_sensor/HidRawSensor.h
index 99ddfe30..0989651f 100644
--- a/modules/sensors/dynamic_sensor/HidRawSensor.h
+++ b/modules/sensors/dynamic_sensor/HidRawSensor.h
@@ -121,6 +121,14 @@ private:
     // helper function to find sensor control feature usage from packets
     bool findSensorControlUsage(const std::vector<HidParser::ReportPacket> &packets);
 
+    // try to parse sensor description feature value to see if it matches any
+    // known sensors
+    void detectSensorFromDescription(const std::string &description);
+
+    // try to parse sensor description feature value to see if it matches the
+    // Android header tracker sensor
+    bool detectAndroidHeadTrackerSensor(const std::string &description);
+
     // try to parse sensor description feature value to see if it matches
     // android specified custom sensor definition.
     bool detectAndroidCustomSensor(const std::string &description);
-- 
cgit v1.2.3


From 0b5ab223e110f3a34b30e7b61e4ea68c03dba98b Mon Sep 17 00:00:00 2001
From: YiMing Tseng <yimingtseng@google.com>
Date: Thu, 11 Nov 2021 14:05:30 +0800
Subject: Add GRALLOC_FRAMEBUFFER_NUM configuration

Add config to set the NUM_BUFFERS. Set NUM_BUFFERS to 1 can
prevent page flipping and set it to a larger number can allow
userspace to fill up the following frame earlier.

Bug: 205917753
Change-Id: Ibf4a52a1e35f4a2404008a48b637cb82c4b46365
---
 modules/gralloc/Android.mk      | 3 +++
 modules/gralloc/framebuffer.cpp | 7 +++++--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/modules/gralloc/Android.mk b/modules/gralloc/Android.mk
index 439c95dd..4c4899ea 100644
--- a/modules/gralloc/Android.mk
+++ b/modules/gralloc/Android.mk
@@ -38,5 +38,8 @@ LOCAL_CFLAGS:= -DLOG_TAG=\"gralloc\" -Wno-missing-field-initializers
 ifeq ($(TARGET_USE_PAN_DISPLAY),true)
 LOCAL_CFLAGS += -DUSE_PAN_DISPLAY=1
 endif
+ifneq ($(GRALLOC_FRAMEBUFFER_NUM),)
+LOCAL_CFLAGS += -DNUM_BUFFERS=$(GRALLOC_FRAMEBUFFER_NUM)
+endif
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/modules/gralloc/framebuffer.cpp b/modules/gralloc/framebuffer.cpp
index b2ec3e44..fc220dbc 100644
--- a/modules/gralloc/framebuffer.cpp
+++ b/modules/gralloc/framebuffer.cpp
@@ -45,8 +45,10 @@
 #define USE_PAN_DISPLAY 0
 #endif
 
-// numbers of buffers for page flipping
+// Enabling page flipping by default
+#ifndef NUM_BUFFERS
 #define NUM_BUFFERS 2
+#endif
 
 
 enum {
@@ -157,7 +159,8 @@ int mapFrameBufferLocked(struct private_module_t* module, int format)
     info.activate = FB_ACTIVATE_NOW;
 
     /*
-     * Request NUM_BUFFERS screens (at lest 2 for page flipping)
+     * Request NUM_BUFFERS screens
+     * To enable page flipping, NUM_BUFFERS should be at least 2.
      */
     info.yres_virtual = info.yres * NUM_BUFFERS;
 
-- 
cgit v1.2.3