Revert "Update tests for multihal to test HAL 2.1"
Revert submission 10501254-multihal_2_1
Reason for revert: Droidcop: Potential culprit for b/155328660 - verifying through Forrest before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.
Bug: 155328660
Reverted Changes:
I2be51568b:Update tests for multihal to test HAL 2.1
Id5ab7b606:Create Multi-HAL 2.1 service
Icefae8c12:Set up Multi-HAL for Sensors HAL 2.1
Change-Id: I8b97eb29633cf24f464d742770256791108c27dd
diff --git a/sensors/common/default/2.X/multihal/tests/Android.bp b/sensors/common/default/2.X/multihal/tests/Android.bp
index 6586b0b..cfd9e78 100644
--- a/sensors/common/default/2.X/multihal/tests/Android.bp
+++ b/sensors/common/default/2.X/multihal/tests/Android.bp
@@ -50,7 +50,6 @@
vendor: true,
defaults: ["android.hardware.sensors@2.X-fakesubhal-defaults"],
cflags: [
- "-DSUB_HAL_VERSION_2_0",
"-DSUPPORT_CONTINUOUS_SENSORS",
"-DSUB_HAL_NAME=\"FakeSubHal-Continuous\"",
],
@@ -61,17 +60,6 @@
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 858786a..ce65c3c 100644
--- a/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp
+++ b/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp
@@ -15,15 +15,12 @@
#include <gtest/gtest.h>
-#include <android/hardware/sensors/1.0/types.h>
#include <android/hardware/sensors/2.0/types.h>
-#include <android/hardware/sensors/2.1/types.h>
#include <fmq/MessageQueue.h>
#include "HalProxy.h"
#include "SensorsSubHal.h"
#include "V2_0/ScopedWakelock.h"
-#include "convertV2_1.h"
#include <chrono>
#include <set>
@@ -41,35 +38,28 @@
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_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::
+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_1::subhal::implementation::ContinuousSensorsSubHal;
-using ::android::hardware::sensors::V2_1::subhal::implementation::
+using ::android::hardware::sensors::V2_0::subhal::implementation::ContinuousSensorsSubHal;
+using ::android::hardware::sensors::V2_0::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::
+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::HalProxy;
-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<EventV2_1, ::android::hardware::kSynchronizedReadWrite>;
-using EventMessageQueueV2_0 = MessageQueue<EventV1_0, ::android::hardware::kSynchronizedReadWrite>;
+using EventMessageQueue = MessageQueue<Event, ::android::hardware::kSynchronizedReadWrite>;
using WakeupMessageQueue = MessageQueue<uint32_t, ::android::hardware::kSynchronizedReadWrite>;
// The barebones sensors callback class passed into halproxy initialize calls
-class SensorsCallback : public ISensorsCallbackV2_0 {
+class SensorsCallback : public ISensorsCallback {
public:
Return<void> onDynamicSensorsConnected(
const hidl_vec<SensorInfo>& /*dynamicSensorsAdded*/) override {
@@ -84,30 +74,8 @@
}
};
-class SensorsCallbackV2_1 : public ISensorsCallbackV2_1 {
- public:
- Return<void> onDynamicSensorsConnected_2_1(
- const hidl_vec<::android::hardware::sensors::V2_1::SensorInfo>& /*dynamicSensorsAdded*/)
- override {
- // Nothing yet
- return Return<void>();
- }
-
- Return<void> onDynamicSensorsConnected(
- const hidl_vec<SensorInfo>& /*dynamicSensorsAdded*/) override {
- // Nothing yet
- return Return<void>();
- }
-
- Return<void> onDynamicSensorsDisconnected(
- const hidl_vec<int32_t>& /*dynamicSensorHandlesRemoved*/) override {
- // Nothing yet
- return Return<void>();
- }
-};
-
// The sensors callback that expects a variable list of sensors to be added
-class TestSensorsCallback : public ISensorsCallbackV2_0 {
+class TestSensorsCallback : public ISensorsCallback {
public:
Return<void> onDynamicSensorsConnected(
const hidl_vec<SensorInfo>& dynamicSensorsAdded) override {
@@ -162,10 +130,10 @@
void ackWakeupEventsToHalProxy(size_t numEvents, std::unique_ptr<WakeupMessageQueue>& wakelockQueue,
EventFlag* wakelockQueueFlag);
-bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr<EventMessageQueueV2_0>& eventQueue,
+bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr<EventMessageQueue>& eventQueue,
EventFlag* eventQueueFlag);
-std::unique_ptr<EventMessageQueueV2_0> makeEventFMQ(size_t size);
+std::unique_ptr<EventMessageQueue> makeEventFMQ(size_t size);
std::unique_ptr<WakeupMessageQueue> makeWakelockFMQ(size_t size);
@@ -175,7 +143,7 @@
*
* @return A proximity event.
*/
-EventV1_0 makeProximityEvent();
+Event makeProximityEvent();
/**
* Construct and return a HIDL Event type thats sensorHandle refers to a proximity sensor
@@ -183,7 +151,7 @@
*
* @return A proximity event.
*/
-EventV1_0 makeAccelerometerEvent();
+Event makeAccelerometerEvent();
/**
* Make a certain number of proximity type events with the sensorHandle field set to
@@ -193,7 +161,7 @@
*
* @return The created list of events.
*/
-std::vector<EventV1_0> makeMultipleProximityEvents(size_t numEvents);
+std::vector<Event> makeMultipleProximityEvents(size_t numEvents);
/**
* Make a certain number of accelerometer type events with the sensorHandle field set to
@@ -203,7 +171,7 @@
*
* @return The created list of events.
*/
-std::vector<EventV1_0> makeMultipleAccelerometerEvents(size_t numEvents);
+std::vector<Event> makeMultipleAccelerometerEvents(size_t numEvents);
/**
* Given a SensorInfo vector and a sensor handles vector populate 'sensors' with SensorInfo
@@ -221,7 +189,7 @@
// Tests follow
TEST(HalProxyTest, GetSensorsListOneSubHalTest) {
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> fakeSubHals{&subHal};
HalProxy proxy(fakeSubHals);
@@ -233,8 +201,8 @@
}
TEST(HalProxyTest, GetSensorsListTwoSubHalTest) {
- ContinuousSensorsSubHal<SensorsSubHalV2_0> continuousSubHal;
- OnChangeSensorsSubHal<SensorsSubHalV2_0> onChangeSubHal;
+ ContinuousSensorsSubHal continuousSubHal;
+ OnChangeSensorsSubHal onChangeSubHal;
std::vector<ISensorsSubHal*> fakeSubHals;
fakeSubHals.push_back(&continuousSubHal);
fakeSubHals.push_back(&onChangeSubHal);
@@ -254,8 +222,8 @@
}
TEST(HalProxyTest, SetOperationModeTwoSubHalSuccessTest) {
- ContinuousSensorsSubHal<SensorsSubHalV2_0> subHal1;
- OnChangeSensorsSubHal<SensorsSubHalV2_0> subHal2;
+ ContinuousSensorsSubHal subHal1;
+ OnChangeSensorsSubHal subHal2;
std::vector<ISensorsSubHal*> fakeSubHals{&subHal1, &subHal2};
HalProxy proxy(fakeSubHals);
@@ -271,7 +239,7 @@
}
TEST(HalProxyTest, SetOperationModeTwoSubHalFailTest) {
- AllSensorsSubHal<SensorsSubHalV2_0> subHal1;
+ AllSensorsSubHal subHal1;
SetOperationModeFailingSensorsSubHal subHal2;
std::vector<ISensorsSubHal*> fakeSubHals{&subHal1, &subHal2};
@@ -312,16 +280,16 @@
TEST(HalProxyTest, PostSingleNonWakeupEvent) {
constexpr size_t kQueueSize = 5;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
HalProxy proxy(subHals);
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
- std::vector<EventV1_0> events{makeAccelerometerEvent()};
- subHal.postEvents(convertToNewEvents(events), false /* wakeup */);
+ std::vector<Event> events{makeAccelerometerEvent()};
+ subHal.postEvents(events, false /* wakeup */);
EXPECT_EQ(eventQueue->availableToRead(), 1);
}
@@ -329,28 +297,28 @@
TEST(HalProxyTest, PostMultipleNonWakeupEvent) {
constexpr size_t kQueueSize = 5;
constexpr size_t kNumEvents = 3;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
HalProxy proxy(subHals);
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
- std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
- subHal.postEvents(convertToNewEvents(events), false /* wakeup */);
+ std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+ subHal.postEvents(events, false /* wakeup */);
EXPECT_EQ(eventQueue->availableToRead(), kNumEvents);
}
TEST(HalProxyTest, PostSingleWakeupEvent) {
constexpr size_t kQueueSize = 5;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
HalProxy proxy(subHals);
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
EventFlag* eventQueueFlag;
@@ -359,8 +327,8 @@
EventFlag* wakelockQueueFlag;
EventFlag::createEventFlag(wakeLockQueue->getEventFlagWord(), &wakelockQueueFlag);
- std::vector<EventV1_0> events{makeProximityEvent()};
- subHal.postEvents(convertToNewEvents(events), true /* wakeup */);
+ std::vector<Event> events{makeProximityEvent()};
+ subHal.postEvents(events, true /* wakeup */);
EXPECT_EQ(eventQueue->availableToRead(), 1);
@@ -371,12 +339,12 @@
TEST(HalProxyTest, PostMultipleWakeupEvents) {
constexpr size_t kQueueSize = 5;
constexpr size_t kNumEvents = 3;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
HalProxy proxy(subHals);
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
EventFlag* eventQueueFlag;
@@ -385,8 +353,8 @@
EventFlag* wakelockQueueFlag;
EventFlag::createEventFlag(wakeLockQueue->getEventFlagWord(), &wakelockQueueFlag);
- std::vector<EventV1_0> events = makeMultipleProximityEvents(kNumEvents);
- subHal.postEvents(convertToNewEvents(events), true /* wakeup */);
+ std::vector<Event> events = makeMultipleProximityEvents(kNumEvents);
+ subHal.postEvents(events, true /* wakeup */);
EXPECT_EQ(eventQueue->availableToRead(), kNumEvents);
@@ -397,20 +365,20 @@
TEST(HalProxyTest, PostEventsMultipleSubhals) {
constexpr size_t kQueueSize = 5;
constexpr size_t kNumEvents = 2;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal1, subHal2;
+ AllSensorsSubHal subHal1, subHal2;
std::vector<ISensorsSubHal*> subHals{&subHal1, &subHal2};
HalProxy proxy(subHals);
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
- std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
- subHal1.postEvents(convertToNewEvents(events), false /* wakeup */);
+ std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+ subHal1.postEvents(events, false /* wakeup */);
EXPECT_EQ(eventQueue->availableToRead(), kNumEvents);
- subHal2.postEvents(convertToNewEvents(events), false /* wakeup */);
+ subHal2.postEvents(events, false /* wakeup */);
EXPECT_EQ(eventQueue->availableToRead(), kNumEvents * 2);
}
@@ -418,19 +386,19 @@
TEST(HalProxyTest, PostEventsDelayedWrite) {
constexpr size_t kQueueSize = 5;
constexpr size_t kNumEvents = 6;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal1, subHal2;
+ AllSensorsSubHal subHal1, subHal2;
std::vector<ISensorsSubHal*> subHals{&subHal1, &subHal2};
HalProxy proxy(subHals);
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
EventFlag* eventQueueFlag;
EventFlag::createEventFlag(eventQueue->getEventFlagWord(), &eventQueueFlag);
- std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
- subHal1.postEvents(convertToNewEvents(events), false /* wakeup */);
+ std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+ subHal1.postEvents(events, false /* wakeup */);
EXPECT_EQ(eventQueue->availableToRead(), kQueueSize);
@@ -446,20 +414,18 @@
TEST(HalProxyTest, PostEventsMultipleSubhalsThreaded) {
constexpr size_t kQueueSize = 5;
constexpr size_t kNumEvents = 2;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal1, subHal2;
+ AllSensorsSubHal subHal1, subHal2;
std::vector<ISensorsSubHal*> subHals{&subHal1, &subHal2};
HalProxy proxy(subHals);
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
- std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
+ std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
- std::thread t1(&AllSensorsSubHal<SensorsSubHalV2_0>::postEvents, &subHal1,
- convertToNewEvents(events), false);
- std::thread t2(&AllSensorsSubHal<SensorsSubHalV2_0>::postEvents, &subHal2,
- convertToNewEvents(events), false);
+ std::thread t1(&AllSensorsSubHal::postEvents, &subHal1, events, false);
+ std::thread t2(&AllSensorsSubHal::postEvents, &subHal2, events, false);
t1.join();
t2.join();
@@ -470,34 +436,34 @@
TEST(HalProxyTest, DestructingWithEventsPendingOnBackgroundThread) {
constexpr size_t kQueueSize = 5;
constexpr size_t kNumEvents = 6;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
HalProxy proxy(subHals);
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
- std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
- subHal.postEvents(convertToNewEvents(events), false /* wakeup */);
+ std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+ subHal.postEvents(events, false /* wakeup */);
// Destructing HalProxy object with events on the background thread
}
TEST(HalProxyTest, DestructingWithUnackedWakeupEventsPosted) {
constexpr size_t kQueueSize = 5;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
HalProxy proxy(subHals);
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
- std::vector<EventV1_0> events{makeProximityEvent()};
- subHal.postEvents(convertToNewEvents(events), true /* wakeup */);
+ std::vector<Event> events{makeProximityEvent()};
+ subHal.postEvents(events, true /* wakeup */);
// Not sending any acks back through wakeLockQueue
@@ -507,17 +473,17 @@
TEST(HalProxyTest, ReinitializeWithEventsPendingOnBackgroundThread) {
constexpr size_t kQueueSize = 5;
constexpr size_t kNumEvents = 10;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
HalProxy proxy(subHals);
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
- std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
- subHal.postEvents(convertToNewEvents(events), false /* wakeup */);
+ std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+ subHal.postEvents(events, false /* wakeup */);
eventQueue = makeEventFMQ(kQueueSize);
wakeLockQueue = makeWakelockFMQ(kQueueSize);
@@ -527,23 +493,23 @@
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));
- EventV1_0 eventOut;
+ Event eventOut;
EXPECT_FALSE(eventQueue->read(&eventOut));
}
TEST(HalProxyTest, ReinitializingWithUnackedWakeupEventsPosted) {
constexpr size_t kQueueSize = 5;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
HalProxy proxy(subHals);
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
- std::vector<EventV1_0> events{makeProximityEvent()};
- subHal.postEvents(convertToNewEvents(events), true /* wakeup */);
+ std::vector<Event> events{makeProximityEvent()};
+ subHal.postEvents(events, true /* wakeup */);
// Not sending any acks back through wakeLockQueue
@@ -558,12 +524,12 @@
TEST(HalProxyTest, InitializeManyTimesInARow) {
constexpr size_t kQueueSize = 5;
constexpr size_t kNumTimesToInit = 100;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
HalProxy proxy(subHals);
for (size_t i = 0; i < kNumTimesToInit; i++) {
@@ -575,15 +541,15 @@
TEST(HalProxyTest, OperationModeResetOnInitialize) {
constexpr size_t kQueueSize = 5;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+ AllSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
HalProxy proxy(subHals);
proxy.setOperationMode(OperationMode::DATA_INJECTION);
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
- EventV1_0 event = makeAccelerometerEvent();
+ Event 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);
@@ -594,7 +560,7 @@
constexpr size_t kNumSensors = 5;
AddAndRemoveDynamicSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
HalProxy proxy(subHals);
@@ -609,9 +575,9 @@
}
TestSensorsCallback* callback = new TestSensorsCallback();
- ::android::sp<ISensorsCallbackV2_0> callbackPtr = callback;
+ ::android::sp<ISensorsCallback> callbackPtr = callback;
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr);
- subHal.addDynamicSensors(convertToNewSensorInfos(sensorsToConnect));
+ subHal.addDynamicSensors(sensorsToConnect);
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr);
subHal.removeDynamicSensors(sensorHandlesToAttemptToRemove);
@@ -628,7 +594,7 @@
AddAndRemoveDynamicSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
HalProxy proxy(subHals);
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(0);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(0);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(0);
std::vector<SensorInfo> sensorsToConnect;
@@ -637,9 +603,9 @@
sensorHandlesToExpect);
TestSensorsCallback* callback = new TestSensorsCallback();
- ::android::sp<ISensorsCallbackV2_0> callbackPtr = callback;
+ ::android::sp<ISensorsCallback> callbackPtr = callback;
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr);
- subHal.addDynamicSensors(convertToNewSensorInfos(sensorsToConnect));
+ subHal.addDynamicSensors(sensorsToConnect);
std::vector<SensorInfo> sensorsSeen = callback->getSensorsConnected();
EXPECT_EQ(kNumSensors, sensorsSeen.size());
@@ -656,7 +622,7 @@
AddAndRemoveDynamicSensorsSubHal subHal;
std::vector<ISensorsSubHal*> subHals{&subHal};
HalProxy proxy(subHals);
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(0);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(0);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(0);
std::vector<SensorInfo> sensorsToConnect;
@@ -681,9 +647,9 @@
nonDynamicSensorHandles.end());
TestSensorsCallback* callback = new TestSensorsCallback();
- ::android::sp<ISensorsCallbackV2_0> callbackPtr = callback;
+ ::android::sp<ISensorsCallback> callbackPtr = callback;
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr);
- subHal.addDynamicSensors(convertToNewSensorInfos(sensorsToConnect));
+ subHal.addDynamicSensors(sensorsToConnect);
subHal.removeDynamicSensors(sensorHandlesToAttemptToRemove);
std::vector<int32_t> sensorHandlesSeen = callback->getSensorHandlesDisconnected();
@@ -702,15 +668,15 @@
constexpr size_t kNumSubHals = 3;
constexpr size_t kQueueSize = 5;
int32_t kNumSubHalsInt32 = static_cast<int32_t>(kNumSubHals);
- std::vector<AllSensorsSubHal<SensorsSubHalV2_0>> subHalObjs(kNumSubHals);
+ std::vector<AllSensorsSubHal> subHalObjs(kNumSubHals);
std::vector<ISensorsSubHal*> subHals;
for (const auto& subHal : subHalObjs) {
subHals.push_back((ISensorsSubHal*)(&subHal));
}
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
HalProxy proxy(subHals);
// Initialize for the injectSensorData call so callback postEvents is valid
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
@@ -722,7 +688,7 @@
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);
- EventV1_0 event;
+ Event event;
event.sensorHandle = 0x00000001 | (kNumSubHalsInt32 << 24);
EXPECT_EQ(proxy.injectSensorData(event), Result::BAD_VALUE);
}
@@ -731,28 +697,28 @@
constexpr size_t kQueueSize = 5;
constexpr int32_t subhal1Index = 0;
constexpr int32_t subhal2Index = 1;
- AllSensorsSubHal<SensorsSubHalV2_0> subhal1;
- AllSensorsSubHal<SensorsSubHalV2_0> subhal2;
+ AllSensorsSubHal subhal1;
+ AllSensorsSubHal subhal2;
std::vector<ISensorsSubHal*> subHals{&subhal1, &subhal2};
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> callback = new SensorsCallback();
HalProxy proxy(subHals);
proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
int32_t sensorHandleToPost = 0x00000001;
- EventV1_0 eventIn = makeAccelerometerEvent();
+ Event eventIn = makeAccelerometerEvent();
eventIn.sensorHandle = sensorHandleToPost;
- std::vector<EventV1_0> eventsToPost{eventIn};
- subhal1.postEvents(convertToNewEvents(eventsToPost), false);
+ std::vector<Event> eventsToPost{eventIn};
+ subhal1.postEvents(eventsToPost, false);
- EventV1_0 eventOut;
+ Event eventOut;
EXPECT_TRUE(eventQueue->read(&eventOut));
EXPECT_EQ(eventOut.sensorHandle, (subhal1Index << 24) | sensorHandleToPost);
- subhal2.postEvents(convertToNewEvents(eventsToPost), false);
+ subhal2.postEvents(eventsToPost, false);
EXPECT_TRUE(eventQueue->read(&eventOut));
@@ -763,22 +729,22 @@
constexpr size_t kQueueSize = 5;
// TODO: Make this constant linked to same limit in HalProxy.h
constexpr size_t kMaxPendingQueueSize = 100000;
- AllSensorsSubHal<SensorsSubHalV2_0> subhal;
+ AllSensorsSubHal subhal;
std::vector<ISensorsSubHal*> subHals{&subhal};
- std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+ std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+ ::android::sp<ISensorsCallback> 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<EventV1_0> events = makeMultipleAccelerometerEvents(kQueueSize);
- subhal.postEvents(convertToNewEvents(events), false);
+ std::vector<Event> events = makeMultipleAccelerometerEvents(kQueueSize);
+ subhal.postEvents(events, false);
events = makeMultipleAccelerometerEvents(kMaxPendingQueueSize);
- subhal.postEvents(convertToNewEvents(events), false);
+ subhal.postEvents(events, false);
// Drain pending queue
for (int i = 0; i < kMaxPendingQueueSize + kQueueSize; i += kQueueSize) {
@@ -787,9 +753,9 @@
// Put one event on pending queue
events = makeMultipleAccelerometerEvents(kQueueSize);
- subhal.postEvents(convertToNewEvents(events), false);
+ subhal.postEvents(events, false);
events = {makeAccelerometerEvent()};
- subhal.postEvents(convertToNewEvents(events), false);
+ subhal.postEvents(events, false);
// Read out to make room for one event on pending queue to write to FMQ
ASSERT_TRUE(readEventsOutOfQueue(kQueueSize, eventQueue, eventQueueFlag));
@@ -798,35 +764,6 @@
EXPECT_TRUE(readEventsOutOfQueue(1, eventQueue, eventQueueFlag));
}
-TEST(HalProxyTest, PostEventsMultipleSubhalsThreadedV2_1) {
- constexpr size_t kQueueSize = 5;
- constexpr size_t kNumEvents = 2;
- AllSensorsSubHal<SensorsSubHalV2_0> subHal1;
- AllSensorsSubHal<SensorsSubHalV2_1> 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<EventMessageQueueV2_1> eventQueue =
- std::make_unique<EventMessageQueueV2_1>(kQueueSize, true);
- std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
- ::android::sp<ISensorsCallbackV2_1> callback = new SensorsCallbackV2_1();
- proxy.initialize_2_1(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
-
- std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
-
- std::thread t1(&AllSensorsSubHal<SensorsSubHalV2_0>::postEvents, &subHal1,
- convertToNewEvents(events), false);
- std::thread t2(&AllSensorsSubHal<SensorsSubHalV2_1>::postEvents, &subHal2,
- convertToNewEvents(events), false);
-
- t1.join();
- t2.join();
-
- EXPECT_EQ(eventQueue->availableToRead(), kNumEvents * 2);
-}
-
// Helper implementations follow
void testSensorsListFromProxyAndSubHal(const std::vector<SensorInfo>& proxySensorsList,
const std::vector<SensorInfo>& subHalSensorsList) {
@@ -865,26 +802,26 @@
wakelockQueueFlag->wake(static_cast<uint32_t>(WakeLockQueueFlagBits::DATA_WRITTEN));
}
-bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr<EventMessageQueueV2_0>& eventQueue,
+bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr<EventMessageQueue>& eventQueue,
EventFlag* eventQueueFlag) {
constexpr int64_t kReadBlockingTimeout = INT64_C(500000000);
- std::vector<EventV1_0> events(numEvents);
+ std::vector<Event> events(numEvents);
return eventQueue->readBlocking(events.data(), numEvents,
static_cast<uint32_t>(EventQueueFlagBits::EVENTS_READ),
static_cast<uint32_t>(EventQueueFlagBits::READ_AND_PROCESS),
kReadBlockingTimeout, eventQueueFlag);
}
-std::unique_ptr<EventMessageQueueV2_0> makeEventFMQ(size_t size) {
- return std::make_unique<EventMessageQueueV2_0>(size, true);
+std::unique_ptr<EventMessageQueue> makeEventFMQ(size_t size) {
+ return std::make_unique<EventMessageQueue>(size, true);
}
std::unique_ptr<WakeupMessageQueue> makeWakelockFMQ(size_t size) {
return std::make_unique<WakeupMessageQueue>(size, true);
}
-EventV1_0 makeProximityEvent() {
- EventV1_0 event;
+Event makeProximityEvent() {
+ Event event;
event.timestamp = 0xFF00FF00;
// This is the sensorhandle of proximity, which is wakeup type
event.sensorHandle = 0x00000008;
@@ -893,8 +830,8 @@
return event;
}
-EventV1_0 makeAccelerometerEvent() {
- EventV1_0 event;
+Event makeAccelerometerEvent() {
+ Event event;
event.timestamp = 0xFF00FF00;
// This is the sensorhandle of proximity, which is wakeup type
event.sensorHandle = 0x00000001;
@@ -903,16 +840,16 @@
return event;
}
-std::vector<EventV1_0> makeMultipleProximityEvents(size_t numEvents) {
- std::vector<EventV1_0> events;
+std::vector<Event> makeMultipleProximityEvents(size_t numEvents) {
+ std::vector<Event> events;
for (size_t i = 0; i < numEvents; i++) {
events.push_back(makeProximityEvent());
}
return events;
}
-std::vector<EventV1_0> makeMultipleAccelerometerEvents(size_t numEvents) {
- std::vector<EventV1_0> events;
+std::vector<Event> makeMultipleAccelerometerEvents(size_t numEvents) {
+ std::vector<Event> 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
deleted file mode 100644
index 4542bfd..0000000
--- a/sensors/common/default/2.X/multihal/tests/fake_subhal/IHalProxyCallbackWrapper.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * 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<void> onDynamicSensorsConnected(
- const hidl_vec<V2_1::SensorInfo>& sensorInfos) = 0;
-
- virtual Return<void> onDynamicSensorsDisconnected(const hidl_vec<int32_t>& sensorHandles) = 0;
-
- virtual void postEvents(const std::vector<V2_1::Event>& events, ScopedWakelock wakelock) = 0;
-
- virtual ScopedWakelock createScopedWakelock(bool lock) = 0;
-};
-
-template <typename T>
-class HalProxyCallbackWrapperBase : public IHalProxyCallbackWrapperBase {
- public:
- HalProxyCallbackWrapperBase(sp<T> callback) : mCallback(callback){};
-
- Return<void> onDynamicSensorsDisconnected(const hidl_vec<int32_t>& sensorHandles) override {
- return mCallback->onDynamicSensorsDisconnected(sensorHandles);
- }
-
- ScopedWakelock createScopedWakelock(bool lock) override {
- return mCallback->createScopedWakelock(lock);
- }
-
- protected:
- sp<T> mCallback;
-};
-
-class HalProxyCallbackWrapperV2_0
- : public HalProxyCallbackWrapperBase<V2_0::implementation::IHalProxyCallback> {
- public:
- HalProxyCallbackWrapperV2_0(sp<V2_0::implementation::IHalProxyCallback> callback)
- : HalProxyCallbackWrapperBase(callback){};
-
- Return<void> onDynamicSensorsConnected(const hidl_vec<V2_1::SensorInfo>& sensorInfos) override {
- return mCallback->onDynamicSensorsConnected(
- V2_1::implementation::convertToOldSensorInfos(sensorInfos));
- }
-
- void postEvents(const std::vector<V2_1::Event>& events, ScopedWakelock wakelock) override {
- return mCallback->postEvents(V2_1::implementation::convertToOldEvents(events),
- std::move(wakelock));
- }
-};
-
-class HalProxyCallbackWrapperV2_1
- : public HalProxyCallbackWrapperBase<V2_1::implementation::IHalProxyCallback> {
- public:
- HalProxyCallbackWrapperV2_1(sp<V2_1::implementation::IHalProxyCallback> callback)
- : HalProxyCallbackWrapperBase(callback){};
-
- Return<void> onDynamicSensorsConnected(const hidl_vec<V2_1::SensorInfo>& sensorInfos) override {
- return mCallback->onDynamicSensorsConnected_2_1(sensorInfos);
- }
-
- void postEvents(const std::vector<V2_1::Event>& 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 1efd971..de89a00 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,18 +24,13 @@
namespace android {
namespace hardware {
namespace sensors {
-namespace V2_1 {
+namespace V2_0 {
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),
@@ -348,7 +343,7 @@
} // namespace implementation
} // namespace subhal
-} // namespace V2_1
+} // namespace V2_0
} // 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 5cf9f83..60f5d3d 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 <android/hardware/sensors/2.1/types.h>
+#include <android/hardware/sensors/1.0/types.h>
#include <condition_variable>
#include <memory>
@@ -24,16 +24,16 @@
#include <thread>
#include <vector>
+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::V2_1::Event;
-using ::android::hardware::sensors::V2_1::SensorInfo;
-using ::android::hardware::sensors::V2_1::SensorType;
+using ::android::hardware::sensors::V1_0::SensorInfo;
+using ::android::hardware::sensors::V1_0::SensorType;
namespace android {
namespace hardware {
namespace sensors {
-namespace V2_1 {
+namespace V2_0 {
namespace subhal {
namespace implementation {
@@ -151,7 +151,7 @@
} // namespace implementation
} // namespace subhal
-} // namespace V2_1
+} // namespace V2_0
} // 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 20a4e9d..ff5ff38 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,66 +16,33 @@
#include "SensorsSubHal.h"
-#include <android/hardware/sensors/2.1/types.h>
+#include <android/hardware/sensors/2.0/types.h>
#include <log/log.h>
-#ifdef SUB_HAL_VERSION_2_0
-::android::hardware::sensors::V2_0::implementation::ISensorsSubHal* sensorsHalGetSubHal(
- uint32_t* version) {
+ISensorsSubHal* sensorsHalGetSubHal(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_0>
- subHal;
+ static ::android::hardware::sensors::V2_0::subhal::implementation::AllSensorsSubHal subHal;
#elif defined SUPPORT_CONTINUOUS_SENSORS
- static ::android::hardware::sensors::V2_1::subhal::implementation::ContinuousSensorsSubHal<
- ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0>
+ static ::android::hardware::sensors::V2_0::subhal::implementation::ContinuousSensorsSubHal
subHal;
#elif defined SUPPORT_ON_CHANGE_SENSORS
- static ::android::hardware::sensors::V2_1::subhal::implementation::OnChangeSensorsSubHal<
- ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0>
- subHal;
+ static ::android::hardware::sensors::V2_0::subhal::implementation::OnChangeSensorsSubHal subHal;
#else
- static ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHal<
- ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0>
- subHal;
+ static ::android::hardware::sensors::V2_0::subhal::implementation::SensorsSubHal 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_1 {
+namespace V2_0 {
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;
@@ -83,12 +50,11 @@
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;
-ISensorsSubHalBase::ISensorsSubHalBase() : mCallback(nullptr), mNextHandle(1) {}
+SensorsSubHal::SensorsSubHal() : mCallback(nullptr), mNextHandle(1) {}
// Methods from ::android::hardware::sensors::V2_0::ISensors follow.
-Return<void> ISensorsSubHalBase::getSensorsList(V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb) {
+Return<void> SensorsSubHal::getSensorsList(getSensorsList_cb _hidl_cb) {
std::vector<SensorInfo> sensors;
for (const auto& sensor : mSensors) {
sensors.push_back(sensor.second->getSensorInfo());
@@ -98,7 +64,7 @@
return Void();
}
-Return<Result> ISensorsSubHalBase::setOperationMode(OperationMode mode) {
+Return<Result> SensorsSubHal::setOperationMode(OperationMode mode) {
for (auto sensor : mSensors) {
sensor.second->setOperationMode(mode);
}
@@ -106,7 +72,7 @@
return Result::OK;
}
-Return<Result> ISensorsSubHalBase::activate(int32_t sensorHandle, bool enabled) {
+Return<Result> SensorsSubHal::activate(int32_t sensorHandle, bool enabled) {
auto sensor = mSensors.find(sensorHandle);
if (sensor != mSensors.end()) {
sensor->second->activate(enabled);
@@ -115,8 +81,8 @@
return Result::BAD_VALUE;
}
-Return<Result> ISensorsSubHalBase::batch(int32_t sensorHandle, int64_t samplingPeriodNs,
- int64_t /* maxReportLatencyNs */) {
+Return<Result> SensorsSubHal::batch(int32_t sensorHandle, int64_t samplingPeriodNs,
+ int64_t /* maxReportLatencyNs */) {
auto sensor = mSensors.find(sensorHandle);
if (sensor != mSensors.end()) {
sensor->second->batch(samplingPeriodNs);
@@ -125,7 +91,7 @@
return Result::BAD_VALUE;
}
-Return<Result> ISensorsSubHalBase::flush(int32_t sensorHandle) {
+Return<Result> SensorsSubHal::flush(int32_t sensorHandle) {
auto sensor = mSensors.find(sensorHandle);
if (sensor != mSensors.end()) {
return sensor->second->flush();
@@ -133,7 +99,7 @@
return Result::BAD_VALUE;
}
-Return<Result> ISensorsSubHalBase::injectSensorData(const Event& event) {
+Return<Result> SensorsSubHal::injectSensorData(const Event& event) {
auto sensor = mSensors.find(event.sensorHandle);
if (sensor != mSensors.end()) {
return sensor->second->injectEvent(event);
@@ -142,24 +108,24 @@
return Result::BAD_VALUE;
}
-Return<void> ISensorsSubHalBase::registerDirectChannel(
- const SharedMemInfo& /* mem */, V2_0::ISensors::registerDirectChannel_cb _hidl_cb) {
+Return<void> SensorsSubHal::registerDirectChannel(const SharedMemInfo& /* mem */,
+ registerDirectChannel_cb _hidl_cb) {
_hidl_cb(Result::INVALID_OPERATION, -1 /* channelHandle */);
return Return<void>();
}
-Return<Result> ISensorsSubHalBase::unregisterDirectChannel(int32_t /* channelHandle */) {
+Return<Result> SensorsSubHal::unregisterDirectChannel(int32_t /* channelHandle */) {
return Result::INVALID_OPERATION;
}
-Return<void> ISensorsSubHalBase::configDirectReport(
- int32_t /* sensorHandle */, int32_t /* channelHandle */, RateLevel /* rate */,
- V2_0::ISensors::configDirectReport_cb _hidl_cb) {
+Return<void> SensorsSubHal::configDirectReport(int32_t /* sensorHandle */,
+ int32_t /* channelHandle */, RateLevel /* rate */,
+ configDirectReport_cb _hidl_cb) {
_hidl_cb(Result::INVALID_OPERATION, 0 /* reportToken */);
return Return<void>();
}
-Return<void> ISensorsSubHalBase::debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) {
+Return<void> SensorsSubHal::debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) {
if (fd.getNativeHandle() == nullptr || fd->numFds < 1) {
ALOGE("%s: missing fd for writing", __FUNCTION__);
return Void();
@@ -190,18 +156,44 @@
return Return<void>();
}
-Return<Result> ISensorsSubHalBase::initialize(
- std::unique_ptr<IHalProxyCallbackWrapperBase>& halProxyCallback) {
- mCallback = std::move(halProxyCallback);
+Return<Result> SensorsSubHal::initialize(const sp<IHalProxyCallback>& halProxyCallback) {
+ mCallback = halProxyCallback;
setOperationMode(OperationMode::NORMAL);
return Result::OK;
}
-void ISensorsSubHalBase::postEvents(const std::vector<Event>& events, bool wakeup) {
+void SensorsSubHal::postEvents(const std::vector<Event>& events, bool wakeup) {
ScopedWakelock wakelock = mCallback->createScopedWakelock(wakeup);
mCallback->postEvents(events, std::move(wakelock));
}
+ContinuousSensorsSubHal::ContinuousSensorsSubHal() {
+ AddSensor<AccelSensor>();
+ AddSensor<GyroSensor>();
+ AddSensor<MagnetometerSensor>();
+ AddSensor<PressureSensor>();
+ AddSensor<DeviceTempSensor>();
+}
+
+OnChangeSensorsSubHal::OnChangeSensorsSubHal() {
+ AddSensor<AmbientTempSensor>();
+ AddSensor<LightSensor>();
+ AddSensor<ProximitySensor>();
+ AddSensor<RelativeHumiditySensor>();
+}
+
+AllSensorsSubHal::AllSensorsSubHal() {
+ AddSensor<AccelSensor>();
+ AddSensor<GyroSensor>();
+ AddSensor<MagnetometerSensor>();
+ AddSensor<PressureSensor>();
+ AddSensor<DeviceTempSensor>();
+ AddSensor<AmbientTempSensor>();
+ AddSensor<LightSensor>();
+ AddSensor<ProximitySensor>();
+ AddSensor<RelativeHumiditySensor>();
+}
+
Return<Result> SetOperationModeFailingSensorsSubHal::setOperationMode(OperationMode /*mode*/) {
return Result::BAD_VALUE;
}
@@ -214,7 +206,7 @@
sensorInfo.flags |= V1_0::SensorFlagBits::MASK_DIRECT_REPORT;
sensors.push_back(sensorInfo);
}
- _hidl_cb(V2_1::implementation::convertToOldSensorInfos(sensors));
+ _hidl_cb(sensors);
return Void();
}
@@ -226,7 +218,7 @@
sensorInfo.flags &= ~static_cast<uint32_t>(V1_0::SensorFlagBits::MASK_DIRECT_REPORT);
sensors.push_back(sensorInfo);
}
- _hidl_cb(V2_1::implementation::convertToOldSensorInfos(sensors));
+ _hidl_cb(sensors);
return Void();
}
@@ -242,7 +234,7 @@
} // namespace implementation
} // namespace subhal
-} // namespace V2_1
+} // namespace V2_0
} // 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 1a78e84..6da4404 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,9 +17,7 @@
#pragma once
#include "V2_0/SubHal.h"
-#include "V2_1/SubHal.h"
-#include "IHalProxyCallbackWrapper.h"
#include "Sensor.h"
#include <vector>
@@ -27,54 +25,54 @@
namespace android {
namespace hardware {
namespace sensors {
-namespace V2_1 {
+namespace V2_0 {
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 ISensorsSubHalBase : public ISensorsEventCallback {
- protected:
- using Event = ::android::hardware::sensors::V2_1::Event;
+class SensorsSubHal : public ISensorsSubHal, public ISensorsEventCallback {
+ using Event = ::android::hardware::sensors::V1_0::Event;
using RateLevel = ::android::hardware::sensors::V1_0::RateLevel;
using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
public:
- ISensorsSubHalBase();
-
- Return<void> getSensorsList(V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb);
- Return<Result> injectSensorData(const Event& event);
- Return<Result> initialize(std::unique_ptr<IHalProxyCallbackWrapperBase>& halProxyCallback);
+ SensorsSubHal();
// Methods from ::android::hardware::sensors::V2_0::ISensors follow.
- virtual Return<Result> setOperationMode(OperationMode mode);
+ virtual Return<void> getSensorsList(getSensorsList_cb _hidl_cb) override;
+
+ virtual Return<Result> setOperationMode(OperationMode mode) override;
OperationMode getOperationMode() const { return mCurrentOperationMode; }
- Return<Result> activate(int32_t sensorHandle, bool enabled);
+ Return<Result> activate(int32_t sensorHandle, bool enabled) override;
Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
- int64_t maxReportLatencyNs);
+ int64_t maxReportLatencyNs) override;
- Return<Result> flush(int32_t sensorHandle);
+ Return<Result> flush(int32_t sensorHandle) override;
+
+ Return<Result> injectSensorData(const Event& event) override;
Return<void> registerDirectChannel(const SharedMemInfo& mem,
- V2_0::ISensors::registerDirectChannel_cb _hidl_cb);
+ registerDirectChannel_cb _hidl_cb) override;
- Return<Result> unregisterDirectChannel(int32_t channelHandle);
+ Return<Result> unregisterDirectChannel(int32_t channelHandle) override;
Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
- V2_0::ISensors::configDirectReport_cb _hidl_cb);
+ configDirectReport_cb _hidl_cb) override;
- Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args);
+ Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) override;
// Methods from ::android::hardware::sensors::V2_0::implementation::ISensorsSubHal follow.
- const std::string getName() {
+ const std::string getName() override {
#ifdef SUB_HAL_NAME
return SUB_HAL_NAME;
#else // SUB_HAL_NAME
@@ -82,6 +80,8 @@
#endif // SUB_HAL_NAME
}
+ Return<Result> initialize(const sp<IHalProxyCallback>& halProxyCallback) override;
+
// Method from ISensorsEventCallback.
void postEvents(const std::vector<Event>& events, bool wakeup) override;
@@ -103,7 +103,7 @@
* disconnected, sensor events need to be sent to the framework, and when a wakelock should be
* acquired.
*/
- std::unique_ptr<IHalProxyCallbackWrapperBase> mCallback;
+ sp<IHalProxyCallback> mCallback;
private:
/**
@@ -118,143 +118,40 @@
int32_t mNextHandle;
};
-template <class SubHalClass>
-class SensorsSubHalBase : public ISensorsSubHalBase, public SubHalClass {
- public:
- Return<Result> setOperationMode(OperationMode mode) override {
- return ISensorsSubHalBase::setOperationMode(mode);
- }
-
- Return<Result> activate(int32_t sensorHandle, bool enabled) override {
- return ISensorsSubHalBase::activate(sensorHandle, enabled);
- }
-
- Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
- int64_t maxReportLatencyNs) override {
- return ISensorsSubHalBase::batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs);
- }
-
- Return<Result> flush(int32_t sensorHandle) override {
- return ISensorsSubHalBase::flush(sensorHandle);
- }
-
- Return<void> registerDirectChannel(const SharedMemInfo& mem,
- V2_0::ISensors::registerDirectChannel_cb _hidl_cb) override {
- return ISensorsSubHalBase::registerDirectChannel(mem, _hidl_cb);
- }
-
- Return<Result> unregisterDirectChannel(int32_t channelHandle) override {
- return ISensorsSubHalBase::unregisterDirectChannel(channelHandle);
- }
-
- Return<void> 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<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) override {
- return ISensorsSubHalBase::debug(fd, args);
- }
-
- const std::string getName() override { return ISensorsSubHalBase::getName(); }
-};
-
-class SensorsSubHalV2_0 : public SensorsSubHalBase<V2_0::implementation::ISensorsSubHal> {
- public:
- virtual Return<void> getSensorsList(V2_0::ISensors::getSensorsList_cb _hidl_cb) override {
- return ISensorsSubHalBase::getSensorsList([&](const auto& list) {
- _hidl_cb(V2_1::implementation::convertToOldSensorInfos(list));
- });
- }
-
- Return<Result> injectSensorData(const V1_0::Event& event) override {
- return ISensorsSubHalBase::injectSensorData(V2_1::implementation::convertToNewEvent(event));
- }
-
- Return<Result> initialize(
- const sp<V2_0::implementation::IHalProxyCallback>& halProxyCallback) override {
- std::unique_ptr<IHalProxyCallbackWrapperBase> wrapper =
- std::make_unique<HalProxyCallbackWrapperV2_0>(halProxyCallback);
- return ISensorsSubHalBase::initialize(wrapper);
- }
-};
-
-class SensorsSubHalV2_1 : public SensorsSubHalBase<V2_1::implementation::ISensorsSubHal> {
- public:
- Return<void> getSensorsList_2_1(V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb) override {
- return ISensorsSubHalBase::getSensorsList(_hidl_cb);
- }
-
- Return<Result> injectSensorData_2_1(const V2_1::Event& event) override {
- return ISensorsSubHalBase::injectSensorData(event);
- }
-
- Return<Result> initialize(
- const sp<V2_1::implementation::IHalProxyCallback>& halProxyCallback) override {
- std::unique_ptr<IHalProxyCallbackWrapperBase> wrapper =
- std::make_unique<HalProxyCallbackWrapperV2_1>(halProxyCallback);
- return ISensorsSubHalBase::initialize(wrapper);
- }
-};
-
// SubHal that has continuous sensors for testing purposes.
-template <class SubHalVersion>
-class ContinuousSensorsSubHal : public SubHalVersion {
+class ContinuousSensorsSubHal : public SensorsSubHal {
public:
- ContinuousSensorsSubHal() {
- ISensorsSubHalBase::AddSensor<AccelSensor>();
- ISensorsSubHalBase::AddSensor<GyroSensor>();
- ISensorsSubHalBase::AddSensor<MagnetometerSensor>();
- ISensorsSubHalBase::AddSensor<PressureSensor>();
- ISensorsSubHalBase::AddSensor<DeviceTempSensor>();
- }
+ ContinuousSensorsSubHal();
};
// SubHal that has on-change sensors for testing purposes.
-template <class SubHalVersion>
-class OnChangeSensorsSubHal : public SubHalVersion {
+class OnChangeSensorsSubHal : public SensorsSubHal {
public:
- OnChangeSensorsSubHal() {
- ISensorsSubHalBase::AddSensor<AmbientTempSensor>();
- ISensorsSubHalBase::AddSensor<LightSensor>();
- ISensorsSubHalBase::AddSensor<ProximitySensor>();
- ISensorsSubHalBase::AddSensor<RelativeHumiditySensor>();
- }
+ OnChangeSensorsSubHal();
};
// SubHal that has both continuous and on-change sensors for testing purposes.
-template <class SubHalVersion>
-class AllSensorsSubHal : public SubHalVersion {
+class AllSensorsSubHal : public SensorsSubHal {
public:
- AllSensorsSubHal() {
- ISensorsSubHalBase::AddSensor<AccelSensor>();
- ISensorsSubHalBase::AddSensor<GyroSensor>();
- ISensorsSubHalBase::AddSensor<MagnetometerSensor>();
- ISensorsSubHalBase::AddSensor<PressureSensor>();
- ISensorsSubHalBase::AddSensor<DeviceTempSensor>();
- ISensorsSubHalBase::AddSensor<AmbientTempSensor>();
- ISensorsSubHalBase::AddSensor<LightSensor>();
- ISensorsSubHalBase::AddSensor<ProximitySensor>();
- ISensorsSubHalBase::AddSensor<RelativeHumiditySensor>();
- }
+ AllSensorsSubHal();
};
-class SetOperationModeFailingSensorsSubHal : public AllSensorsSubHal<SensorsSubHalV2_0> {
+class SetOperationModeFailingSensorsSubHal : public AllSensorsSubHal {
public:
Return<Result> setOperationMode(OperationMode mode) override;
};
-class AllSupportDirectChannelSensorsSubHal : public AllSensorsSubHal<SensorsSubHalV2_0> {
+class AllSupportDirectChannelSensorsSubHal : public AllSensorsSubHal {
public:
- Return<void> getSensorsList(V2_0::ISensors::getSensorsList_cb _hidl_cb) override;
+ Return<void> getSensorsList(getSensorsList_cb _hidl_cb) override;
};
-class DoesNotSupportDirectChannelSensorsSubHal : public AllSensorsSubHal<SensorsSubHalV2_0> {
+class DoesNotSupportDirectChannelSensorsSubHal : public AllSensorsSubHal {
public:
- Return<void> getSensorsList(V2_0::ISensors::getSensorsList_cb _hidl_cb) override;
+ Return<void> getSensorsList(getSensorsList_cb _hidl_cb) override;
};
-class AddAndRemoveDynamicSensorsSubHal : public AllSensorsSubHal<SensorsSubHalV2_0> {
+class AddAndRemoveDynamicSensorsSubHal : public AllSensorsSubHal {
public:
void addDynamicSensors(const std::vector<SensorInfo>& sensorsAdded);
void removeDynamicSensors(const std::vector<int32_t>& sensorHandlesAdded);
@@ -262,7 +159,7 @@
} // namespace implementation
} // namespace subhal
-} // namespace V2_1
+} // namespace V2_0
} // namespace sensors
} // namespace hardware
} // namespace android