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