| /* |
| * Copyright (C) 2019 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 "SubHal.h" |
| |
| #include <android/hardware/sensors/2.0/ISensors.h> |
| #include <fmq/MessageQueue.h> |
| #include <hardware_legacy/power.h> |
| #include <hidl/MQDescriptor.h> |
| #include <hidl/Status.h> |
| |
| namespace android { |
| namespace hardware { |
| namespace sensors { |
| namespace V2_0 { |
| namespace implementation { |
| |
| using ::android::sp; |
| using ::android::hardware::EventFlag; |
| using ::android::hardware::hidl_string; |
| using ::android::hardware::hidl_vec; |
| using ::android::hardware::MessageQueue; |
| using ::android::hardware::MQDescriptor; |
| using ::android::hardware::Return; |
| using ::android::hardware::Void; |
| |
| struct HalProxy : public ISensors { |
| using Event = ::android::hardware::sensors::V1_0::Event; |
| using OperationMode = ::android::hardware::sensors::V1_0::OperationMode; |
| using RateLevel = ::android::hardware::sensors::V1_0::RateLevel; |
| using Result = ::android::hardware::sensors::V1_0::Result; |
| using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo; |
| |
| HalProxy(); |
| ~HalProxy(); |
| |
| // Methods from ::android::hardware::sensors::V2_0::ISensors follow. |
| Return<void> getSensorsList(getSensorsList_cb _hidl_cb) override; |
| |
| Return<Result> setOperationMode(OperationMode mode) override; |
| |
| Return<Result> activate(int32_t sensorHandle, bool enabled) override; |
| |
| Return<Result> initialize( |
| const ::android::hardware::MQDescriptorSync<Event>& eventQueueDescriptor, |
| const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor, |
| const sp<ISensorsCallback>& sensorsCallback) override; |
| |
| Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs, |
| int64_t maxReportLatencyNs) override; |
| |
| Return<Result> flush(int32_t sensorHandle) override; |
| |
| Return<Result> injectSensorData(const Event& event) override; |
| |
| Return<void> registerDirectChannel(const SharedMemInfo& mem, |
| registerDirectChannel_cb _hidl_cb) override; |
| |
| Return<Result> unregisterDirectChannel(int32_t channelHandle) override; |
| |
| Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate, |
| configDirectReport_cb _hidl_cb) override; |
| |
| Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) override; |
| |
| // Below methods from ::android::hardware::sensors::V2_0::ISensorsCaback with a minor change |
| // to pass in the sub-HAL index. While the above methods are invoked from the sensors framework |
| // via the binder, these methods are invoked from a callback provided to sub-HALs inside the |
| // same process as the HalProxy, but potentially running on different threads. |
| Return<void> onDynamicSensorsConnected(const hidl_vec<SensorInfo>& dynamicSensorsAdded, |
| int32_t subHalIndex); |
| |
| Return<void> onDynamicSensorsDisconnected(const hidl_vec<int32_t>& dynamicSensorHandlesRemoved, |
| int32_t subHalIndex); |
| |
| private: |
| using EventMessageQueue = MessageQueue<Event, kSynchronizedReadWrite>; |
| using WakeLockMessageQueue = MessageQueue<uint32_t, kSynchronizedReadWrite>; |
| |
| /** |
| * The Event FMQ where sensor events are written |
| */ |
| std::unique_ptr<EventMessageQueue> mEventQueue; |
| |
| /** |
| * The Wake Lock FMQ that is read to determine when the framework has handled WAKE_UP events |
| */ |
| std::unique_ptr<WakeLockMessageQueue> mWakeLockQueue; |
| |
| /** |
| * Event Flag to signal to the framework when sensor events are available to be read |
| */ |
| EventFlag* mEventQueueFlag; |
| |
| /** |
| * Callback to the sensors framework to inform it that new sensors have been added or removed. |
| */ |
| sp<ISensorsCallback> mDynamicSensorsCallback; |
| }; |
| |
| } // namespace implementation |
| } // namespace V2_0 |
| } // namespace sensors |
| } // namespace hardware |
| } // namespace android |