1 /*
2  * Copyright (C) 2016 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 "convert.h"
18 
19 #include <android-base/logging.h>
20 
21 namespace android {
22 namespace hardware {
23 namespace sensors {
24 namespace V1_0 {
25 namespace implementation {
26 
convertFromSensor(const sensor_t & src,SensorInfo * dst)27 void convertFromSensor(const sensor_t &src, SensorInfo *dst) {
28     dst->name = src.name;
29     dst->vendor = src.vendor;
30     dst->version = src.version;
31     dst->sensorHandle = src.handle;
32     dst->type = (SensorType)src.type;
33     dst->maxRange = src.maxRange;
34     dst->resolution = src.resolution;
35     dst->power = src.power;
36     dst->minDelay = src.minDelay;
37     dst->fifoReservedEventCount = src.fifoReservedEventCount;
38     dst->fifoMaxEventCount = src.fifoMaxEventCount;
39     dst->typeAsString = src.stringType;
40     dst->requiredPermission = src.requiredPermission;
41     dst->maxDelay = src.maxDelay;
42     dst->flags = src.flags;
43 }
44 
convertToSensor(const::android::hardware::sensors::V1_0::SensorInfo & src,sensor_t * dst)45 void convertToSensor(
46         const ::android::hardware::sensors::V1_0::SensorInfo &src,
47         sensor_t *dst) {
48     dst->name = strdup(src.name.c_str());
49     dst->vendor = strdup(src.vendor.c_str());
50     dst->version = src.version;
51     dst->handle = src.sensorHandle;
52     dst->type = (int)src.type;
53     dst->maxRange = src.maxRange;
54     dst->resolution = src.resolution;
55     dst->power = src.power;
56     dst->minDelay = src.minDelay;
57     dst->fifoReservedEventCount = src.fifoReservedEventCount;
58     dst->fifoMaxEventCount = src.fifoMaxEventCount;
59     dst->stringType = strdup(src.typeAsString.c_str());
60     dst->requiredPermission = strdup(src.requiredPermission.c_str());
61     dst->maxDelay = src.maxDelay;
62     dst->flags = src.flags;
63     dst->reserved[0] = dst->reserved[1] = 0;
64 }
65 
convertFromSensorEvent(const sensors_event_t & src,Event * dst)66 void convertFromSensorEvent(const sensors_event_t &src, Event *dst) {
67     typedef ::android::hardware::sensors::V1_0::SensorType SensorType;
68     typedef ::android::hardware::sensors::V1_0::MetaDataEventType MetaDataEventType;
69 
70     *dst = {
71             .timestamp = src.timestamp,
72             .sensorHandle = src.sensor,
73             .sensorType = (SensorType)src.type,
74     };
75 
76     switch (dst->sensorType) {
77         case SensorType::META_DATA: {
78             dst->u.meta.what = (MetaDataEventType)src.meta_data.what;
79             // Legacy HALs contain the handle reference in the meta data field.
80             // Copy that over to the handle of the event. In legacy HALs this
81             // field was expected to be 0.
82             dst->sensorHandle = src.meta_data.sensor;
83             break;
84         }
85 
86         case SensorType::ACCELEROMETER:
87         case SensorType::MAGNETIC_FIELD:
88         case SensorType::ORIENTATION:
89         case SensorType::GYROSCOPE:
90         case SensorType::GRAVITY:
91         case SensorType::LINEAR_ACCELERATION: {
92             dst->u.vec3.x = src.acceleration.x;
93             dst->u.vec3.y = src.acceleration.y;
94             dst->u.vec3.z = src.acceleration.z;
95             dst->u.vec3.status = (SensorStatus)src.acceleration.status;
96             break;
97         }
98 
99         case SensorType::GAME_ROTATION_VECTOR: {
100             dst->u.vec4.x = src.data[0];
101             dst->u.vec4.y = src.data[1];
102             dst->u.vec4.z = src.data[2];
103             dst->u.vec4.w = src.data[3];
104             break;
105         }
106 
107         case SensorType::ROTATION_VECTOR:
108         case SensorType::GEOMAGNETIC_ROTATION_VECTOR: {
109             dst->u.data[0] = src.data[0];
110             dst->u.data[1] = src.data[1];
111             dst->u.data[2] = src.data[2];
112             dst->u.data[3] = src.data[3];
113             dst->u.data[4] = src.data[4];
114             break;
115         }
116 
117         case SensorType::MAGNETIC_FIELD_UNCALIBRATED:
118         case SensorType::GYROSCOPE_UNCALIBRATED:
119         case SensorType::ACCELEROMETER_UNCALIBRATED: {
120             dst->u.uncal.x = src.uncalibrated_gyro.x_uncalib;
121             dst->u.uncal.y = src.uncalibrated_gyro.y_uncalib;
122             dst->u.uncal.z = src.uncalibrated_gyro.z_uncalib;
123             dst->u.uncal.x_bias = src.uncalibrated_gyro.x_bias;
124             dst->u.uncal.y_bias = src.uncalibrated_gyro.y_bias;
125             dst->u.uncal.z_bias = src.uncalibrated_gyro.z_bias;
126             break;
127         }
128 
129         case SensorType::DEVICE_ORIENTATION:
130         case SensorType::LIGHT:
131         case SensorType::PRESSURE:
132         case SensorType::TEMPERATURE:
133         case SensorType::PROXIMITY:
134         case SensorType::RELATIVE_HUMIDITY:
135         case SensorType::AMBIENT_TEMPERATURE:
136         case SensorType::SIGNIFICANT_MOTION:
137         case SensorType::STEP_DETECTOR:
138         case SensorType::TILT_DETECTOR:
139         case SensorType::WAKE_GESTURE:
140         case SensorType::GLANCE_GESTURE:
141         case SensorType::PICK_UP_GESTURE:
142         case SensorType::WRIST_TILT_GESTURE:
143         case SensorType::STATIONARY_DETECT:
144         case SensorType::MOTION_DETECT:
145         case SensorType::HEART_BEAT:
146         case SensorType::LOW_LATENCY_OFFBODY_DETECT: {
147             dst->u.scalar = src.data[0];
148             break;
149         }
150 
151         case SensorType::STEP_COUNTER: {
152             dst->u.stepCount = src.u64.step_counter;
153             break;
154         }
155 
156         case SensorType::HEART_RATE: {
157             dst->u.heartRate.bpm = src.heart_rate.bpm;
158             dst->u.heartRate.status = (SensorStatus)src.heart_rate.status;
159             break;
160         }
161 
162         case SensorType::POSE_6DOF: {  // 15 floats
163             for (size_t i = 0; i < 15; ++i) {
164                 dst->u.pose6DOF[i] = src.data[i];
165             }
166             break;
167         }
168 
169         case SensorType::DYNAMIC_SENSOR_META: {
170             dst->u.dynamic.connected = src.dynamic_sensor_meta.connected;
171             dst->u.dynamic.sensorHandle = src.dynamic_sensor_meta.handle;
172 
173             memcpy(dst->u.dynamic.uuid.data(), src.dynamic_sensor_meta.uuid, 16);
174 
175             break;
176         }
177 
178         case SensorType::ADDITIONAL_INFO: {
179             ::android::hardware::sensors::V1_0::AdditionalInfo* dstInfo = &dst->u.additional;
180 
181             const additional_info_event_t& srcInfo = src.additional_info;
182 
183             dstInfo->type = (::android::hardware::sensors::V1_0::AdditionalInfoType)srcInfo.type;
184 
185             dstInfo->serial = srcInfo.serial;
186 
187             CHECK_EQ(sizeof(dstInfo->u), sizeof(srcInfo.data_int32));
188             memcpy(&dstInfo->u, srcInfo.data_int32, sizeof(srcInfo.data_int32));
189             break;
190         }
191 
192         default: {
193             CHECK_GE((int32_t)dst->sensorType, (int32_t)SensorType::DEVICE_PRIVATE_BASE);
194 
195             memcpy(dst->u.data.data(), src.data, 16 * sizeof(float));
196             break;
197         }
198     }
199 }
200 
convertToSensorEvent(const Event & src,sensors_event_t * dst)201 void convertToSensorEvent(const Event &src, sensors_event_t *dst) {
202     *dst = {.version = sizeof(sensors_event_t),
203             .sensor = src.sensorHandle,
204             .type = (int32_t)src.sensorType,
205             .reserved0 = 0,
206             .timestamp = src.timestamp};
207 
208     switch (src.sensorType) {
209         case SensorType::META_DATA: {
210             // Legacy HALs expect the handle reference in the meta data field.
211             // Copy it over from the handle of the event.
212             dst->meta_data.what = (int32_t)src.u.meta.what;
213             dst->meta_data.sensor = src.sensorHandle;
214             // Set the sensor handle to 0 to maintain compatibility.
215             dst->sensor = 0;
216             break;
217         }
218 
219         case SensorType::ACCELEROMETER:
220         case SensorType::MAGNETIC_FIELD:
221         case SensorType::ORIENTATION:
222         case SensorType::GYROSCOPE:
223         case SensorType::GRAVITY:
224         case SensorType::LINEAR_ACCELERATION: {
225             dst->acceleration.x = src.u.vec3.x;
226             dst->acceleration.y = src.u.vec3.y;
227             dst->acceleration.z = src.u.vec3.z;
228             dst->acceleration.status = (int8_t)src.u.vec3.status;
229             break;
230         }
231 
232         case SensorType::GAME_ROTATION_VECTOR: {
233             dst->data[0] = src.u.vec4.x;
234             dst->data[1] = src.u.vec4.y;
235             dst->data[2] = src.u.vec4.z;
236             dst->data[3] = src.u.vec4.w;
237             break;
238         }
239 
240         case SensorType::ROTATION_VECTOR:
241         case SensorType::GEOMAGNETIC_ROTATION_VECTOR: {
242             dst->data[0] = src.u.data[0];
243             dst->data[1] = src.u.data[1];
244             dst->data[2] = src.u.data[2];
245             dst->data[3] = src.u.data[3];
246             dst->data[4] = src.u.data[4];
247             break;
248         }
249 
250         case SensorType::MAGNETIC_FIELD_UNCALIBRATED:
251         case SensorType::GYROSCOPE_UNCALIBRATED:
252         case SensorType::ACCELEROMETER_UNCALIBRATED:
253         {
254             dst->uncalibrated_gyro.x_uncalib = src.u.uncal.x;
255             dst->uncalibrated_gyro.y_uncalib = src.u.uncal.y;
256             dst->uncalibrated_gyro.z_uncalib = src.u.uncal.z;
257             dst->uncalibrated_gyro.x_bias = src.u.uncal.x_bias;
258             dst->uncalibrated_gyro.y_bias = src.u.uncal.y_bias;
259             dst->uncalibrated_gyro.z_bias = src.u.uncal.z_bias;
260             break;
261         }
262 
263         case SensorType::DEVICE_ORIENTATION:
264         case SensorType::LIGHT:
265         case SensorType::PRESSURE:
266         case SensorType::TEMPERATURE:
267         case SensorType::PROXIMITY:
268         case SensorType::RELATIVE_HUMIDITY:
269         case SensorType::AMBIENT_TEMPERATURE:
270         case SensorType::SIGNIFICANT_MOTION:
271         case SensorType::STEP_DETECTOR:
272         case SensorType::TILT_DETECTOR:
273         case SensorType::WAKE_GESTURE:
274         case SensorType::GLANCE_GESTURE:
275         case SensorType::PICK_UP_GESTURE:
276         case SensorType::WRIST_TILT_GESTURE:
277         case SensorType::STATIONARY_DETECT:
278         case SensorType::MOTION_DETECT:
279         case SensorType::HEART_BEAT:
280         case SensorType::LOW_LATENCY_OFFBODY_DETECT: {
281             dst->data[0] = src.u.scalar;
282             break;
283         }
284 
285         case SensorType::STEP_COUNTER: {
286             dst->u64.step_counter = src.u.stepCount;
287             break;
288         }
289 
290         case SensorType::HEART_RATE: {
291             dst->heart_rate.bpm = src.u.heartRate.bpm;
292             dst->heart_rate.status = (int8_t)src.u.heartRate.status;
293             break;
294         }
295 
296         case SensorType::POSE_6DOF: {  // 15 floats
297             for (size_t i = 0; i < 15; ++i) {
298                 dst->data[i] = src.u.pose6DOF[i];
299             }
300             break;
301         }
302 
303         case SensorType::DYNAMIC_SENSOR_META: {
304             dst->dynamic_sensor_meta.connected = src.u.dynamic.connected;
305             dst->dynamic_sensor_meta.handle = src.u.dynamic.sensorHandle;
306             dst->dynamic_sensor_meta.sensor = NULL;  // to be filled in later
307 
308             memcpy(dst->dynamic_sensor_meta.uuid,
309                    src.u.dynamic.uuid.data(),
310                    16);
311 
312             break;
313         }
314 
315         case SensorType::ADDITIONAL_INFO: {
316             const ::android::hardware::sensors::V1_0::AdditionalInfo &srcInfo =
317                 src.u.additional;
318 
319             additional_info_event_t *dstInfo = &dst->additional_info;
320             dstInfo->type = (int32_t)srcInfo.type;
321             dstInfo->serial = srcInfo.serial;
322 
323             CHECK_EQ(sizeof(srcInfo.u), sizeof(dstInfo->data_int32));
324 
325             memcpy(dstInfo->data_int32,
326                    &srcInfo.u,
327                    sizeof(dstInfo->data_int32));
328 
329             break;
330         }
331 
332         default: {
333             CHECK_GE((int32_t)src.sensorType,
334                      (int32_t)SensorType::DEVICE_PRIVATE_BASE);
335 
336             memcpy(dst->data, src.u.data.data(), 16 * sizeof(float));
337             break;
338         }
339     }
340 }
341 
convertFromSharedMemInfo(const SharedMemInfo & memIn,sensors_direct_mem_t * memOut)342 bool convertFromSharedMemInfo(const SharedMemInfo& memIn, sensors_direct_mem_t *memOut) {
343     if (memOut == nullptr) {
344         return false;
345     }
346 
347     switch(memIn.type) {
348         case SharedMemType::ASHMEM:
349             memOut->type = SENSOR_DIRECT_MEM_TYPE_ASHMEM;
350             break;
351         case SharedMemType::GRALLOC:
352             memOut->type = SENSOR_DIRECT_MEM_TYPE_GRALLOC;
353             break;
354         default:
355             return false;
356     }
357 
358     switch(memIn.format) {
359         case SharedMemFormat::SENSORS_EVENT:
360             memOut->format = SENSOR_DIRECT_FMT_SENSORS_EVENT;
361             break;
362         default:
363             return false;
364     }
365 
366     if (memIn.memoryHandle == nullptr) {
367         return false;
368     }
369 
370     memOut->size = memIn.size;
371     memOut->handle = memIn.memoryHandle;
372     return true;
373 }
374 
convertFromRateLevel(RateLevel rate)375 int convertFromRateLevel(RateLevel rate) {
376     switch(rate) {
377         case RateLevel::STOP:
378             return SENSOR_DIRECT_RATE_STOP;
379         case RateLevel::NORMAL:
380             return SENSOR_DIRECT_RATE_NORMAL;
381         case RateLevel::FAST:
382             return SENSOR_DIRECT_RATE_FAST;
383         case RateLevel::VERY_FAST:
384             return SENSOR_DIRECT_RATE_VERY_FAST;
385         default:
386             return -1;
387     }
388 }
389 
390 }  // namespace implementation
391 }  // namespace V1_0
392 }  // namespace sensors
393 }  // namespace hardware
394 }  // namespace android
395 
396