/* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef ANDROID_SENSORS_WRAPPER_H #define ANDROID_SENSORS_WRAPPER_H #include "android/hardware/sensors/1.0/ISensors.h" #include "android/hardware/sensors/2.0/ISensors.h" #include "android/hardware/sensors/2.0/ISensorsCallback.h" #include <utils/LightRefBase.h> namespace android { namespace SensorServiceUtil { using ::android::hardware::MQDescriptorSync; using ::android::hardware::Return; using ::android::hardware::sensors::V1_0::Event; using ::android::hardware::sensors::V1_0::ISensors; using ::android::hardware::sensors::V1_0::OperationMode; using ::android::hardware::sensors::V1_0::RateLevel; using ::android::hardware::sensors::V1_0::Result; using ::android::hardware::sensors::V1_0::SharedMemInfo; using ::android::hardware::sensors::V2_0::ISensorsCallback; /* * The ISensorsWrapper interface includes all function from supported Sensors HAL versions. This * allows for the SensorDevice to use the ISensorsWrapper interface to interact with the Sensors * HAL regardless of the current version of the Sensors HAL that is loaded. Each concrete * instantiation of ISensorsWrapper must correspond to a specific Sensors HAL version. This design * is beneficial because only the functions that change between Sensors HAL versions must be newly * newly implemented, any previously implemented function that does not change may remain the same. * * Functions that exist across all versions of the Sensors HAL should be implemented as pure * virtual functions which forces the concrete instantiations to implement the functions. * * Functions that do not exist across all versions of the Sensors HAL should include a default * implementation that generates an error if called. The default implementation should never * be called and must be overridden by Sensors HAL versions that support the function. */ class ISensorsWrapper : public VirtualLightRefBase { public: virtual bool supportsPolling() const = 0; virtual bool supportsMessageQueues() const = 0; virtual Return<void> getSensorsList(ISensors::getSensorsList_cb _hidl_cb) = 0; virtual Return<Result> setOperationMode(OperationMode mode) = 0; virtual Return<Result> activate(int32_t sensorHandle, bool enabled) = 0; virtual Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs, int64_t maxReportLatencyNs) = 0; virtual Return<Result> flush(int32_t sensorHandle) = 0; virtual Return<Result> injectSensorData(const Event& event) = 0; virtual Return<void> registerDirectChannel(const SharedMemInfo& mem, ISensors::registerDirectChannel_cb _hidl_cb) = 0; virtual Return<Result> unregisterDirectChannel(int32_t channelHandle) = 0; virtual Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate, ISensors::configDirectReport_cb _hidl_cb) = 0; virtual Return<void> poll(int32_t maxCount, ISensors::poll_cb _hidl_cb) { (void)maxCount; (void)_hidl_cb; // TODO (b/111070257): Generate an assert-level error since this should never be called // directly return Return<void>(); } virtual Return<Result> initialize(const MQDescriptorSync<Event>& eventQueueDesc, const MQDescriptorSync<uint32_t>& wakeLockDesc, const ::android::sp<ISensorsCallback>& callback) { (void)eventQueueDesc; (void)wakeLockDesc; (void)callback; // TODO (b/111070257): Generate an assert-level error since this should never be called // directly return Result::INVALID_OPERATION; } }; template<typename T> class SensorsWrapperBase : public ISensorsWrapper { public: SensorsWrapperBase(sp<T> sensors) : mSensors(sensors) { }; Return<void> getSensorsList(ISensors::getSensorsList_cb _hidl_cb) override { return mSensors->getSensorsList(_hidl_cb); } Return<Result> setOperationMode(OperationMode mode) override { return mSensors->setOperationMode(mode); } Return<Result> activate(int32_t sensorHandle, bool enabled) override { return mSensors->activate(sensorHandle, enabled); } Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs, int64_t maxReportLatencyNs) override { return mSensors->batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs); } Return<Result> flush(int32_t sensorHandle) override { return mSensors->flush(sensorHandle); } Return<Result> injectSensorData(const Event& event) override { return mSensors->injectSensorData(event); } Return<void> registerDirectChannel(const SharedMemInfo& mem, ISensors::registerDirectChannel_cb _hidl_cb) override { return mSensors->registerDirectChannel(mem, _hidl_cb); } Return<Result> unregisterDirectChannel(int32_t channelHandle) override { return mSensors->unregisterDirectChannel(channelHandle); } Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate, ISensors::configDirectReport_cb _hidl_cb) override { return mSensors->configDirectReport(sensorHandle, channelHandle, rate, _hidl_cb); } protected: sp<T> mSensors; }; class SensorsWrapperV1_0 : public SensorsWrapperBase<hardware::sensors::V1_0::ISensors> { public: SensorsWrapperV1_0(sp<hardware::sensors::V1_0::ISensors> sensors) : SensorsWrapperBase(sensors) { }; bool supportsPolling() const override { return true; } bool supportsMessageQueues() const override { return false; } Return<void> poll(int32_t maxCount, hardware::sensors::V1_0::ISensors::poll_cb _hidl_cb) override { return mSensors->poll(maxCount, _hidl_cb); } }; class SensorsWrapperV2_0 : public SensorsWrapperBase<hardware::sensors::V2_0::ISensors> { public: SensorsWrapperV2_0(sp<hardware::sensors::V2_0::ISensors> sensors) : SensorsWrapperBase(sensors) { }; bool supportsPolling() const override { return false; } bool supportsMessageQueues() const override { return true; } Return<Result> initialize(const MQDescriptorSync<Event>& eventQueueDesc, const MQDescriptorSync<uint32_t>& wakeLockDesc, const ::android::sp<ISensorsCallback>& callback) override { return mSensors->initialize(eventQueueDesc, wakeLockDesc, callback); } }; }; // namespace SensorServiceUtil }; // namespace android #endif // ANDROID_SENSORS_WRAPPER_H