diff --git a/sensors/common/default/2.X/multihal/tests/Android.bp b/sensors/common/default/2.X/multihal/tests/Android.bp index 0dfbd498ec..a15faed1ef 100644 --- a/sensors/common/default/2.X/multihal/tests/Android.bp +++ b/sensors/common/default/2.X/multihal/tests/Android.bp @@ -50,6 +50,7 @@ cc_library { vendor: true, defaults: ["android.hardware.sensors@2.X-fakesubhal-defaults"], cflags: [ + "-DSUB_HAL_VERSION_2_0", "-DSUPPORT_CONTINUOUS_SENSORS", "-DSUB_HAL_NAME=\"FakeSubHal-Continuous\"", ], @@ -59,6 +60,17 @@ cc_library { name: "android.hardware.sensors@2.X-fakesubhal-config2", vendor: true, defaults: ["android.hardware.sensors@2.X-fakesubhal-defaults"], + cflags: [ + "-DSUB_HAL_VERSION_2_0", + "-DSUPPORT_ON_CHANGE_SENSORS", + "-DSUB_HAL_NAME=\"FakeSubHal-OnChange\"", + ], +} + +cc_library { + name: "android.hardware.sensors@2.X-fakesubhal-config3", + vendor: true, + defaults: ["android.hardware.sensors@2.X-fakesubhal-defaults"], cflags: [ "-DSUPPORT_ON_CHANGE_SENSORS", "-DSUB_HAL_NAME=\"FakeSubHal-OnChange\"", diff --git a/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp b/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp index ce65c3cd80..858786af09 100644 --- a/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp +++ b/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp @@ -15,12 +15,15 @@ #include +#include #include +#include #include #include "HalProxy.h" #include "SensorsSubHal.h" #include "V2_0/ScopedWakelock.h" +#include "convertV2_1.h" #include #include @@ -38,28 +41,35 @@ using ::android::hardware::sensors::V1_0::SensorFlagBits; using ::android::hardware::sensors::V1_0::SensorInfo; using ::android::hardware::sensors::V1_0::SensorType; using ::android::hardware::sensors::V2_0::EventQueueFlagBits; -using ::android::hardware::sensors::V2_0::ISensorsCallback; using ::android::hardware::sensors::V2_0::WakeLockQueueFlagBits; using ::android::hardware::sensors::V2_0::implementation::HalProxyCallbackBase; using ::android::hardware::sensors::V2_0::implementation::ScopedWakelock; -using ::android::hardware::sensors::V2_0::subhal::implementation::AddAndRemoveDynamicSensorsSubHal; -using ::android::hardware::sensors::V2_0::subhal::implementation::AllSensorsSubHal; -using ::android::hardware::sensors::V2_0::subhal::implementation:: - AllSupportDirectChannelSensorsSubHal; -using ::android::hardware::sensors::V2_0::subhal::implementation::ContinuousSensorsSubHal; -using ::android::hardware::sensors::V2_0::subhal::implementation:: - DoesNotSupportDirectChannelSensorsSubHal; -using ::android::hardware::sensors::V2_0::subhal::implementation::OnChangeSensorsSubHal; -using ::android::hardware::sensors::V2_0::subhal::implementation::SensorsSubHal; -using ::android::hardware::sensors::V2_0::subhal::implementation:: - SetOperationModeFailingSensorsSubHal; +using ::android::hardware::sensors::V2_1::implementation::convertToNewEvents; +using ::android::hardware::sensors::V2_1::implementation::convertToNewSensorInfos; using ::android::hardware::sensors::V2_1::implementation::HalProxy; +using ::android::hardware::sensors::V2_1::subhal::implementation::AddAndRemoveDynamicSensorsSubHal; +using ::android::hardware::sensors::V2_1::subhal::implementation::AllSensorsSubHal; +using ::android::hardware::sensors::V2_1::subhal::implementation:: + AllSupportDirectChannelSensorsSubHal; +using ::android::hardware::sensors::V2_1::subhal::implementation::ContinuousSensorsSubHal; +using ::android::hardware::sensors::V2_1::subhal::implementation:: + DoesNotSupportDirectChannelSensorsSubHal; +using ::android::hardware::sensors::V2_1::subhal::implementation::OnChangeSensorsSubHal; +using ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0; +using ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1; +using ::android::hardware::sensors::V2_1::subhal::implementation:: + SetOperationModeFailingSensorsSubHal; -using EventMessageQueue = MessageQueue; +using ISensorsCallbackV2_0 = ::android::hardware::sensors::V2_0::ISensorsCallback; +using ISensorsCallbackV2_1 = ::android::hardware::sensors::V2_1::ISensorsCallback; +using EventV1_0 = ::android::hardware::sensors::V1_0::Event; +using EventV2_1 = ::android::hardware::sensors::V2_1::Event; +using EventMessageQueueV2_1 = MessageQueue; +using EventMessageQueueV2_0 = MessageQueue; using WakeupMessageQueue = MessageQueue; // The barebones sensors callback class passed into halproxy initialize calls -class SensorsCallback : public ISensorsCallback { +class SensorsCallback : public ISensorsCallbackV2_0 { public: Return onDynamicSensorsConnected( const hidl_vec& /*dynamicSensorsAdded*/) override { @@ -74,8 +84,30 @@ class SensorsCallback : public ISensorsCallback { } }; +class SensorsCallbackV2_1 : public ISensorsCallbackV2_1 { + public: + Return onDynamicSensorsConnected_2_1( + const hidl_vec<::android::hardware::sensors::V2_1::SensorInfo>& /*dynamicSensorsAdded*/) + override { + // Nothing yet + return Return(); + } + + Return onDynamicSensorsConnected( + const hidl_vec& /*dynamicSensorsAdded*/) override { + // Nothing yet + return Return(); + } + + Return onDynamicSensorsDisconnected( + const hidl_vec& /*dynamicSensorHandlesRemoved*/) override { + // Nothing yet + return Return(); + } +}; + // The sensors callback that expects a variable list of sensors to be added -class TestSensorsCallback : public ISensorsCallback { +class TestSensorsCallback : public ISensorsCallbackV2_0 { public: Return onDynamicSensorsConnected( const hidl_vec& dynamicSensorsAdded) override { @@ -130,10 +162,10 @@ void testSensorsListForOneDirectChannelEnabledSubHal(const std::vector& wakelockQueue, EventFlag* wakelockQueueFlag); -bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr& eventQueue, +bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr& eventQueue, EventFlag* eventQueueFlag); -std::unique_ptr makeEventFMQ(size_t size); +std::unique_ptr makeEventFMQ(size_t size); std::unique_ptr makeWakelockFMQ(size_t size); @@ -143,7 +175,7 @@ std::unique_ptr makeWakelockFMQ(size_t size); * * @return A proximity event. */ -Event makeProximityEvent(); +EventV1_0 makeProximityEvent(); /** * Construct and return a HIDL Event type thats sensorHandle refers to a proximity sensor @@ -151,7 +183,7 @@ Event makeProximityEvent(); * * @return A proximity event. */ -Event makeAccelerometerEvent(); +EventV1_0 makeAccelerometerEvent(); /** * Make a certain number of proximity type events with the sensorHandle field set to @@ -161,7 +193,7 @@ Event makeAccelerometerEvent(); * * @return The created list of events. */ -std::vector makeMultipleProximityEvents(size_t numEvents); +std::vector makeMultipleProximityEvents(size_t numEvents); /** * Make a certain number of accelerometer type events with the sensorHandle field set to @@ -171,7 +203,7 @@ std::vector makeMultipleProximityEvents(size_t numEvents); * * @return The created list of events. */ -std::vector makeMultipleAccelerometerEvents(size_t numEvents); +std::vector makeMultipleAccelerometerEvents(size_t numEvents); /** * Given a SensorInfo vector and a sensor handles vector populate 'sensors' with SensorInfo @@ -189,7 +221,7 @@ void makeSensorsAndSensorHandlesStartingAndOfSize(int32_t start, size_t size, // Tests follow TEST(HalProxyTest, GetSensorsListOneSubHalTest) { - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector fakeSubHals{&subHal}; HalProxy proxy(fakeSubHals); @@ -201,8 +233,8 @@ TEST(HalProxyTest, GetSensorsListOneSubHalTest) { } TEST(HalProxyTest, GetSensorsListTwoSubHalTest) { - ContinuousSensorsSubHal continuousSubHal; - OnChangeSensorsSubHal onChangeSubHal; + ContinuousSensorsSubHal continuousSubHal; + OnChangeSensorsSubHal onChangeSubHal; std::vector fakeSubHals; fakeSubHals.push_back(&continuousSubHal); fakeSubHals.push_back(&onChangeSubHal); @@ -222,8 +254,8 @@ TEST(HalProxyTest, GetSensorsListTwoSubHalTest) { } TEST(HalProxyTest, SetOperationModeTwoSubHalSuccessTest) { - ContinuousSensorsSubHal subHal1; - OnChangeSensorsSubHal subHal2; + ContinuousSensorsSubHal subHal1; + OnChangeSensorsSubHal subHal2; std::vector fakeSubHals{&subHal1, &subHal2}; HalProxy proxy(fakeSubHals); @@ -239,7 +271,7 @@ TEST(HalProxyTest, SetOperationModeTwoSubHalSuccessTest) { } TEST(HalProxyTest, SetOperationModeTwoSubHalFailTest) { - AllSensorsSubHal subHal1; + AllSensorsSubHal subHal1; SetOperationModeFailingSensorsSubHal subHal2; std::vector fakeSubHals{&subHal1, &subHal2}; @@ -280,16 +312,16 @@ TEST(HalProxyTest, InitDirectChannelThreeSubHalsUnitTest) { TEST(HalProxyTest, PostSingleNonWakeupEvent) { constexpr size_t kQueueSize = 5; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; HalProxy proxy(subHals); - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); - std::vector events{makeAccelerometerEvent()}; - subHal.postEvents(events, false /* wakeup */); + std::vector events{makeAccelerometerEvent()}; + subHal.postEvents(convertToNewEvents(events), false /* wakeup */); EXPECT_EQ(eventQueue->availableToRead(), 1); } @@ -297,28 +329,28 @@ TEST(HalProxyTest, PostSingleNonWakeupEvent) { TEST(HalProxyTest, PostMultipleNonWakeupEvent) { constexpr size_t kQueueSize = 5; constexpr size_t kNumEvents = 3; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; HalProxy proxy(subHals); - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); - std::vector events = makeMultipleAccelerometerEvents(kNumEvents); - subHal.postEvents(events, false /* wakeup */); + std::vector events = makeMultipleAccelerometerEvents(kNumEvents); + subHal.postEvents(convertToNewEvents(events), false /* wakeup */); EXPECT_EQ(eventQueue->availableToRead(), kNumEvents); } TEST(HalProxyTest, PostSingleWakeupEvent) { constexpr size_t kQueueSize = 5; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; HalProxy proxy(subHals); - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); EventFlag* eventQueueFlag; @@ -327,8 +359,8 @@ TEST(HalProxyTest, PostSingleWakeupEvent) { EventFlag* wakelockQueueFlag; EventFlag::createEventFlag(wakeLockQueue->getEventFlagWord(), &wakelockQueueFlag); - std::vector events{makeProximityEvent()}; - subHal.postEvents(events, true /* wakeup */); + std::vector events{makeProximityEvent()}; + subHal.postEvents(convertToNewEvents(events), true /* wakeup */); EXPECT_EQ(eventQueue->availableToRead(), 1); @@ -339,12 +371,12 @@ TEST(HalProxyTest, PostSingleWakeupEvent) { TEST(HalProxyTest, PostMultipleWakeupEvents) { constexpr size_t kQueueSize = 5; constexpr size_t kNumEvents = 3; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; HalProxy proxy(subHals); - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); EventFlag* eventQueueFlag; @@ -353,8 +385,8 @@ TEST(HalProxyTest, PostMultipleWakeupEvents) { EventFlag* wakelockQueueFlag; EventFlag::createEventFlag(wakeLockQueue->getEventFlagWord(), &wakelockQueueFlag); - std::vector events = makeMultipleProximityEvents(kNumEvents); - subHal.postEvents(events, true /* wakeup */); + std::vector events = makeMultipleProximityEvents(kNumEvents); + subHal.postEvents(convertToNewEvents(events), true /* wakeup */); EXPECT_EQ(eventQueue->availableToRead(), kNumEvents); @@ -365,20 +397,20 @@ TEST(HalProxyTest, PostMultipleWakeupEvents) { TEST(HalProxyTest, PostEventsMultipleSubhals) { constexpr size_t kQueueSize = 5; constexpr size_t kNumEvents = 2; - AllSensorsSubHal subHal1, subHal2; + AllSensorsSubHal subHal1, subHal2; std::vector subHals{&subHal1, &subHal2}; HalProxy proxy(subHals); - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); - std::vector events = makeMultipleAccelerometerEvents(kNumEvents); - subHal1.postEvents(events, false /* wakeup */); + std::vector events = makeMultipleAccelerometerEvents(kNumEvents); + subHal1.postEvents(convertToNewEvents(events), false /* wakeup */); EXPECT_EQ(eventQueue->availableToRead(), kNumEvents); - subHal2.postEvents(events, false /* wakeup */); + subHal2.postEvents(convertToNewEvents(events), false /* wakeup */); EXPECT_EQ(eventQueue->availableToRead(), kNumEvents * 2); } @@ -386,19 +418,19 @@ TEST(HalProxyTest, PostEventsMultipleSubhals) { TEST(HalProxyTest, PostEventsDelayedWrite) { constexpr size_t kQueueSize = 5; constexpr size_t kNumEvents = 6; - AllSensorsSubHal subHal1, subHal2; + AllSensorsSubHal subHal1, subHal2; std::vector subHals{&subHal1, &subHal2}; HalProxy proxy(subHals); - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); EventFlag* eventQueueFlag; EventFlag::createEventFlag(eventQueue->getEventFlagWord(), &eventQueueFlag); - std::vector events = makeMultipleAccelerometerEvents(kNumEvents); - subHal1.postEvents(events, false /* wakeup */); + std::vector events = makeMultipleAccelerometerEvents(kNumEvents); + subHal1.postEvents(convertToNewEvents(events), false /* wakeup */); EXPECT_EQ(eventQueue->availableToRead(), kQueueSize); @@ -414,18 +446,20 @@ TEST(HalProxyTest, PostEventsDelayedWrite) { TEST(HalProxyTest, PostEventsMultipleSubhalsThreaded) { constexpr size_t kQueueSize = 5; constexpr size_t kNumEvents = 2; - AllSensorsSubHal subHal1, subHal2; + AllSensorsSubHal subHal1, subHal2; std::vector subHals{&subHal1, &subHal2}; HalProxy proxy(subHals); - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); - std::vector events = makeMultipleAccelerometerEvents(kNumEvents); + std::vector events = makeMultipleAccelerometerEvents(kNumEvents); - std::thread t1(&AllSensorsSubHal::postEvents, &subHal1, events, false); - std::thread t2(&AllSensorsSubHal::postEvents, &subHal2, events, false); + std::thread t1(&AllSensorsSubHal::postEvents, &subHal1, + convertToNewEvents(events), false); + std::thread t2(&AllSensorsSubHal::postEvents, &subHal2, + convertToNewEvents(events), false); t1.join(); t2.join(); @@ -436,34 +470,34 @@ TEST(HalProxyTest, PostEventsMultipleSubhalsThreaded) { TEST(HalProxyTest, DestructingWithEventsPendingOnBackgroundThread) { constexpr size_t kQueueSize = 5; constexpr size_t kNumEvents = 6; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); HalProxy proxy(subHals); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); - std::vector events = makeMultipleAccelerometerEvents(kNumEvents); - subHal.postEvents(events, false /* wakeup */); + std::vector events = makeMultipleAccelerometerEvents(kNumEvents); + subHal.postEvents(convertToNewEvents(events), false /* wakeup */); // Destructing HalProxy object with events on the background thread } TEST(HalProxyTest, DestructingWithUnackedWakeupEventsPosted) { constexpr size_t kQueueSize = 5; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); HalProxy proxy(subHals); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); - std::vector events{makeProximityEvent()}; - subHal.postEvents(events, true /* wakeup */); + std::vector events{makeProximityEvent()}; + subHal.postEvents(convertToNewEvents(events), true /* wakeup */); // Not sending any acks back through wakeLockQueue @@ -473,17 +507,17 @@ TEST(HalProxyTest, DestructingWithUnackedWakeupEventsPosted) { TEST(HalProxyTest, ReinitializeWithEventsPendingOnBackgroundThread) { constexpr size_t kQueueSize = 5; constexpr size_t kNumEvents = 10; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); HalProxy proxy(subHals); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); - std::vector events = makeMultipleAccelerometerEvents(kNumEvents); - subHal.postEvents(events, false /* wakeup */); + std::vector events = makeMultipleAccelerometerEvents(kNumEvents); + subHal.postEvents(convertToNewEvents(events), false /* wakeup */); eventQueue = makeEventFMQ(kQueueSize); wakeLockQueue = makeWakelockFMQ(kQueueSize); @@ -493,23 +527,23 @@ TEST(HalProxyTest, ReinitializeWithEventsPendingOnBackgroundThread) { EXPECT_EQ(secondInitResult, Result::OK); // Small sleep so that pending writes thread has a change to hit writeBlocking call. std::this_thread::sleep_for(std::chrono::milliseconds(5)); - Event eventOut; + EventV1_0 eventOut; EXPECT_FALSE(eventQueue->read(&eventOut)); } TEST(HalProxyTest, ReinitializingWithUnackedWakeupEventsPosted) { constexpr size_t kQueueSize = 5; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); HalProxy proxy(subHals); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); - std::vector events{makeProximityEvent()}; - subHal.postEvents(events, true /* wakeup */); + std::vector events{makeProximityEvent()}; + subHal.postEvents(convertToNewEvents(events), true /* wakeup */); // Not sending any acks back through wakeLockQueue @@ -524,12 +558,12 @@ TEST(HalProxyTest, ReinitializingWithUnackedWakeupEventsPosted) { TEST(HalProxyTest, InitializeManyTimesInARow) { constexpr size_t kQueueSize = 5; constexpr size_t kNumTimesToInit = 100; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); HalProxy proxy(subHals); for (size_t i = 0; i < kNumTimesToInit; i++) { @@ -541,15 +575,15 @@ TEST(HalProxyTest, InitializeManyTimesInARow) { TEST(HalProxyTest, OperationModeResetOnInitialize) { constexpr size_t kQueueSize = 5; - AllSensorsSubHal subHal; + AllSensorsSubHal subHal; std::vector subHals{&subHal}; - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); HalProxy proxy(subHals); proxy.setOperationMode(OperationMode::DATA_INJECTION); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); - Event event = makeAccelerometerEvent(); + EventV1_0 event = makeAccelerometerEvent(); // Should not be able to inject a non AdditionInfo type event because operation mode should // have been reset to NORMAL EXPECT_EQ(proxy.injectSensorData(event), Result::BAD_VALUE); @@ -560,7 +594,7 @@ TEST(HalProxyTest, DynamicSensorsDiscardedOnInitialize) { constexpr size_t kNumSensors = 5; AddAndRemoveDynamicSensorsSubHal subHal; std::vector subHals{&subHal}; - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); HalProxy proxy(subHals); @@ -575,9 +609,9 @@ TEST(HalProxyTest, DynamicSensorsDiscardedOnInitialize) { } TestSensorsCallback* callback = new TestSensorsCallback(); - ::android::sp callbackPtr = callback; + ::android::sp callbackPtr = callback; proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr); - subHal.addDynamicSensors(sensorsToConnect); + subHal.addDynamicSensors(convertToNewSensorInfos(sensorsToConnect)); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr); subHal.removeDynamicSensors(sensorHandlesToAttemptToRemove); @@ -594,7 +628,7 @@ TEST(HalProxyTest, DynamicSensorsConnectedTest) { AddAndRemoveDynamicSensorsSubHal subHal; std::vector subHals{&subHal}; HalProxy proxy(subHals); - std::unique_ptr eventQueue = makeEventFMQ(0); + std::unique_ptr eventQueue = makeEventFMQ(0); std::unique_ptr wakeLockQueue = makeWakelockFMQ(0); std::vector sensorsToConnect; @@ -603,9 +637,9 @@ TEST(HalProxyTest, DynamicSensorsConnectedTest) { sensorHandlesToExpect); TestSensorsCallback* callback = new TestSensorsCallback(); - ::android::sp callbackPtr = callback; + ::android::sp callbackPtr = callback; proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr); - subHal.addDynamicSensors(sensorsToConnect); + subHal.addDynamicSensors(convertToNewSensorInfos(sensorsToConnect)); std::vector sensorsSeen = callback->getSensorsConnected(); EXPECT_EQ(kNumSensors, sensorsSeen.size()); @@ -622,7 +656,7 @@ TEST(HalProxyTest, DynamicSensorsDisconnectedTest) { AddAndRemoveDynamicSensorsSubHal subHal; std::vector subHals{&subHal}; HalProxy proxy(subHals); - std::unique_ptr eventQueue = makeEventFMQ(0); + std::unique_ptr eventQueue = makeEventFMQ(0); std::unique_ptr wakeLockQueue = makeWakelockFMQ(0); std::vector sensorsToConnect; @@ -647,9 +681,9 @@ TEST(HalProxyTest, DynamicSensorsDisconnectedTest) { nonDynamicSensorHandles.end()); TestSensorsCallback* callback = new TestSensorsCallback(); - ::android::sp callbackPtr = callback; + ::android::sp callbackPtr = callback; proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr); - subHal.addDynamicSensors(sensorsToConnect); + subHal.addDynamicSensors(convertToNewSensorInfos(sensorsToConnect)); subHal.removeDynamicSensors(sensorHandlesToAttemptToRemove); std::vector sensorHandlesSeen = callback->getSensorHandlesDisconnected(); @@ -668,15 +702,15 @@ TEST(HalProxyTest, InvalidSensorHandleSubHalIndexProxyCalls) { constexpr size_t kNumSubHals = 3; constexpr size_t kQueueSize = 5; int32_t kNumSubHalsInt32 = static_cast(kNumSubHals); - std::vector subHalObjs(kNumSubHals); + std::vector> subHalObjs(kNumSubHals); std::vector subHals; for (const auto& subHal : subHalObjs) { subHals.push_back((ISensorsSubHal*)(&subHal)); } - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); HalProxy proxy(subHals); // Initialize for the injectSensorData call so callback postEvents is valid proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); @@ -688,7 +722,7 @@ TEST(HalProxyTest, InvalidSensorHandleSubHalIndexProxyCalls) { EXPECT_EQ(proxy.activate(0x00000001 | (kNumSubHalsInt32 << 24), true), Result::BAD_VALUE); EXPECT_EQ(proxy.batch(0x00000001 | (kNumSubHalsInt32 << 24), 0, 0), Result::BAD_VALUE); EXPECT_EQ(proxy.flush(0x00000001 | (kNumSubHalsInt32 << 24)), Result::BAD_VALUE); - Event event; + EventV1_0 event; event.sensorHandle = 0x00000001 | (kNumSubHalsInt32 << 24); EXPECT_EQ(proxy.injectSensorData(event), Result::BAD_VALUE); } @@ -697,28 +731,28 @@ TEST(HalProxyTest, PostedEventSensorHandleSubHalIndexValid) { constexpr size_t kQueueSize = 5; constexpr int32_t subhal1Index = 0; constexpr int32_t subhal2Index = 1; - AllSensorsSubHal subhal1; - AllSensorsSubHal subhal2; + AllSensorsSubHal subhal1; + AllSensorsSubHal subhal2; std::vector subHals{&subhal1, &subhal2}; - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); HalProxy proxy(subHals); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); int32_t sensorHandleToPost = 0x00000001; - Event eventIn = makeAccelerometerEvent(); + EventV1_0 eventIn = makeAccelerometerEvent(); eventIn.sensorHandle = sensorHandleToPost; - std::vector eventsToPost{eventIn}; - subhal1.postEvents(eventsToPost, false); + std::vector eventsToPost{eventIn}; + subhal1.postEvents(convertToNewEvents(eventsToPost), false); - Event eventOut; + EventV1_0 eventOut; EXPECT_TRUE(eventQueue->read(&eventOut)); EXPECT_EQ(eventOut.sensorHandle, (subhal1Index << 24) | sensorHandleToPost); - subhal2.postEvents(eventsToPost, false); + subhal2.postEvents(convertToNewEvents(eventsToPost), false); EXPECT_TRUE(eventQueue->read(&eventOut)); @@ -729,22 +763,22 @@ TEST(HalProxyTest, FillAndDrainPendingQueueTest) { constexpr size_t kQueueSize = 5; // TODO: Make this constant linked to same limit in HalProxy.h constexpr size_t kMaxPendingQueueSize = 100000; - AllSensorsSubHal subhal; + AllSensorsSubHal subhal; std::vector subHals{&subhal}; - std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); + std::unique_ptr eventQueue = makeEventFMQ(kQueueSize); std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); - ::android::sp callback = new SensorsCallback(); + ::android::sp callback = new SensorsCallback(); EventFlag* eventQueueFlag; EventFlag::createEventFlag(eventQueue->getEventFlagWord(), &eventQueueFlag); HalProxy proxy(subHals); proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); // Fill pending queue - std::vector events = makeMultipleAccelerometerEvents(kQueueSize); - subhal.postEvents(events, false); + std::vector events = makeMultipleAccelerometerEvents(kQueueSize); + subhal.postEvents(convertToNewEvents(events), false); events = makeMultipleAccelerometerEvents(kMaxPendingQueueSize); - subhal.postEvents(events, false); + subhal.postEvents(convertToNewEvents(events), false); // Drain pending queue for (int i = 0; i < kMaxPendingQueueSize + kQueueSize; i += kQueueSize) { @@ -753,9 +787,9 @@ TEST(HalProxyTest, FillAndDrainPendingQueueTest) { // Put one event on pending queue events = makeMultipleAccelerometerEvents(kQueueSize); - subhal.postEvents(events, false); + subhal.postEvents(convertToNewEvents(events), false); events = {makeAccelerometerEvent()}; - subhal.postEvents(events, false); + subhal.postEvents(convertToNewEvents(events), false); // Read out to make room for one event on pending queue to write to FMQ ASSERT_TRUE(readEventsOutOfQueue(kQueueSize, eventQueue, eventQueueFlag)); @@ -764,6 +798,35 @@ TEST(HalProxyTest, FillAndDrainPendingQueueTest) { EXPECT_TRUE(readEventsOutOfQueue(1, eventQueue, eventQueueFlag)); } +TEST(HalProxyTest, PostEventsMultipleSubhalsThreadedV2_1) { + constexpr size_t kQueueSize = 5; + constexpr size_t kNumEvents = 2; + AllSensorsSubHal subHal1; + AllSensorsSubHal subHal2; + std::vector<::android::hardware::sensors::V2_0::implementation::ISensorsSubHal*> subHalsV2_0{ + &subHal1}; + std::vector<::android::hardware::sensors::V2_1::implementation::ISensorsSubHal*> subHalsV2_1{ + &subHal2}; + HalProxy proxy(subHalsV2_0, subHalsV2_1); + std::unique_ptr eventQueue = + std::make_unique(kQueueSize, true); + std::unique_ptr wakeLockQueue = makeWakelockFMQ(kQueueSize); + ::android::sp callback = new SensorsCallbackV2_1(); + proxy.initialize_2_1(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback); + + std::vector events = makeMultipleAccelerometerEvents(kNumEvents); + + std::thread t1(&AllSensorsSubHal::postEvents, &subHal1, + convertToNewEvents(events), false); + std::thread t2(&AllSensorsSubHal::postEvents, &subHal2, + convertToNewEvents(events), false); + + t1.join(); + t2.join(); + + EXPECT_EQ(eventQueue->availableToRead(), kNumEvents * 2); +} + // Helper implementations follow void testSensorsListFromProxyAndSubHal(const std::vector& proxySensorsList, const std::vector& subHalSensorsList) { @@ -802,26 +865,26 @@ void ackWakeupEventsToHalProxy(size_t numEvents, std::unique_ptrwake(static_cast(WakeLockQueueFlagBits::DATA_WRITTEN)); } -bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr& eventQueue, +bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr& eventQueue, EventFlag* eventQueueFlag) { constexpr int64_t kReadBlockingTimeout = INT64_C(500000000); - std::vector events(numEvents); + std::vector events(numEvents); return eventQueue->readBlocking(events.data(), numEvents, static_cast(EventQueueFlagBits::EVENTS_READ), static_cast(EventQueueFlagBits::READ_AND_PROCESS), kReadBlockingTimeout, eventQueueFlag); } -std::unique_ptr makeEventFMQ(size_t size) { - return std::make_unique(size, true); +std::unique_ptr makeEventFMQ(size_t size) { + return std::make_unique(size, true); } std::unique_ptr makeWakelockFMQ(size_t size) { return std::make_unique(size, true); } -Event makeProximityEvent() { - Event event; +EventV1_0 makeProximityEvent() { + EventV1_0 event; event.timestamp = 0xFF00FF00; // This is the sensorhandle of proximity, which is wakeup type event.sensorHandle = 0x00000008; @@ -830,8 +893,8 @@ Event makeProximityEvent() { return event; } -Event makeAccelerometerEvent() { - Event event; +EventV1_0 makeAccelerometerEvent() { + EventV1_0 event; event.timestamp = 0xFF00FF00; // This is the sensorhandle of proximity, which is wakeup type event.sensorHandle = 0x00000001; @@ -840,16 +903,16 @@ Event makeAccelerometerEvent() { return event; } -std::vector makeMultipleProximityEvents(size_t numEvents) { - std::vector events; +std::vector makeMultipleProximityEvents(size_t numEvents) { + std::vector events; for (size_t i = 0; i < numEvents; i++) { events.push_back(makeProximityEvent()); } return events; } -std::vector makeMultipleAccelerometerEvents(size_t numEvents) { - std::vector events; +std::vector makeMultipleAccelerometerEvents(size_t numEvents) { + std::vector events; for (size_t i = 0; i < numEvents; i++) { events.push_back(makeAccelerometerEvent()); } diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/IHalProxyCallbackWrapper.h b/sensors/common/default/2.X/multihal/tests/fake_subhal/IHalProxyCallbackWrapper.h new file mode 100644 index 0000000000..4542bfdc2c --- /dev/null +++ b/sensors/common/default/2.X/multihal/tests/fake_subhal/IHalProxyCallbackWrapper.h @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2020 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. + */ + +#pragma once + +#include "V2_0/SubHal.h" +#include "V2_1/SubHal.h" +#include "convertV2_1.h" + +namespace android { +namespace hardware { +namespace sensors { +namespace V2_1 { +namespace subhal { +namespace implementation { + +/** + * The following callback wrapper classes abstract away common functionality across V2.0 and V2.1 + * interfaces. Much of the logic is common between the two versions and this allows users of the + * classes to only care about the type used at initialization and then interact with either version + * of the callback interface without worrying about the type. + */ +class IHalProxyCallbackWrapperBase { + protected: + using ScopedWakelock = V2_0::implementation::ScopedWakelock; + + public: + virtual ~IHalProxyCallbackWrapperBase() {} + + virtual Return onDynamicSensorsConnected( + const hidl_vec& sensorInfos) = 0; + + virtual Return onDynamicSensorsDisconnected(const hidl_vec& sensorHandles) = 0; + + virtual void postEvents(const std::vector& events, ScopedWakelock wakelock) = 0; + + virtual ScopedWakelock createScopedWakelock(bool lock) = 0; +}; + +template +class HalProxyCallbackWrapperBase : public IHalProxyCallbackWrapperBase { + public: + HalProxyCallbackWrapperBase(sp callback) : mCallback(callback){}; + + Return onDynamicSensorsDisconnected(const hidl_vec& sensorHandles) override { + return mCallback->onDynamicSensorsDisconnected(sensorHandles); + } + + ScopedWakelock createScopedWakelock(bool lock) override { + return mCallback->createScopedWakelock(lock); + } + + protected: + sp mCallback; +}; + +class HalProxyCallbackWrapperV2_0 + : public HalProxyCallbackWrapperBase { + public: + HalProxyCallbackWrapperV2_0(sp callback) + : HalProxyCallbackWrapperBase(callback){}; + + Return onDynamicSensorsConnected(const hidl_vec& sensorInfos) override { + return mCallback->onDynamicSensorsConnected( + V2_1::implementation::convertToOldSensorInfos(sensorInfos)); + } + + void postEvents(const std::vector& events, ScopedWakelock wakelock) override { + return mCallback->postEvents(V2_1::implementation::convertToOldEvents(events), + std::move(wakelock)); + } +}; + +class HalProxyCallbackWrapperV2_1 + : public HalProxyCallbackWrapperBase { + public: + HalProxyCallbackWrapperV2_1(sp callback) + : HalProxyCallbackWrapperBase(callback){}; + + Return onDynamicSensorsConnected(const hidl_vec& sensorInfos) override { + return mCallback->onDynamicSensorsConnected_2_1(sensorInfos); + } + + void postEvents(const std::vector& events, ScopedWakelock wakelock) { + return mCallback->postEvents(events, std::move(wakelock)); + } +}; + +} // namespace implementation +} // namespace subhal +} // namespace V2_1 +} // namespace sensors +} // namespace hardware +} // namespace android diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.cpp b/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.cpp index de89a00ef9..1efd971115 100644 --- a/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.cpp +++ b/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.cpp @@ -24,13 +24,18 @@ namespace android { namespace hardware { namespace sensors { -namespace V2_0 { +namespace V2_1 { namespace subhal { namespace implementation { using ::android::hardware::sensors::V1_0::MetaDataEventType; +using ::android::hardware::sensors::V1_0::OperationMode; +using ::android::hardware::sensors::V1_0::Result; using ::android::hardware::sensors::V1_0::SensorFlagBits; using ::android::hardware::sensors::V1_0::SensorStatus; +using ::android::hardware::sensors::V2_1::Event; +using ::android::hardware::sensors::V2_1::SensorInfo; +using ::android::hardware::sensors::V2_1::SensorType; Sensor::Sensor(int32_t sensorHandle, ISensorsEventCallback* callback) : mIsEnabled(false), @@ -343,7 +348,7 @@ RelativeHumiditySensor::RelativeHumiditySensor(int32_t sensorHandle, } // namespace implementation } // namespace subhal -} // namespace V2_0 +} // namespace V2_1 } // namespace sensors } // namespace hardware } // namespace android diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.h b/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.h index 60f5d3d40a..5cf9f837cf 100644 --- a/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.h +++ b/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.h @@ -16,7 +16,7 @@ #pragma once -#include +#include #include #include @@ -24,16 +24,16 @@ #include #include -using ::android::hardware::sensors::V1_0::Event; using ::android::hardware::sensors::V1_0::OperationMode; using ::android::hardware::sensors::V1_0::Result; -using ::android::hardware::sensors::V1_0::SensorInfo; -using ::android::hardware::sensors::V1_0::SensorType; +using ::android::hardware::sensors::V2_1::Event; +using ::android::hardware::sensors::V2_1::SensorInfo; +using ::android::hardware::sensors::V2_1::SensorType; namespace android { namespace hardware { namespace sensors { -namespace V2_0 { +namespace V2_1 { namespace subhal { namespace implementation { @@ -151,7 +151,7 @@ class RelativeHumiditySensor : public OnChangeSensor { } // namespace implementation } // namespace subhal -} // namespace V2_0 +} // namespace V2_1 } // namespace sensors } // namespace hardware } // namespace android diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.cpp b/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.cpp index ff5ff38541..20a4e9de04 100644 --- a/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.cpp +++ b/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.cpp @@ -16,33 +16,66 @@ #include "SensorsSubHal.h" -#include +#include #include -ISensorsSubHal* sensorsHalGetSubHal(uint32_t* version) { +#ifdef SUB_HAL_VERSION_2_0 +::android::hardware::sensors::V2_0::implementation::ISensorsSubHal* sensorsHalGetSubHal( + uint32_t* version) { #if defined SUPPORT_CONTINUOUS_SENSORS && defined SUPPORT_ON_CHANGE_SENSORS - static ::android::hardware::sensors::V2_0::subhal::implementation::AllSensorsSubHal subHal; + static ::android::hardware::sensors::V2_1::subhal::implementation::AllSensorsSubHal< + ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0> + subHal; #elif defined SUPPORT_CONTINUOUS_SENSORS - static ::android::hardware::sensors::V2_0::subhal::implementation::ContinuousSensorsSubHal + static ::android::hardware::sensors::V2_1::subhal::implementation::ContinuousSensorsSubHal< + ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0> subHal; #elif defined SUPPORT_ON_CHANGE_SENSORS - static ::android::hardware::sensors::V2_0::subhal::implementation::OnChangeSensorsSubHal subHal; + static ::android::hardware::sensors::V2_1::subhal::implementation::OnChangeSensorsSubHal< + ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0> + subHal; #else - static ::android::hardware::sensors::V2_0::subhal::implementation::SensorsSubHal subHal; + static ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHal< + ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0> + subHal; #endif // defined SUPPORT_CONTINUOUS_SENSORS && defined SUPPORT_ON_CHANGE_SENSORS *version = SUB_HAL_2_0_VERSION; return &subHal; } +#else // SUB_HAL_VERSION_2_0 + +::android::hardware::sensors::V2_1::implementation::ISensorsSubHal* sensorsHalGetSubHal_2_1( + uint32_t* version) { +#if defined SUPPORT_CONTINUOUS_SENSORS && defined SUPPORT_ON_CHANGE_SENSORS + static ::android::hardware::sensors::V2_1::subhal::implementation::AllSensorsSubHal< + ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1> + subHal; +#elif defined SUPPORT_CONTINUOUS_SENSORS + static ::android::hardware::sensors::V2_1::subhal::implementation::ContinuousSensorsSubHal< + ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1> + subHal; +#elif defined SUPPORT_ON_CHANGE_SENSORS + static ::android::hardware::sensors::V2_1::subhal::implementation::OnChangeSensorsSubHal< + ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1> + subHal; +#else + static ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1 subHal; +#endif // defined SUPPORT_CONTINUOUS_SENSORS && defined SUPPORT_ON_CHANGE_SENSORS + *version = SUB_HAL_2_1_VERSION; + return &subHal; +} + +#endif // SUB_HAL_VERSION_2_0 + namespace android { namespace hardware { namespace sensors { -namespace V2_0 { +namespace V2_1 { namespace subhal { namespace implementation { using ::android::hardware::Void; -using ::android::hardware::sensors::V1_0::Event; using ::android::hardware::sensors::V1_0::OperationMode; using ::android::hardware::sensors::V1_0::RateLevel; using ::android::hardware::sensors::V1_0::Result; @@ -50,11 +83,12 @@ using ::android::hardware::sensors::V1_0::SharedMemInfo; using ::android::hardware::sensors::V2_0::SensorTimeout; using ::android::hardware::sensors::V2_0::WakeLockQueueFlagBits; using ::android::hardware::sensors::V2_0::implementation::ScopedWakelock; +using ::android::hardware::sensors::V2_1::Event; -SensorsSubHal::SensorsSubHal() : mCallback(nullptr), mNextHandle(1) {} +ISensorsSubHalBase::ISensorsSubHalBase() : mCallback(nullptr), mNextHandle(1) {} // Methods from ::android::hardware::sensors::V2_0::ISensors follow. -Return SensorsSubHal::getSensorsList(getSensorsList_cb _hidl_cb) { +Return ISensorsSubHalBase::getSensorsList(V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb) { std::vector sensors; for (const auto& sensor : mSensors) { sensors.push_back(sensor.second->getSensorInfo()); @@ -64,7 +98,7 @@ Return SensorsSubHal::getSensorsList(getSensorsList_cb _hidl_cb) { return Void(); } -Return SensorsSubHal::setOperationMode(OperationMode mode) { +Return ISensorsSubHalBase::setOperationMode(OperationMode mode) { for (auto sensor : mSensors) { sensor.second->setOperationMode(mode); } @@ -72,7 +106,7 @@ Return SensorsSubHal::setOperationMode(OperationMode mode) { return Result::OK; } -Return SensorsSubHal::activate(int32_t sensorHandle, bool enabled) { +Return ISensorsSubHalBase::activate(int32_t sensorHandle, bool enabled) { auto sensor = mSensors.find(sensorHandle); if (sensor != mSensors.end()) { sensor->second->activate(enabled); @@ -81,8 +115,8 @@ Return SensorsSubHal::activate(int32_t sensorHandle, bool enabled) { return Result::BAD_VALUE; } -Return SensorsSubHal::batch(int32_t sensorHandle, int64_t samplingPeriodNs, - int64_t /* maxReportLatencyNs */) { +Return ISensorsSubHalBase::batch(int32_t sensorHandle, int64_t samplingPeriodNs, + int64_t /* maxReportLatencyNs */) { auto sensor = mSensors.find(sensorHandle); if (sensor != mSensors.end()) { sensor->second->batch(samplingPeriodNs); @@ -91,7 +125,7 @@ Return SensorsSubHal::batch(int32_t sensorHandle, int64_t samplingPeriod return Result::BAD_VALUE; } -Return SensorsSubHal::flush(int32_t sensorHandle) { +Return ISensorsSubHalBase::flush(int32_t sensorHandle) { auto sensor = mSensors.find(sensorHandle); if (sensor != mSensors.end()) { return sensor->second->flush(); @@ -99,7 +133,7 @@ Return SensorsSubHal::flush(int32_t sensorHandle) { return Result::BAD_VALUE; } -Return SensorsSubHal::injectSensorData(const Event& event) { +Return ISensorsSubHalBase::injectSensorData(const Event& event) { auto sensor = mSensors.find(event.sensorHandle); if (sensor != mSensors.end()) { return sensor->second->injectEvent(event); @@ -108,24 +142,24 @@ Return SensorsSubHal::injectSensorData(const Event& event) { return Result::BAD_VALUE; } -Return SensorsSubHal::registerDirectChannel(const SharedMemInfo& /* mem */, - registerDirectChannel_cb _hidl_cb) { +Return ISensorsSubHalBase::registerDirectChannel( + const SharedMemInfo& /* mem */, V2_0::ISensors::registerDirectChannel_cb _hidl_cb) { _hidl_cb(Result::INVALID_OPERATION, -1 /* channelHandle */); return Return(); } -Return SensorsSubHal::unregisterDirectChannel(int32_t /* channelHandle */) { +Return ISensorsSubHalBase::unregisterDirectChannel(int32_t /* channelHandle */) { return Result::INVALID_OPERATION; } -Return SensorsSubHal::configDirectReport(int32_t /* sensorHandle */, - int32_t /* channelHandle */, RateLevel /* rate */, - configDirectReport_cb _hidl_cb) { +Return ISensorsSubHalBase::configDirectReport( + int32_t /* sensorHandle */, int32_t /* channelHandle */, RateLevel /* rate */, + V2_0::ISensors::configDirectReport_cb _hidl_cb) { _hidl_cb(Result::INVALID_OPERATION, 0 /* reportToken */); return Return(); } -Return SensorsSubHal::debug(const hidl_handle& fd, const hidl_vec& args) { +Return ISensorsSubHalBase::debug(const hidl_handle& fd, const hidl_vec& args) { if (fd.getNativeHandle() == nullptr || fd->numFds < 1) { ALOGE("%s: missing fd for writing", __FUNCTION__); return Void(); @@ -156,44 +190,18 @@ Return SensorsSubHal::debug(const hidl_handle& fd, const hidl_vec(); } -Return SensorsSubHal::initialize(const sp& halProxyCallback) { - mCallback = halProxyCallback; +Return ISensorsSubHalBase::initialize( + std::unique_ptr& halProxyCallback) { + mCallback = std::move(halProxyCallback); setOperationMode(OperationMode::NORMAL); return Result::OK; } -void SensorsSubHal::postEvents(const std::vector& events, bool wakeup) { +void ISensorsSubHalBase::postEvents(const std::vector& events, bool wakeup) { ScopedWakelock wakelock = mCallback->createScopedWakelock(wakeup); mCallback->postEvents(events, std::move(wakelock)); } -ContinuousSensorsSubHal::ContinuousSensorsSubHal() { - AddSensor(); - AddSensor(); - AddSensor(); - AddSensor(); - AddSensor(); -} - -OnChangeSensorsSubHal::OnChangeSensorsSubHal() { - AddSensor(); - AddSensor(); - AddSensor(); - AddSensor(); -} - -AllSensorsSubHal::AllSensorsSubHal() { - AddSensor(); - AddSensor(); - AddSensor(); - AddSensor(); - AddSensor(); - AddSensor(); - AddSensor(); - AddSensor(); - AddSensor(); -} - Return SetOperationModeFailingSensorsSubHal::setOperationMode(OperationMode /*mode*/) { return Result::BAD_VALUE; } @@ -206,7 +214,7 @@ Return AllSupportDirectChannelSensorsSubHal::getSensorsList(getSensorsList sensorInfo.flags |= V1_0::SensorFlagBits::MASK_DIRECT_REPORT; sensors.push_back(sensorInfo); } - _hidl_cb(sensors); + _hidl_cb(V2_1::implementation::convertToOldSensorInfos(sensors)); return Void(); } @@ -218,7 +226,7 @@ Return DoesNotSupportDirectChannelSensorsSubHal::getSensorsList(getSensors sensorInfo.flags &= ~static_cast(V1_0::SensorFlagBits::MASK_DIRECT_REPORT); sensors.push_back(sensorInfo); } - _hidl_cb(sensors); + _hidl_cb(V2_1::implementation::convertToOldSensorInfos(sensors)); return Void(); } @@ -234,7 +242,7 @@ void AddAndRemoveDynamicSensorsSubHal::removeDynamicSensors( } // namespace implementation } // namespace subhal -} // namespace V2_0 +} // namespace V2_1 } // namespace sensors } // namespace hardware } // namespace android diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.h b/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.h index 6da4404c3e..1a78e847c7 100644 --- a/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.h +++ b/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.h @@ -17,7 +17,9 @@ #pragma once #include "V2_0/SubHal.h" +#include "V2_1/SubHal.h" +#include "IHalProxyCallbackWrapper.h" #include "Sensor.h" #include @@ -25,54 +27,54 @@ namespace android { namespace hardware { namespace sensors { -namespace V2_0 { +namespace V2_1 { namespace subhal { namespace implementation { using ::android::hardware::sensors::V1_0::OperationMode; using ::android::hardware::sensors::V1_0::Result; -using ::android::hardware::sensors::V2_0::implementation::IHalProxyCallback; /** * Implementation of a ISensorsSubHal that can be used to test the implementation of multihal 2.0. * See the README file for more details on how this class can be used for testing. */ -class SensorsSubHal : public ISensorsSubHal, public ISensorsEventCallback { - using Event = ::android::hardware::sensors::V1_0::Event; +class ISensorsSubHalBase : public ISensorsEventCallback { + protected: + using Event = ::android::hardware::sensors::V2_1::Event; using RateLevel = ::android::hardware::sensors::V1_0::RateLevel; using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo; public: - SensorsSubHal(); + ISensorsSubHalBase(); + + Return getSensorsList(V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb); + Return injectSensorData(const Event& event); + Return initialize(std::unique_ptr& halProxyCallback); // Methods from ::android::hardware::sensors::V2_0::ISensors follow. - virtual Return getSensorsList(getSensorsList_cb _hidl_cb) override; - - virtual Return setOperationMode(OperationMode mode) override; + virtual Return setOperationMode(OperationMode mode); OperationMode getOperationMode() const { return mCurrentOperationMode; } - Return activate(int32_t sensorHandle, bool enabled) override; + Return activate(int32_t sensorHandle, bool enabled); Return batch(int32_t sensorHandle, int64_t samplingPeriodNs, - int64_t maxReportLatencyNs) override; + int64_t maxReportLatencyNs); - Return flush(int32_t sensorHandle) override; - - Return injectSensorData(const Event& event) override; + Return flush(int32_t sensorHandle); Return registerDirectChannel(const SharedMemInfo& mem, - registerDirectChannel_cb _hidl_cb) override; + V2_0::ISensors::registerDirectChannel_cb _hidl_cb); - Return unregisterDirectChannel(int32_t channelHandle) override; + Return unregisterDirectChannel(int32_t channelHandle); Return configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate, - configDirectReport_cb _hidl_cb) override; + V2_0::ISensors::configDirectReport_cb _hidl_cb); - Return debug(const hidl_handle& fd, const hidl_vec& args) override; + Return debug(const hidl_handle& fd, const hidl_vec& args); // Methods from ::android::hardware::sensors::V2_0::implementation::ISensorsSubHal follow. - const std::string getName() override { + const std::string getName() { #ifdef SUB_HAL_NAME return SUB_HAL_NAME; #else // SUB_HAL_NAME @@ -80,8 +82,6 @@ class SensorsSubHal : public ISensorsSubHal, public ISensorsEventCallback { #endif // SUB_HAL_NAME } - Return initialize(const sp& halProxyCallback) override; - // Method from ISensorsEventCallback. void postEvents(const std::vector& events, bool wakeup) override; @@ -103,7 +103,7 @@ class SensorsSubHal : public ISensorsSubHal, public ISensorsEventCallback { * disconnected, sensor events need to be sent to the framework, and when a wakelock should be * acquired. */ - sp mCallback; + std::unique_ptr mCallback; private: /** @@ -118,40 +118,143 @@ class SensorsSubHal : public ISensorsSubHal, public ISensorsEventCallback { int32_t mNextHandle; }; -// SubHal that has continuous sensors for testing purposes. -class ContinuousSensorsSubHal : public SensorsSubHal { +template +class SensorsSubHalBase : public ISensorsSubHalBase, public SubHalClass { public: - ContinuousSensorsSubHal(); + Return setOperationMode(OperationMode mode) override { + return ISensorsSubHalBase::setOperationMode(mode); + } + + Return activate(int32_t sensorHandle, bool enabled) override { + return ISensorsSubHalBase::activate(sensorHandle, enabled); + } + + Return batch(int32_t sensorHandle, int64_t samplingPeriodNs, + int64_t maxReportLatencyNs) override { + return ISensorsSubHalBase::batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs); + } + + Return flush(int32_t sensorHandle) override { + return ISensorsSubHalBase::flush(sensorHandle); + } + + Return registerDirectChannel(const SharedMemInfo& mem, + V2_0::ISensors::registerDirectChannel_cb _hidl_cb) override { + return ISensorsSubHalBase::registerDirectChannel(mem, _hidl_cb); + } + + Return unregisterDirectChannel(int32_t channelHandle) override { + return ISensorsSubHalBase::unregisterDirectChannel(channelHandle); + } + + Return configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate, + V2_0::ISensors::configDirectReport_cb _hidl_cb) override { + return ISensorsSubHalBase::configDirectReport(sensorHandle, channelHandle, rate, _hidl_cb); + } + + Return debug(const hidl_handle& fd, const hidl_vec& args) override { + return ISensorsSubHalBase::debug(fd, args); + } + + const std::string getName() override { return ISensorsSubHalBase::getName(); } +}; + +class SensorsSubHalV2_0 : public SensorsSubHalBase { + public: + virtual Return getSensorsList(V2_0::ISensors::getSensorsList_cb _hidl_cb) override { + return ISensorsSubHalBase::getSensorsList([&](const auto& list) { + _hidl_cb(V2_1::implementation::convertToOldSensorInfos(list)); + }); + } + + Return injectSensorData(const V1_0::Event& event) override { + return ISensorsSubHalBase::injectSensorData(V2_1::implementation::convertToNewEvent(event)); + } + + Return initialize( + const sp& halProxyCallback) override { + std::unique_ptr wrapper = + std::make_unique(halProxyCallback); + return ISensorsSubHalBase::initialize(wrapper); + } +}; + +class SensorsSubHalV2_1 : public SensorsSubHalBase { + public: + Return getSensorsList_2_1(V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb) override { + return ISensorsSubHalBase::getSensorsList(_hidl_cb); + } + + Return injectSensorData_2_1(const V2_1::Event& event) override { + return ISensorsSubHalBase::injectSensorData(event); + } + + Return initialize( + const sp& halProxyCallback) override { + std::unique_ptr wrapper = + std::make_unique(halProxyCallback); + return ISensorsSubHalBase::initialize(wrapper); + } +}; + +// SubHal that has continuous sensors for testing purposes. +template +class ContinuousSensorsSubHal : public SubHalVersion { + public: + ContinuousSensorsSubHal() { + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + } }; // SubHal that has on-change sensors for testing purposes. -class OnChangeSensorsSubHal : public SensorsSubHal { +template +class OnChangeSensorsSubHal : public SubHalVersion { public: - OnChangeSensorsSubHal(); + OnChangeSensorsSubHal() { + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + } }; // SubHal that has both continuous and on-change sensors for testing purposes. -class AllSensorsSubHal : public SensorsSubHal { +template +class AllSensorsSubHal : public SubHalVersion { public: - AllSensorsSubHal(); + AllSensorsSubHal() { + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + ISensorsSubHalBase::AddSensor(); + } }; -class SetOperationModeFailingSensorsSubHal : public AllSensorsSubHal { +class SetOperationModeFailingSensorsSubHal : public AllSensorsSubHal { public: Return setOperationMode(OperationMode mode) override; }; -class AllSupportDirectChannelSensorsSubHal : public AllSensorsSubHal { +class AllSupportDirectChannelSensorsSubHal : public AllSensorsSubHal { public: - Return getSensorsList(getSensorsList_cb _hidl_cb) override; + Return getSensorsList(V2_0::ISensors::getSensorsList_cb _hidl_cb) override; }; -class DoesNotSupportDirectChannelSensorsSubHal : public AllSensorsSubHal { +class DoesNotSupportDirectChannelSensorsSubHal : public AllSensorsSubHal { public: - Return getSensorsList(getSensorsList_cb _hidl_cb) override; + Return getSensorsList(V2_0::ISensors::getSensorsList_cb _hidl_cb) override; }; -class AddAndRemoveDynamicSensorsSubHal : public AllSensorsSubHal { +class AddAndRemoveDynamicSensorsSubHal : public AllSensorsSubHal { public: void addDynamicSensors(const std::vector& sensorsAdded); void removeDynamicSensors(const std::vector& sensorHandlesAdded); @@ -159,7 +262,7 @@ class AddAndRemoveDynamicSensorsSubHal : public AllSensorsSubHal { } // namespace implementation } // namespace subhal -} // namespace V2_0 +} // namespace V2_1 } // namespace sensors } // namespace hardware } // namespace android