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 #include "ConvertUtils.h"
18 #include <android-base/logging.h>
19 #include <log/log.h>
20 
21 using AidlSensorInfo = ::aidl::android::hardware::sensors::SensorInfo;
22 using AidlSensorType = ::aidl::android::hardware::sensors::SensorType;
23 using AidlEvent = ::aidl::android::hardware::sensors::Event;
24 using AidlSensorStatus = ::aidl::android::hardware::sensors::SensorStatus;
25 using ::aidl::android::hardware::sensors::AdditionalInfo;
26 using ::aidl::android::hardware::sensors::DynamicSensorInfo;
27 using ::android::hardware::sensors::V1_0::MetaDataEventType;
28 using V1_0SensorStatus = ::android::hardware::sensors::V1_0::SensorStatus;
29 using ::android::hardware::sensors::V1_0::AdditionalInfoType;
30 using V2_1SensorInfo = ::android::hardware::sensors::V2_1::SensorInfo;
31 using V2_1Event = ::android::hardware::sensors::V2_1::Event;
32 using V2_1SensorType = ::android::hardware::sensors::V2_1::SensorType;
33 
34 namespace aidl {
35 namespace android {
36 namespace hardware {
37 namespace sensors {
38 namespace implementation {
39 
convertSensorInfo(const V2_1SensorInfo & sensorInfo)40 AidlSensorInfo convertSensorInfo(const V2_1SensorInfo& sensorInfo) {
41     AidlSensorInfo aidlSensorInfo;
42     aidlSensorInfo.sensorHandle = sensorInfo.sensorHandle;
43     aidlSensorInfo.name = sensorInfo.name;
44     aidlSensorInfo.vendor = sensorInfo.vendor;
45     aidlSensorInfo.version = sensorInfo.version;
46     aidlSensorInfo.type = (AidlSensorType)sensorInfo.type;
47     aidlSensorInfo.typeAsString = sensorInfo.typeAsString;
48     aidlSensorInfo.maxRange = sensorInfo.maxRange;
49     aidlSensorInfo.resolution = sensorInfo.resolution;
50     aidlSensorInfo.power = sensorInfo.power;
51     aidlSensorInfo.minDelayUs = sensorInfo.minDelay;
52     aidlSensorInfo.fifoReservedEventCount = sensorInfo.fifoReservedEventCount;
53     aidlSensorInfo.fifoMaxEventCount = sensorInfo.fifoMaxEventCount;
54     aidlSensorInfo.requiredPermission = sensorInfo.requiredPermission;
55     aidlSensorInfo.maxDelayUs = sensorInfo.maxDelay;
56     aidlSensorInfo.flags = sensorInfo.flags;
57     return aidlSensorInfo;
58 }
59 
convertToHidlEvent(const AidlEvent & aidlEvent,V2_1Event * hidlEvent)60 void convertToHidlEvent(const AidlEvent& aidlEvent, V2_1Event* hidlEvent) {
61     static_assert(decltype(hidlEvent->u.data)::elementCount() == 16);
62     hidlEvent->timestamp = aidlEvent.timestamp;
63     hidlEvent->sensorHandle = aidlEvent.sensorHandle;
64     hidlEvent->sensorType = (V2_1SensorType)aidlEvent.sensorType;
65 
66     switch (aidlEvent.sensorType) {
67         case AidlSensorType::META_DATA:
68             hidlEvent->u.meta.what =
69                     (MetaDataEventType)aidlEvent.payload.get<Event::EventPayload::meta>().what;
70             break;
71         case AidlSensorType::ACCELEROMETER:
72         case AidlSensorType::MAGNETIC_FIELD:
73         case AidlSensorType::ORIENTATION:
74         case AidlSensorType::GYROSCOPE:
75         case AidlSensorType::GRAVITY:
76         case AidlSensorType::LINEAR_ACCELERATION:
77             hidlEvent->u.vec3.x = aidlEvent.payload.get<Event::EventPayload::vec3>().x;
78             hidlEvent->u.vec3.y = aidlEvent.payload.get<Event::EventPayload::vec3>().y;
79             hidlEvent->u.vec3.z = aidlEvent.payload.get<Event::EventPayload::vec3>().z;
80             hidlEvent->u.vec3.status =
81                     (V1_0SensorStatus)aidlEvent.payload.get<Event::EventPayload::vec3>().status;
82             break;
83         case AidlSensorType::GAME_ROTATION_VECTOR:
84             hidlEvent->u.vec4.x = aidlEvent.payload.get<Event::EventPayload::vec4>().x;
85             hidlEvent->u.vec4.y = aidlEvent.payload.get<Event::EventPayload::vec4>().y;
86             hidlEvent->u.vec4.z = aidlEvent.payload.get<Event::EventPayload::vec4>().z;
87             hidlEvent->u.vec4.w = aidlEvent.payload.get<Event::EventPayload::vec4>().w;
88             break;
89         case AidlSensorType::ROTATION_VECTOR:
90         case AidlSensorType::GEOMAGNETIC_ROTATION_VECTOR:
91             std::copy(aidlEvent.payload.get<Event::EventPayload::data>().values.data(),
92                       aidlEvent.payload.get<Event::EventPayload::data>().values.data() + 5,
93                       hidlEvent->u.data.data());
94             break;
95         case AidlSensorType::ACCELEROMETER_UNCALIBRATED:
96         case AidlSensorType::MAGNETIC_FIELD_UNCALIBRATED:
97         case AidlSensorType::GYROSCOPE_UNCALIBRATED:
98             hidlEvent->u.uncal.x = aidlEvent.payload.get<Event::EventPayload::uncal>().x;
99             hidlEvent->u.uncal.y = aidlEvent.payload.get<Event::EventPayload::uncal>().y;
100             hidlEvent->u.uncal.z = aidlEvent.payload.get<Event::EventPayload::uncal>().z;
101             hidlEvent->u.uncal.x_bias = aidlEvent.payload.get<Event::EventPayload::uncal>().xBias;
102             hidlEvent->u.uncal.y_bias = aidlEvent.payload.get<Event::EventPayload::uncal>().yBias;
103             hidlEvent->u.uncal.z_bias = aidlEvent.payload.get<Event::EventPayload::uncal>().zBias;
104             break;
105         case AidlSensorType::DEVICE_ORIENTATION:
106         case AidlSensorType::LIGHT:
107         case AidlSensorType::PRESSURE:
108         case AidlSensorType::PROXIMITY:
109         case AidlSensorType::RELATIVE_HUMIDITY:
110         case AidlSensorType::AMBIENT_TEMPERATURE:
111         case AidlSensorType::SIGNIFICANT_MOTION:
112         case AidlSensorType::STEP_DETECTOR:
113         case AidlSensorType::TILT_DETECTOR:
114         case AidlSensorType::WAKE_GESTURE:
115         case AidlSensorType::GLANCE_GESTURE:
116         case AidlSensorType::PICK_UP_GESTURE:
117         case AidlSensorType::WRIST_TILT_GESTURE:
118         case AidlSensorType::STATIONARY_DETECT:
119         case AidlSensorType::MOTION_DETECT:
120         case AidlSensorType::HEART_BEAT:
121         case AidlSensorType::LOW_LATENCY_OFFBODY_DETECT:
122         case AidlSensorType::HINGE_ANGLE:
123             hidlEvent->u.scalar = aidlEvent.payload.get<Event::EventPayload::scalar>();
124             break;
125         case AidlSensorType::STEP_COUNTER:
126             hidlEvent->u.stepCount = aidlEvent.payload.get<AidlEvent::EventPayload::stepCount>();
127             break;
128         case AidlSensorType::HEART_RATE:
129             hidlEvent->u.heartRate.bpm =
130                     aidlEvent.payload.get<AidlEvent::EventPayload::heartRate>().bpm;
131             hidlEvent->u.heartRate.status =
132                     (V1_0SensorStatus)aidlEvent.payload.get<Event::EventPayload::heartRate>()
133                             .status;
134             break;
135         case AidlSensorType::POSE_6DOF:
136             std::copy(std::begin(aidlEvent.payload.get<AidlEvent::EventPayload::pose6DOF>().values),
137                       std::end(aidlEvent.payload.get<AidlEvent::EventPayload::pose6DOF>().values),
138                       hidlEvent->u.pose6DOF.data());
139             break;
140         case AidlSensorType::DYNAMIC_SENSOR_META:
141             hidlEvent->u.dynamic.connected =
142                     aidlEvent.payload.get<Event::EventPayload::dynamic>().connected;
143             hidlEvent->u.dynamic.sensorHandle =
144                     aidlEvent.payload.get<Event::EventPayload::dynamic>().sensorHandle;
145             std::copy(
146                     std::begin(
147                             aidlEvent.payload.get<AidlEvent::EventPayload::dynamic>().uuid.values),
148                     std::end(aidlEvent.payload.get<AidlEvent::EventPayload::dynamic>().uuid.values),
149                     hidlEvent->u.dynamic.uuid.data());
150             break;
151         case AidlSensorType::ADDITIONAL_INFO: {
152             const AdditionalInfo& additionalInfo =
153                     aidlEvent.payload.get<AidlEvent::EventPayload::additional>();
154             hidlEvent->u.additional.type = (AdditionalInfoType)additionalInfo.type;
155             hidlEvent->u.additional.serial = additionalInfo.serial;
156 
157             switch (additionalInfo.payload.getTag()) {
158                 case AdditionalInfo::AdditionalInfoPayload::Tag::dataInt32: {
159                     const auto& aidlData =
160                             additionalInfo.payload
161                                     .get<AdditionalInfo::AdditionalInfoPayload::dataInt32>()
162                                     .values;
163                     std::copy(std::begin(aidlData), std::end(aidlData),
164                               hidlEvent->u.additional.u.data_int32.data());
165                     break;
166                 }
167                 case AdditionalInfo::AdditionalInfoPayload::Tag::dataFloat: {
168                     const auto& aidlData =
169                             additionalInfo.payload
170                                     .get<AdditionalInfo::AdditionalInfoPayload::dataFloat>()
171                                     .values;
172                     std::copy(std::begin(aidlData), std::end(aidlData),
173                               hidlEvent->u.additional.u.data_float.data());
174                     break;
175                 }
176                 default:
177                     ALOGE("Invalid sensor additioanl info tag: %d",
178                           static_cast<int32_t>(additionalInfo.payload.getTag()));
179                     break;
180             }
181             break;
182         }
183         case AidlSensorType::HEAD_TRACKER: {
184             const auto& ht = aidlEvent.payload.get<Event::EventPayload::headTracker>();
185             hidlEvent->u.data[0] = ht.rx;
186             hidlEvent->u.data[1] = ht.ry;
187             hidlEvent->u.data[2] = ht.rz;
188             hidlEvent->u.data[3] = ht.vx;
189             hidlEvent->u.data[4] = ht.vy;
190             hidlEvent->u.data[5] = ht.vz;
191 
192             // IMPORTANT: Because we want to preserve the data range of discontinuityCount,
193             // we assume the data can be interpreted as an int32_t directly (e.g. the underlying
194             // HIDL HAL must be using memcpy or equivalent to store this value).
195             *(reinterpret_cast<int32_t*>(&hidlEvent->u.data[6])) = ht.discontinuityCount;
196             break;
197         }
198         default: {
199             CHECK_GE((int32_t)aidlEvent.sensorType, (int32_t)SensorType::DEVICE_PRIVATE_BASE);
200             std::copy(std::begin(aidlEvent.payload.get<AidlEvent::EventPayload::data>().values),
201                       std::end(aidlEvent.payload.get<AidlEvent::EventPayload::data>().values),
202                       hidlEvent->u.data.data());
203             break;
204         }
205     }
206 }
207 
convertToAidlEvent(const V2_1Event & hidlEvent,AidlEvent * aidlEvent)208 void convertToAidlEvent(const V2_1Event& hidlEvent, AidlEvent* aidlEvent) {
209     static_assert(decltype(hidlEvent.u.data)::elementCount() == 16);
210     aidlEvent->timestamp = hidlEvent.timestamp;
211     aidlEvent->sensorHandle = hidlEvent.sensorHandle;
212     aidlEvent->sensorType = (AidlSensorType)hidlEvent.sensorType;
213     switch (hidlEvent.sensorType) {
214         case V2_1SensorType::META_DATA: {
215             AidlEvent::EventPayload::MetaData meta;
216             meta.what = (Event::EventPayload::MetaData::MetaDataEventType)hidlEvent.u.meta.what;
217             aidlEvent->payload.set<Event::EventPayload::meta>(meta);
218             break;
219         }
220         case V2_1SensorType::ACCELEROMETER:
221         case V2_1SensorType::MAGNETIC_FIELD:
222         case V2_1SensorType::ORIENTATION:
223         case V2_1SensorType::GYROSCOPE:
224         case V2_1SensorType::GRAVITY:
225         case V2_1SensorType::LINEAR_ACCELERATION: {
226             AidlEvent::EventPayload::Vec3 vec3;
227             vec3.x = hidlEvent.u.vec3.x;
228             vec3.y = hidlEvent.u.vec3.y;
229             vec3.z = hidlEvent.u.vec3.z;
230             vec3.status = (SensorStatus)hidlEvent.u.vec3.status;
231             aidlEvent->payload.set<Event::EventPayload::vec3>(vec3);
232             break;
233         }
234         case V2_1SensorType::GAME_ROTATION_VECTOR: {
235             AidlEvent::EventPayload::Vec4 vec4;
236             vec4.x = hidlEvent.u.vec4.x;
237             vec4.y = hidlEvent.u.vec4.y;
238             vec4.z = hidlEvent.u.vec4.z;
239             vec4.w = hidlEvent.u.vec4.w;
240             aidlEvent->payload.set<Event::EventPayload::vec4>(vec4);
241             break;
242         }
243         case V2_1SensorType::ROTATION_VECTOR:
244         case V2_1SensorType::GEOMAGNETIC_ROTATION_VECTOR: {
245             AidlEvent::EventPayload::Data data;
246             std::copy(hidlEvent.u.data.data(), hidlEvent.u.data.data() + 5,
247                       std::begin(data.values));
248             aidlEvent->payload.set<Event::EventPayload::data>(data);
249             break;
250         }
251         case V2_1SensorType::MAGNETIC_FIELD_UNCALIBRATED:
252         case V2_1SensorType::GYROSCOPE_UNCALIBRATED:
253         case V2_1SensorType::ACCELEROMETER_UNCALIBRATED: {
254             AidlEvent::EventPayload::Uncal uncal;
255             uncal.x = hidlEvent.u.uncal.x;
256             uncal.y = hidlEvent.u.uncal.y;
257             uncal.z = hidlEvent.u.uncal.z;
258             uncal.xBias = hidlEvent.u.uncal.x_bias;
259             uncal.yBias = hidlEvent.u.uncal.y_bias;
260             uncal.zBias = hidlEvent.u.uncal.z_bias;
261             aidlEvent->payload.set<Event::EventPayload::uncal>(uncal);
262             break;
263         }
264         case V2_1SensorType::DEVICE_ORIENTATION:
265         case V2_1SensorType::LIGHT:
266         case V2_1SensorType::PRESSURE:
267         case V2_1SensorType::PROXIMITY:
268         case V2_1SensorType::RELATIVE_HUMIDITY:
269         case V2_1SensorType::AMBIENT_TEMPERATURE:
270         case V2_1SensorType::SIGNIFICANT_MOTION:
271         case V2_1SensorType::STEP_DETECTOR:
272         case V2_1SensorType::TILT_DETECTOR:
273         case V2_1SensorType::WAKE_GESTURE:
274         case V2_1SensorType::GLANCE_GESTURE:
275         case V2_1SensorType::PICK_UP_GESTURE:
276         case V2_1SensorType::WRIST_TILT_GESTURE:
277         case V2_1SensorType::STATIONARY_DETECT:
278         case V2_1SensorType::MOTION_DETECT:
279         case V2_1SensorType::HEART_BEAT:
280         case V2_1SensorType::LOW_LATENCY_OFFBODY_DETECT:
281         case V2_1SensorType::HINGE_ANGLE:
282             aidlEvent->payload.set<Event::EventPayload::scalar>(hidlEvent.u.scalar);
283             break;
284         case V2_1SensorType::STEP_COUNTER:
285             aidlEvent->payload.set<Event::EventPayload::stepCount>(hidlEvent.u.stepCount);
286             break;
287         case V2_1SensorType::HEART_RATE: {
288             AidlEvent::EventPayload::HeartRate heartRate;
289             heartRate.bpm = hidlEvent.u.heartRate.bpm;
290             heartRate.status = (SensorStatus)hidlEvent.u.heartRate.status;
291             aidlEvent->payload.set<Event::EventPayload::heartRate>(heartRate);
292             break;
293         }
294         case V2_1SensorType::POSE_6DOF: {
295             AidlEvent::EventPayload::Pose6Dof pose6Dof;
296             std::copy(hidlEvent.u.pose6DOF.data(),
297                       hidlEvent.u.pose6DOF.data() + hidlEvent.u.pose6DOF.size(),
298                       std::begin(pose6Dof.values));
299             aidlEvent->payload.set<Event::EventPayload::pose6DOF>(pose6Dof);
300             break;
301         }
302         case V2_1SensorType::DYNAMIC_SENSOR_META: {
303             DynamicSensorInfo dynamicSensorInfo;
304             dynamicSensorInfo.connected = hidlEvent.u.dynamic.connected;
305             dynamicSensorInfo.sensorHandle = hidlEvent.u.dynamic.sensorHandle;
306             std::copy(hidlEvent.u.dynamic.uuid.data(),
307                       hidlEvent.u.dynamic.uuid.data() + hidlEvent.u.dynamic.uuid.size(),
308                       std::begin(dynamicSensorInfo.uuid.values));
309             aidlEvent->payload.set<Event::EventPayload::dynamic>(dynamicSensorInfo);
310             break;
311         }
312         case V2_1SensorType::ADDITIONAL_INFO: {
313             AdditionalInfo additionalInfo;
314             additionalInfo.type = (AdditionalInfo::AdditionalInfoType)hidlEvent.u.additional.type;
315             additionalInfo.serial = hidlEvent.u.additional.serial;
316 
317             AdditionalInfo::AdditionalInfoPayload::Int32Values int32Values;
318             std::copy(hidlEvent.u.additional.u.data_int32.data(),
319                       hidlEvent.u.additional.u.data_int32.data() +
320                               hidlEvent.u.additional.u.data_int32.size(),
321                       std::begin(int32Values.values));
322             additionalInfo.payload.set<AdditionalInfo::AdditionalInfoPayload::dataInt32>(
323                     int32Values);
324             aidlEvent->payload.set<Event::EventPayload::additional>(additionalInfo);
325             break;
326         }
327         default: {
328             if (static_cast<int32_t>(hidlEvent.sensorType) ==
329                 static_cast<int32_t>(AidlSensorType::HEAD_TRACKER)) {
330                 Event::EventPayload::HeadTracker headTracker;
331                 headTracker.rx = hidlEvent.u.data[0];
332                 headTracker.ry = hidlEvent.u.data[1];
333                 headTracker.rz = hidlEvent.u.data[2];
334                 headTracker.vx = hidlEvent.u.data[3];
335                 headTracker.vy = hidlEvent.u.data[4];
336                 headTracker.vz = hidlEvent.u.data[5];
337 
338                 // IMPORTANT: Because we want to preserve the data range of discontinuityCount,
339                 // we assume the data can be interpreted as an int32_t directly (e.g. the underlying
340                 // HIDL HAL must be using memcpy or equivalent to store this value).
341                 headTracker.discontinuityCount =
342                         *(reinterpret_cast<const int32_t*>(&hidlEvent.u.data[6]));
343 
344                 aidlEvent->payload.set<Event::EventPayload::Tag::headTracker>(headTracker);
345             } else {
346                 CHECK_GE((int32_t)hidlEvent.sensorType,
347                          (int32_t)V2_1SensorType::DEVICE_PRIVATE_BASE);
348                 AidlEvent::EventPayload::Data data;
349                 std::copy(hidlEvent.u.data.data(),
350                           hidlEvent.u.data.data() + hidlEvent.u.data.size(),
351                           std::begin(data.values));
352                 aidlEvent->payload.set<Event::EventPayload::data>(data);
353             }
354             break;
355         }
356     }
357 }
358 
359 }  // namespace implementation
360 }  // namespace sensors
361 }  // namespace hardware
362 }  // namespace android
363 }  // namespace aidl
364