Adds sensors aidl default (cuttlefish) implementation

Bug: 195593357
Test: Verify VTS AIDL sensors tests pass

Change-Id: I12f09adfb0d81c8c15e2c18c836f03cbd9d82daf

1 files changed, 103 insertions, 30 deletions

diff --git a/sensors/aidl/default/Sensors.cpp b/sensors/aidl/default/Sensors.cpp
index 14bbbbf7f4..65dd304b2c 100644
--- a/sensors/aidl/default/Sensors.cpp
+++ b/sensors/aidl/default/Sensors.cpp
@@ -16,66 +16,139 @@
 
 #include "sensors-impl/Sensors.h"
 
+#include <aidl/android/hardware/common/fmq/SynchronizedReadWrite.h>
+
 using ::aidl::android::hardware::common::fmq::MQDescriptor;
 using ::aidl::android::hardware::common::fmq::SynchronizedReadWrite;
 using ::aidl::android::hardware::sensors::Event;
 using ::aidl::android::hardware::sensors::ISensors;
 using ::aidl::android::hardware::sensors::ISensorsCallback;
 using ::aidl::android::hardware::sensors::SensorInfo;
+using ::ndk::ScopedAStatus;
 
 namespace aidl {
 namespace android {
 namespace hardware {
 namespace sensors {
 
-// TODO(b/195593357): Implement AIDL HAL
-::ndk::ScopedAStatus Sensors::activate(int32_t /* in_sensorHandle */, bool /* in_enabled */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::activate(int32_t in_sensorHandle, bool in_enabled) {
+    auto sensor = mSensors.find(in_sensorHandle);
+    if (sensor != mSensors.end()) {
+        sensor->second->activate(in_enabled);
+        return ScopedAStatus::ok();
+    }
+
+    return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
 }
 
-::ndk::ScopedAStatus Sensors::batch(int32_t /* in_sensorHandle */,
-                                    int64_t /* in_samplingPeriodNs */,
-                                    int64_t /* in_maxReportLatencyNs */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::batch(int32_t in_sensorHandle, int64_t in_samplingPeriodNs,
+                             int64_t /* in_maxReportLatencyNs */) {
+    auto sensor = mSensors.find(in_sensorHandle);
+    if (sensor != mSensors.end()) {
+        sensor->second->batch(in_samplingPeriodNs);
+        return ScopedAStatus::ok();
+    }
+
+    return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
 }
 
-::ndk::ScopedAStatus Sensors::configDirectReport(int32_t /* in_sensorHandle */,
-                                                 int32_t /* in_channelHandle */,
-                                                 ISensors::RateLevel /* in_rate */,
-                                                 int32_t* /* _aidl_return */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::configDirectReport(int32_t /* in_sensorHandle */,
+                                          int32_t /* in_channelHandle */,
+                                          ISensors::RateLevel /* in_rate */,
+                                          int32_t* _aidl_return) {
+    *_aidl_return = EX_UNSUPPORTED_OPERATION;
+
+    return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-::ndk::ScopedAStatus Sensors::flush(int32_t /* in_sensorHandle */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::flush(int32_t in_sensorHandle) {
+    auto sensor = mSensors.find(in_sensorHandle);
+    if (sensor != mSensors.end()) {
+        return sensor->second->flush();
+    }
+
+    return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
 }
 
-::ndk::ScopedAStatus Sensors::getSensorsList(std::vector<SensorInfo>* /* _aidl_return */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::getSensorsList(std::vector<SensorInfo>* _aidl_return) {
+    for (const auto& sensor : mSensors) {
+        _aidl_return->push_back(sensor.second->getSensorInfo());
+    }
+    return ScopedAStatus::ok();
 }
 
-::ndk::ScopedAStatus Sensors::initialize(
-        const MQDescriptor<Event, SynchronizedReadWrite>& /* in_eventQueueDescriptor */,
-        const MQDescriptor<int32_t, SynchronizedReadWrite>& /* in_wakeLockDescriptor */,
-        const std::shared_ptr<ISensorsCallback>& /* in_sensorsCallback */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::initialize(
+        const MQDescriptor<Event, SynchronizedReadWrite>& in_eventQueueDescriptor,
+        const MQDescriptor<int32_t, SynchronizedReadWrite>& in_wakeLockDescriptor,
+        const std::shared_ptr<::aidl::android::hardware::sensors::ISensorsCallback>&
+                in_sensorsCallback) {
+    ScopedAStatus result = ScopedAStatus::ok();
+
+    mEventQueue = std::make_unique<AidlMessageQueue<Event, SynchronizedReadWrite>>(
+            in_eventQueueDescriptor, true /* resetPointers */);
+
+    // Ensure that all sensors are disabled.
+    for (auto sensor : mSensors) {
+        sensor.second->activate(false);
+    }
+
+    // Stop the Wake Lock thread if it is currently running
+    if (mReadWakeLockQueueRun.load()) {
+        mReadWakeLockQueueRun = false;
+        mWakeLockThread.join();
+    }
+
+    // Save a reference to the callback
+    mCallback = in_sensorsCallback;
+
+    // Ensure that any existing EventFlag is properly deleted
+    deleteEventFlag();
+
+    // Create the EventFlag that is used to signal to the framework that sensor events have been
+    // written to the Event FMQ
+    if (EventFlag::createEventFlag(mEventQueue->getEventFlagWord(), &mEventQueueFlag) != OK) {
+        result = ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
+    }
+
+    // Create the Wake Lock FMQ that is used by the framework to communicate whenever WAKE_UP
+    // events have been successfully read and handled by the framework.
+    mWakeLockQueue = std::make_unique<AidlMessageQueue<int32_t, SynchronizedReadWrite>>(
+            in_wakeLockDescriptor, true /* resetPointers */);
+
+    if (!mCallback || !mEventQueue || !mWakeLockQueue || mEventQueueFlag == nullptr) {
+        result = ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
+    }
+
+    // Start the thread to read events from the Wake Lock FMQ
+    mReadWakeLockQueueRun = true;
+    mWakeLockThread = std::thread(startReadWakeLockThread, this);
+    return result;
 }
 
-::ndk::ScopedAStatus Sensors::injectSensorData(const Event& /* in_event */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::injectSensorData(const Event& in_event) {
+    auto sensor = mSensors.find(in_event.sensorHandle);
+    if (sensor != mSensors.end()) {
+        return sensor->second->injectEvent(in_event);
+    }
+    return ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(ERROR_BAD_VALUE));
 }
 
-::ndk::ScopedAStatus Sensors::registerDirectChannel(const ISensors::SharedMemInfo& /* in_mem */,
-                                                    int32_t* /* _aidl_return */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::registerDirectChannel(const ISensors::SharedMemInfo& /* in_mem */,
+                                             int32_t* _aidl_return) {
+    *_aidl_return = EX_UNSUPPORTED_OPERATION;
+
+    return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-::ndk::ScopedAStatus Sensors::setOperationMode(OperationMode /* in_mode */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::setOperationMode(OperationMode in_mode) {
+    for (auto sensor : mSensors) {
+        sensor.second->setOperationMode(in_mode);
+    }
+    return ScopedAStatus::ok();
 }
 
-::ndk::ScopedAStatus Sensors::unregisterDirectChannel(int32_t /* in_channelHandle */) {
-    return ndk::ScopedAStatus::ok();
+ScopedAStatus Sensors::unregisterDirectChannel(int32_t /* in_channelHandle */) {
+    return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
 }  // namespace sensors