• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef ANDROID_HIDL_SENSOR_HAL_WRAPPER_H
18 #define ANDROID_HIDL_SENSOR_HAL_WRAPPER_H
19 
20 #include <sensor/SensorEventQueue.h>
21 #include <utils/Singleton.h>
22 
23 #include "ISensorHalWrapper.h"
24 
25 #include "ISensorsWrapper.h"
26 #include "SensorDeviceUtils.h"
27 
28 namespace android {
29 
30 using android::hardware::sensors::V1_0::Result;
31 using android::hardware::sensors::V2_1::Event;
32 using android::hardware::sensors::V2_1::SensorInfo;
33 
34 class HidlTransportErrorLog {
35 public:
HidlTransportErrorLog()36     HidlTransportErrorLog() {
37         mTs = 0;
38         mCount = 0;
39     }
40 
HidlTransportErrorLog(time_t ts,int count)41     HidlTransportErrorLog(time_t ts, int count) {
42         mTs = ts;
43         mCount = count;
44     }
45 
toString()46     String8 toString() const {
47         String8 result;
48         struct tm* timeInfo = localtime(&mTs);
49         result.appendFormat("%02d:%02d:%02d :: %d", timeInfo->tm_hour, timeInfo->tm_min,
50                             timeInfo->tm_sec, mCount);
51         return result;
52     }
53 
54 private:
55     time_t mTs; // timestamp of the error
56     int mCount; // number of transport errors observed
57 };
58 
59 class SensorsHalDeathReceiver : public android::hardware::hidl_death_recipient {
60 public:
SensorsHalDeathReceiver(ISensorHalWrapper * wrapper)61     SensorsHalDeathReceiver(ISensorHalWrapper* wrapper) : mHidlSensorHalWrapper(wrapper) {}
62 
63     virtual void serviceDied(uint64_t cookie,
64                              const wp<::android::hidl::base::V1_0::IBase>& service) override;
65 
66 private:
67     ISensorHalWrapper* mHidlSensorHalWrapper;
68 };
69 
70 class HidlSensorHalWrapper : public ISensorHalWrapper {
71 public:
HidlSensorHalWrapper()72     HidlSensorHalWrapper()
73           : mHidlTransportErrors(20),
74             mTotalHidlTransportErrors(0),
75             mRestartWaiter(new SensorDeviceUtils::HidlServiceRegistrationWaiter()),
76             mEventQueueFlag(nullptr),
77             mWakeLockQueueFlag(nullptr) {}
78 
~HidlSensorHalWrapper()79     ~HidlSensorHalWrapper() override {
80         if (mEventQueueFlag != nullptr) {
81             hardware::EventFlag::deleteEventFlag(&mEventQueueFlag);
82             mEventQueueFlag = nullptr;
83         }
84         if (mWakeLockQueueFlag != nullptr) {
85             hardware::EventFlag::deleteEventFlag(&mWakeLockQueueFlag);
86             mWakeLockQueueFlag = nullptr;
87         }
88     }
89     virtual bool connect(SensorDeviceCallback* callback) override;
90 
91     virtual void prepareForReconnect() override;
92 
93     virtual bool supportsPolling() override;
94 
95     virtual bool supportsMessageQueues() override;
96 
97     virtual ssize_t poll(sensors_event_t* buffer, size_t count) override;
98 
99     virtual ssize_t pollFmq(sensors_event_t* buffer, size_t count) override;
100 
101     virtual std::vector<sensor_t> getSensorsList() override;
102 
103     virtual status_t setOperationMode(SensorService::Mode mode) override;
104 
105     virtual status_t activate(int32_t sensorHandle, bool enabled) override;
106 
107     virtual status_t batch(int32_t sensorHandle, int64_t samplingPeriodNs,
108                            int64_t maxReportLatencyNs) override;
109 
110     virtual status_t flush(int32_t sensorHandle) override;
111 
112     virtual status_t injectSensorData(const sensors_event_t* event) override;
113 
114     virtual status_t registerDirectChannel(const sensors_direct_mem_t* memory,
115                                            int32_t* outChannelHandle) override;
116 
117     virtual status_t unregisterDirectChannel(int32_t channelHandle) override;
118 
119     virtual status_t configureDirectChannel(int32_t sensorHandle, int32_t channelHandle,
120                                             const struct sensors_direct_cfg_t* config) override;
121 
122     virtual void writeWakeLockHandled(uint32_t count) override;
123 
124 private:
125     sp<::android::hardware::sensors::V2_1::implementation::ISensorsWrapperBase> mSensors;
126     sp<::android::hardware::sensors::V2_1::ISensorsCallback> mCallback;
127 
128     // Keep track of any hidl transport failures
129     SensorServiceUtil::RingBuffer<HidlTransportErrorLog> mHidlTransportErrors;
130     int mTotalHidlTransportErrors;
131 
132     SensorDeviceCallback* mSensorDeviceCallback = nullptr;
133 
134     // TODO(b/67425500): remove waiter after bug is resolved.
135     sp<SensorDeviceUtils::HidlServiceRegistrationWaiter> mRestartWaiter;
136 
137     template <typename T>
checkReturn(const hardware::Return<T> & ret)138     void checkReturn(const hardware::Return<T>& ret) {
139         if (!ret.isOk()) {
140             handleHidlDeath(ret.description());
141         }
142     }
143 
144     status_t checkReturnAndGetStatus(const hardware::Return<Result>& ret);
145 
146     void handleHidlDeath(const std::string& detail);
147 
148     void convertToSensorEvent(const Event& src, sensors_event_t* dst);
149 
150     void convertToSensorEvents(const hardware::hidl_vec<Event>& src,
151                                const hardware::hidl_vec<SensorInfo>& dynamicSensorsAdded,
152                                sensors_event_t* dst);
153 
154     bool connectHidlService();
155 
156     HalConnectionStatus connectHidlServiceV1_0();
157     HalConnectionStatus connectHidlServiceV2_0();
158     HalConnectionStatus connectHidlServiceV2_1();
159     HalConnectionStatus initializeHidlServiceV2_X();
160 
161     typedef hardware::MessageQueue<uint32_t, hardware::kSynchronizedReadWrite> WakeLockQueue;
162     std::unique_ptr<WakeLockQueue> mWakeLockQueue;
163 
164     hardware::EventFlag* mEventQueueFlag;
165     hardware::EventFlag* mWakeLockQueueFlag;
166 
167     std::array<Event, SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT> mEventBuffer;
168 
169     sp<SensorsHalDeathReceiver> mSensorsHalDeathReceiver;
170 };
171 
172 } // namespace android
173 
174 #endif // ANDROID_HIDL_SENSOR_HAL_WRAPPER_H
175