From dd45428ffa7f487039df573f6d443484381f9f61 Mon Sep 17 00:00:00 2001 From: Ray Essick Date: Tue, 1 Mar 2022 15:45:33 -0800 Subject: drop no-longer-needed apex_available clause on libhardware codec2/vndk referenced, but did not use, libhardware. Now that the reference is cleaned, we don't need to to export to apex's. Bug: 221444002 Test: build, boot Change-Id: I43bff5cab71d53d8c7422c13265f129b26ca0430 --- Android.bp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/Android.bp b/Android.bp index a8f4fe4c..92c77faa 100644 --- a/Android.bp +++ b/Android.bp @@ -99,9 +99,4 @@ cc_library_shared { }, }, min_sdk_version: "29", - apex_available: [ - "//apex_available:platform", - "com.android.media.swcodec", - "test_com.android.media.swcodec", - ], } -- cgit v1.2.3 From b9769d799cc69a5d7ecc2dfaa47f7a8dd37264a1 Mon Sep 17 00:00:00 2001 From: Brian Duddie Date: Fri, 1 Apr 2022 09:41:41 -0700 Subject: Change dynamic sensors handle base to 1 Fixes: 227766975 Test: load on device, confirm handle number changed Change-Id: I0466784d7e468bd785f2525f1ab7cd02cc5436e8 --- modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h index e9a46d68..f59b00ae 100644 --- a/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h +++ b/modules/sensors/dynamic_sensor/DynamicSensorsSubHal.h @@ -71,7 +71,7 @@ public: const sensors_event_t& e) override; private: - static constexpr int32_t kDynamicHandleBase = 0; + static constexpr int32_t kDynamicHandleBase = 1; static constexpr int32_t kDynamicHandleEnd = 0x1000000; static constexpr int32_t kMaxDynamicHandleCount = kDynamicHandleEnd - kDynamicHandleBase; -- cgit v1.2.3 From 9b8bc0f7c1fd4565572a894d4f5380e9ae0905b9 Mon Sep 17 00:00:00 2001 From: Erik Staats Date: Fri, 1 Apr 2022 11:04:54 -0700 Subject: dynamic_sensor: Support timing out sensor operations. Bug: 226012902 Test: Used uhid-sample to add a dynamic sensor and verified it can be sampled. Test: Simulated start sampling ioctl timeout and verified operation completes with a timeout and eventually cleans up. Test: Simulated start sampling ioctl timeout with device removal before completion and verified operation completes with a timeout and eventually cleans up. Change-Id: I9a957bc1e4000b2c587278146ecbe6e903010616 --- .../dynamic_sensor/DynamicSensorManager.cpp | 85 +++++++++++++++++++++- .../sensors/dynamic_sensor/DynamicSensorManager.h | 35 +++++---- 2 files changed, 100 insertions(+), 20 deletions(-) diff --git a/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp b/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp index be1a0044..efac5e95 100644 --- a/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp +++ b/modules/sensors/dynamic_sensor/DynamicSensorManager.cpp @@ -87,7 +87,7 @@ int DynamicSensorManager::activate(int handle, bool enable) { } return operateSensor(handle, - [&enable] (sp s)->int { + [=] (sp s)->int { return s->enable(enable); }); } @@ -98,7 +98,7 @@ int DynamicSensorManager::batch(int handle, nsecs_t sample_period, nsecs_t batch return 0; } return operateSensor(handle, - [&sample_period, &batch_period] (sp s)->int { + [=] (sp s)->int { return s->batch(sample_period, batch_period); }); } @@ -239,6 +239,87 @@ const sensor_t& DynamicSensorManager::getDynamicMetaSensor() const { return mMetaSensor; } +int DynamicSensorManager::operateSensor( + int handle, OperateSensorFunc sensorFunc) { + std::shared_future sensorOp; + { + std::lock_guard lock(mSensorOpQueueLock); + + // Invoke the function asynchronously. + sensorOp = std::async( + [this, handle = handle, sensorFunc = sensorFunc, + sensorOpIndex = mNextSensorOpIndex] ()->int { + return operateSensor(handle, sensorFunc, sensorOpIndex); + }).share(); + + // Add sensor operation to the queue. + mSensorOpQueue.push({mNextSensorOpIndex, sensorOp}); + mNextSensorOpIndex++; + } + + // Wait for the sensor operation to complete. + if (sensorOp.wait_for(kSensorOpTimeout) != std::future_status::ready) { + ALOGE("sensor operation timed out"); + return TIMED_OUT; + } + + return sensorOp.get(); +} + +int DynamicSensorManager::operateSensor( + int handle, OperateSensorFunc sensorFunc, uint64_t sensorOpIndex) { + int rv = 0; + + // Wait until this sensor operation is at the head of the queue. + while (1) { + std::shared_future headSensorOp; + + { + std::lock_guard lock(mSensorOpQueueLock); + + if (mSensorOpQueue.front().first == sensorOpIndex) { + break; + } + headSensorOp = mSensorOpQueue.front().second; + } + headSensorOp.wait(); + } + + // Perform sensor operation. + sp sensor; + { + std::lock_guard lk(mLock); + const auto i = mMap.find(handle); + if (i == mMap.end()) { + rv = BAD_VALUE; + } + if (rv == 0) { + sensor = i->second.promote(); + if (sensor == nullptr) { + // sensor object is already gone + rv = BAD_VALUE; + } + } + } + if (rv == 0) { + rv = sensorFunc(sensor); + } + + // Remove sensor operation from queue. When the operation's shared state is + // destroyed, execution of this function ceases. Thus, if the state is + // destroyed when the operation is removed from the queue, the lock will + // never be released. To prevent that, the state is shared locally, so it + // isn't destroyed until this function completes. + std::shared_future sensorOp; + { + std::lock_guard lock(mSensorOpQueueLock); + sensorOp = mSensorOpQueue.front().second; + mSensorOpQueue.pop(); + } + + return rv; +} + DynamicSensorManager::ConnectionReport::ConnectionReport( int handle, sp sensor) : mSensor(*(sensor->getSensor())), diff --git a/modules/sensors/dynamic_sensor/DynamicSensorManager.h b/modules/sensors/dynamic_sensor/DynamicSensorManager.h index 264582ec..b8a73203 100644 --- a/modules/sensors/dynamic_sensor/DynamicSensorManager.h +++ b/modules/sensors/dynamic_sensor/DynamicSensorManager.h @@ -22,7 +22,9 @@ #include #include +#include #include +#include #include #include #include @@ -92,24 +94,13 @@ private: // returns next available handle to use upon a new sensor connection, or -1 if we run out. int getNextAvailableHandle(); - // TF: int foo(sp obj); - template - int operateSensor(int handle, TF f) const { - sp s; - { - std::lock_guard 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); - } + // Runs a sensor function with a timeout. On timeout, function could still + // be running, so any function parameter or closure lifetimes should match + // the function's lifetime. + using OperateSensorFunc = std::function)>; + int operateSensor(int handle, OperateSensorFunc sensorFunc); + int operateSensor(int handle, OperateSensorFunc sensorFunc, + uint64_t sensorOpIndex); // available sensor handle space const std::pair mHandleRange; @@ -133,6 +124,14 @@ private: // daemons std::vector> mDaemonVector; + + // Sensor operation queue. Calls to the sensor HAL must complete within 1 + // second. + static constexpr std::chrono::milliseconds + kSensorOpTimeout = std::chrono::milliseconds(900); + std::mutex mSensorOpQueueLock; + std::queue>> mSensorOpQueue; + uint64_t mNextSensorOpIndex = 0; }; } // namespace SensorHalExt -- cgit v1.2.3 From fdb42f78cdce22e13353f3e3b529ac13ebf0f18f Mon Sep 17 00:00:00 2001 From: Erik Staats Date: Wed, 6 Apr 2022 15:24:28 -0700 Subject: dynamic_sensor: Fix HID min/max sample rate computation. Bug: 228369656 Test: Used uhid-sample to add a dynamic sensor and verified correct min/max sample rate. Change-Id: I88a1bec26a03a97ee7a3c590d2601151b89ee545 --- modules/sensors/dynamic_sensor/HidRawSensor.cpp | 20 +++++++++++++++----- modules/sensors/dynamic_sensor/HidRawSensor.h | 2 ++ .../sensors/dynamic_sensor/HidUtils/HidParser.cpp | 10 ++++++++-- 3 files changed, 25 insertions(+), 7 deletions(-) diff --git a/modules/sensors/dynamic_sensor/HidRawSensor.cpp b/modules/sensors/dynamic_sensor/HidRawSensor.cpp index 4520ddaa..3759e7e9 100644 --- a/modules/sensors/dynamic_sensor/HidRawSensor.cpp +++ b/modules/sensors/dynamic_sensor/HidRawSensor.cpp @@ -891,10 +891,18 @@ bool HidRawSensor::findSensorControlUsage(const std::vectorid; mReportIntervalBitOffset = reportInterval->bitOffset; mReportIntervalBitSize = reportInterval->bitSize; - - mFeatureInfo.minDelay = std::max(static_cast(1), reportInterval->minRaw) * 1000; - mFeatureInfo.maxDelay = std::min(static_cast(1000000), - reportInterval->maxRaw) * 1000; // maximum 1000 second + mReportIntervalScale = reportInterval->a; + mReportIntervalOffset = reportInterval->b; + + mFeatureInfo.minDelay = 1000000.0 + * (reportInterval->minRaw + reportInterval->b) + * reportInterval->a; + mFeatureInfo.minDelay = std::max(1000, mFeatureInfo.minDelay); + mFeatureInfo.maxDelay = 1000000.0 + * (reportInterval->maxRaw + reportInterval->b) + * reportInterval->a; + mFeatureInfo.maxDelay = std::min(static_cast(1000000000), + mFeatureInfo.maxDelay); } return true; return (mPowerStateId >= 0 || mReportingStateId >= 0) && mReportIntervalId >= 0; @@ -981,7 +989,9 @@ int HidRawSensor::batch(int64_t samplingPeriod, int64_t batchingPeriod) { if (device->getFeature(id, &buffer) && (8 * buffer.size()) >= (mReportIntervalBitOffset + mReportIntervalBitSize)) { - int64_t periodMs = samplingPeriod / 1000000; //ns -> ms + int64_t periodMs = + (((static_cast(samplingPeriod)) / 1000000000.0) + / mReportIntervalScale) - mReportIntervalOffset; int64_t maxPeriodMs = (1LL << std::min(mReportIntervalBitSize, 63U)) - 1; periodMs = std::min(periodMs, maxPeriodMs); diff --git a/modules/sensors/dynamic_sensor/HidRawSensor.h b/modules/sensors/dynamic_sensor/HidRawSensor.h index 66843fcd..074482a8 100644 --- a/modules/sensors/dynamic_sensor/HidRawSensor.h +++ b/modules/sensors/dynamic_sensor/HidRawSensor.h @@ -195,6 +195,8 @@ private: int mReportIntervalId; unsigned int mReportIntervalBitOffset; unsigned int mReportIntervalBitSize; + double mReportIntervalScale; + int64_t mReportIntervalOffset; // Input report translate table std::vector mTranslateTable; diff --git a/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp b/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp index 19aa4291..63210200 100644 --- a/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp +++ b/modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp @@ -240,8 +240,14 @@ std::vector HidParser::convertGroupToPacket( auto logical = r.getLogicalRange(); auto physical = r.getPhysicalRange(); - double scale = static_cast((physical.second - physical.first)) - / (logical.second - logical.first); + double scale; + if ((physical.first != physical.second) && + (logical.first != logical.second)) { + scale = static_cast(physical.second - physical.first) + / (logical.second - logical.first); + } else { + scale = (physical.first != 0) ? physical.first : 1.0; + } scale *= r.getExponentValue(); int64_t offset = (physical.first * r.getExponentValue() / scale) - -- cgit v1.2.3 From 349356570894ce56eaf3145c4f0f01183ca63358 Mon Sep 17 00:00:00 2001 From: Erik Staats Date: Wed, 20 Apr 2022 11:16:52 -0700 Subject: Add /dev permissions to dynamic sensor README.md . Bug: 228879057 Test: Verified in gitiles. Change-Id: If82a5bf302cb68a2c5b486006e4679fbfc8ee545 --- modules/sensors/dynamic_sensor/README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/sensors/dynamic_sensor/README.md b/modules/sensors/dynamic_sensor/README.md index 49e541e3..5d5bd6d3 100644 --- a/modules/sensors/dynamic_sensor/README.md +++ b/modules/sensors/dynamic_sensor/README.md @@ -62,6 +62,7 @@ index 0797253..22a4208 100644 +get_prop(hal_sensors_default, vendor_dynamic_sensor_prop) + +# Allow access to raw HID devices for dynamic sensors. ++allow hal_sensors_default device:dir r_dir_perms; +allow hal_sensors_default hidraw_device:chr_file rw_file_perms; + # -- cgit v1.2.3