Sensor.cpp revision d9441e4c27bb7d0b1dfe2a8b5c1ee1714442648d
1/* 2 * Copyright (C) 2010 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 <stdint.h> 18#include <sys/types.h> 19#include <sys/limits.h> 20 21#include <utils/Errors.h> 22#include <utils/String8.h> 23#include <utils/Flattenable.h> 24 25#include <hardware/sensors.h> 26 27#include <gui/Sensor.h> 28#include <log/log.h> 29 30// ---------------------------------------------------------------------------- 31namespace android { 32// ---------------------------------------------------------------------------- 33 34Sensor::Sensor() 35 : mHandle(0), mType(0), 36 mMinValue(0), mMaxValue(0), mResolution(0), 37 mPower(0), mMinDelay(0), mFifoReservedEventCount(0), mFifoMaxEventCount(0), 38 mMaxDelay(0), mWakeUpSensor(false) 39{ 40} 41 42Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion) 43{ 44 mName = hwSensor->name; 45 mVendor = hwSensor->vendor; 46 mVersion = hwSensor->version; 47 mHandle = hwSensor->handle; 48 mType = hwSensor->type; 49 mMinValue = 0; // FIXME: minValue 50 mMaxValue = hwSensor->maxRange; // FIXME: maxValue 51 mResolution = hwSensor->resolution; 52 mPower = hwSensor->power; 53 mMinDelay = hwSensor->minDelay; 54 mWakeUpSensor = false; 55 56 // Set fifo event count zero for older devices which do not support batching. Fused 57 // sensors also have their fifo counts set to zero. 58 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) { 59 mFifoReservedEventCount = hwSensor->fifoReservedEventCount; 60 mFifoMaxEventCount = hwSensor->fifoMaxEventCount; 61 } else { 62 mFifoReservedEventCount = 0; 63 mFifoMaxEventCount = 0; 64 } 65 66 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) { 67 if (hwSensor->maxDelay > INT_MAX) { 68 // Max delay is declared as a 64 bit integer for 64 bit architectures. But it should 69 // always fit in a 32 bit integer, log error and cap it to INT_MAX. 70 ALOGE("Sensor maxDelay overflow error %s %lld", mName.string(), hwSensor->maxDelay); 71 mMaxDelay = INT_MAX; 72 } else { 73 mMaxDelay = (int32_t) hwSensor->maxDelay; 74 } 75 } else { 76 // For older hals set maxDelay to 0. 77 mMaxDelay = 0; 78 } 79 80 // Ensure existing sensors have correct string type and required 81 // permissions. 82 switch (mType) { 83 case SENSOR_TYPE_ACCELEROMETER: 84 mStringType = SENSOR_STRING_TYPE_ACCELEROMETER; 85 break; 86 case SENSOR_TYPE_AMBIENT_TEMPERATURE: 87 mStringType = SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE; 88 break; 89 case SENSOR_TYPE_GAME_ROTATION_VECTOR: 90 mStringType = SENSOR_STRING_TYPE_GAME_ROTATION_VECTOR; 91 break; 92 case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 93 mStringType = SENSOR_STRING_TYPE_GEOMAGNETIC_ROTATION_VECTOR; 94 break; 95 case SENSOR_TYPE_GRAVITY: 96 mStringType = SENSOR_STRING_TYPE_GRAVITY; 97 break; 98 case SENSOR_TYPE_GYROSCOPE: 99 mStringType = SENSOR_STRING_TYPE_GYROSCOPE; 100 break; 101 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 102 mStringType = SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED; 103 break; 104 case SENSOR_TYPE_HEART_RATE: 105 mStringType = SENSOR_STRING_TYPE_HEART_RATE; 106 mRequiredPermission = SENSOR_PERMISSION_BODY_SENSORS; 107 break; 108 case SENSOR_TYPE_LIGHT: 109 mStringType = SENSOR_STRING_TYPE_LIGHT; 110 break; 111 case SENSOR_TYPE_LINEAR_ACCELERATION: 112 mStringType = SENSOR_STRING_TYPE_LINEAR_ACCELERATION; 113 break; 114 case SENSOR_TYPE_MAGNETIC_FIELD: 115 mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD; 116 break; 117 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 118 mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED; 119 break; 120 case SENSOR_TYPE_ORIENTATION: 121 mStringType = SENSOR_STRING_TYPE_ORIENTATION; 122 break; 123 case SENSOR_TYPE_PRESSURE: 124 mStringType = SENSOR_STRING_TYPE_PRESSURE; 125 break; 126 case SENSOR_TYPE_PROXIMITY: 127 mStringType = SENSOR_STRING_TYPE_PROXIMITY; 128 mWakeUpSensor = true; 129 break; 130 case SENSOR_TYPE_RELATIVE_HUMIDITY: 131 mStringType = SENSOR_STRING_TYPE_RELATIVE_HUMIDITY; 132 break; 133 case SENSOR_TYPE_ROTATION_VECTOR: 134 mStringType = SENSOR_STRING_TYPE_ROTATION_VECTOR; 135 break; 136 case SENSOR_TYPE_SIGNIFICANT_MOTION: 137 mStringType = SENSOR_STRING_TYPE_SIGNIFICANT_MOTION; 138 mWakeUpSensor = true; 139 break; 140 case SENSOR_TYPE_STEP_COUNTER: 141 mStringType = SENSOR_STRING_TYPE_STEP_COUNTER; 142 break; 143 case SENSOR_TYPE_STEP_DETECTOR: 144 mStringType = SENSOR_STRING_TYPE_STEP_DETECTOR; 145 break; 146 case SENSOR_TYPE_TEMPERATURE: 147 mStringType = SENSOR_STRING_TYPE_TEMPERATURE; 148 break; 149 case SENSOR_TYPE_NON_WAKE_UP_PROXIMITY_SENSOR: 150 mStringType = SENSOR_STRING_TYPE_NON_WAKE_UP_PROXIMITY_SENSOR; 151 break; 152 case SENSOR_TYPE_WAKE_UP_ACCELEROMETER: 153 mStringType = SENSOR_STRING_TYPE_WAKE_UP_ACCELEROMETER; 154 mWakeUpSensor = true; 155 break; 156 case SENSOR_TYPE_WAKE_UP_MAGNETIC_FIELD: 157 mStringType = SENSOR_STRING_TYPE_WAKE_UP_MAGNETIC_FIELD; 158 mWakeUpSensor = true; 159 break; 160 case SENSOR_TYPE_WAKE_UP_ORIENTATION: 161 mStringType = SENSOR_STRING_TYPE_WAKE_UP_ORIENTATION; 162 mWakeUpSensor = true; 163 break; 164 case SENSOR_TYPE_WAKE_UP_GYROSCOPE: 165 mStringType = SENSOR_STRING_TYPE_WAKE_UP_GYROSCOPE; 166 mWakeUpSensor = true; 167 break; 168 case SENSOR_TYPE_WAKE_UP_LIGHT: 169 mStringType = SENSOR_STRING_TYPE_WAKE_UP_LIGHT; 170 mWakeUpSensor = true; 171 break; 172 case SENSOR_TYPE_WAKE_UP_PRESSURE: 173 mStringType = SENSOR_STRING_TYPE_WAKE_UP_PRESSURE; 174 mWakeUpSensor = true; 175 break; 176 case SENSOR_TYPE_WAKE_UP_GRAVITY: 177 mStringType = SENSOR_STRING_TYPE_WAKE_UP_GRAVITY; 178 mWakeUpSensor = true; 179 break; 180 case SENSOR_TYPE_WAKE_UP_LINEAR_ACCELERATION: 181 mStringType = SENSOR_STRING_TYPE_WAKE_UP_LINEAR_ACCELERATION; 182 mWakeUpSensor = true; 183 break; 184 case SENSOR_TYPE_WAKE_UP_ROTATION_VECTOR: 185 mStringType = SENSOR_STRING_TYPE_WAKE_UP_ROTATION_VECTOR; 186 mWakeUpSensor = true; 187 break; 188 case SENSOR_TYPE_WAKE_UP_RELATIVE_HUMIDITY: 189 mStringType = SENSOR_STRING_TYPE_WAKE_UP_RELATIVE_HUMIDITY; 190 mWakeUpSensor = true; 191 break; 192 case SENSOR_TYPE_WAKE_UP_AMBIENT_TEMPERATURE: 193 mStringType = SENSOR_STRING_TYPE_WAKE_UP_AMBIENT_TEMPERATURE; 194 mWakeUpSensor = true; 195 break; 196 case SENSOR_TYPE_WAKE_UP_MAGNETIC_FIELD_UNCALIBRATED: 197 mStringType = SENSOR_STRING_TYPE_WAKE_UP_MAGNETIC_FIELD_UNCALIBRATED; 198 mWakeUpSensor = true; 199 break; 200 case SENSOR_TYPE_WAKE_UP_GAME_ROTATION_VECTOR: 201 mStringType = SENSOR_STRING_TYPE_WAKE_UP_GAME_ROTATION_VECTOR; 202 mWakeUpSensor = true; 203 break; 204 case SENSOR_TYPE_WAKE_UP_GYROSCOPE_UNCALIBRATED: 205 mStringType = SENSOR_STRING_TYPE_WAKE_UP_GYROSCOPE_UNCALIBRATED; 206 mWakeUpSensor = true; 207 break; 208 case SENSOR_TYPE_WAKE_UP_STEP_DETECTOR: 209 mStringType = SENSOR_STRING_TYPE_WAKE_UP_STEP_DETECTOR; 210 mWakeUpSensor = true; 211 break; 212 case SENSOR_TYPE_WAKE_UP_STEP_COUNTER: 213 mStringType = SENSOR_STRING_TYPE_WAKE_UP_STEP_COUNTER; 214 mWakeUpSensor = true; 215 break; 216 case SENSOR_TYPE_WAKE_UP_GEOMAGNETIC_ROTATION_VECTOR: 217 mStringType = SENSOR_STRING_TYPE_WAKE_UP_GEOMAGNETIC_ROTATION_VECTOR; 218 mWakeUpSensor = true; 219 break; 220 case SENSOR_TYPE_WAKE_UP_HEART_RATE: 221 mStringType = SENSOR_STRING_TYPE_WAKE_UP_HEART_RATE; 222 mRequiredPermission = SENSOR_PERMISSION_BODY_SENSORS; 223 mWakeUpSensor = true; 224 break; 225 case SENSOR_TYPE_WAKE_GESTURE: 226 mStringType = SENSOR_STRING_TYPE_WAKE_GESTURE; 227 mWakeUpSensor = true; 228 break; 229 default: 230 // Only pipe the stringType, requiredPermission and flags for custom sensors. 231 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->stringType) { 232 mStringType = hwSensor->stringType; 233 } 234 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->requiredPermission) { 235 mRequiredPermission = hwSensor->requiredPermission; 236 } 237 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) { 238 mWakeUpSensor = hwSensor->flags & SENSOR_FLAG_WAKE_UP; 239 } 240 break; 241 } 242} 243 244Sensor::~Sensor() 245{ 246} 247 248const String8& Sensor::getName() const { 249 return mName; 250} 251 252const String8& Sensor::getVendor() const { 253 return mVendor; 254} 255 256int32_t Sensor::getHandle() const { 257 return mHandle; 258} 259 260int32_t Sensor::getType() const { 261 return mType; 262} 263 264float Sensor::getMinValue() const { 265 return mMinValue; 266} 267 268float Sensor::getMaxValue() const { 269 return mMaxValue; 270} 271 272float Sensor::getResolution() const { 273 return mResolution; 274} 275 276float Sensor::getPowerUsage() const { 277 return mPower; 278} 279 280int32_t Sensor::getMinDelay() const { 281 return mMinDelay; 282} 283 284nsecs_t Sensor::getMinDelayNs() const { 285 return getMinDelay() * 1000; 286} 287 288int32_t Sensor::getVersion() const { 289 return mVersion; 290} 291 292int32_t Sensor::getFifoReservedEventCount() const { 293 return mFifoReservedEventCount; 294} 295 296int32_t Sensor::getFifoMaxEventCount() const { 297 return mFifoMaxEventCount; 298} 299 300const String8& Sensor::getStringType() const { 301 return mStringType; 302} 303 304const String8& Sensor::getRequiredPermission() const { 305 return mRequiredPermission; 306} 307 308int32_t Sensor::getMaxDelay() const { 309 return mMaxDelay; 310} 311 312bool Sensor::isWakeUpSensor() const { 313 return mWakeUpSensor; 314} 315 316size_t Sensor::getFlattenedSize() const 317{ 318 size_t fixedSize = 319 sizeof(int32_t) * 3 + 320 sizeof(float) * 4 + 321 sizeof(int32_t) * 4 + 322 sizeof(bool) * 1; 323 324 size_t variableSize = 325 sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) + 326 sizeof(uint32_t) + FlattenableUtils::align<4>(mVendor.length()) + 327 sizeof(uint32_t) + FlattenableUtils::align<4>(mStringType.length()) + 328 sizeof(uint32_t) + FlattenableUtils::align<4>(mRequiredPermission.length()); 329 330 return fixedSize + variableSize; 331} 332 333status_t Sensor::flatten(void* buffer, size_t size) const { 334 if (size < getFlattenedSize()) { 335 return NO_MEMORY; 336 } 337 338 flattenString8(buffer, size, mName); 339 flattenString8(buffer, size, mVendor); 340 FlattenableUtils::write(buffer, size, mVersion); 341 FlattenableUtils::write(buffer, size, mHandle); 342 FlattenableUtils::write(buffer, size, mType); 343 FlattenableUtils::write(buffer, size, mMinValue); 344 FlattenableUtils::write(buffer, size, mMaxValue); 345 FlattenableUtils::write(buffer, size, mResolution); 346 FlattenableUtils::write(buffer, size, mPower); 347 FlattenableUtils::write(buffer, size, mMinDelay); 348 FlattenableUtils::write(buffer, size, mFifoReservedEventCount); 349 FlattenableUtils::write(buffer, size, mFifoMaxEventCount); 350 flattenString8(buffer, size, mStringType); 351 flattenString8(buffer, size, mRequiredPermission); 352 FlattenableUtils::write(buffer, size, mMaxDelay); 353 FlattenableUtils::write(buffer, size, mWakeUpSensor); 354 return NO_ERROR; 355} 356 357status_t Sensor::unflatten(void const* buffer, size_t size) { 358 if (!unflattenString8(buffer, size, mName)) { 359 return NO_MEMORY; 360 } 361 if (!unflattenString8(buffer, size, mVendor)) { 362 return NO_MEMORY; 363 } 364 365 size_t fixedSize = 366 sizeof(int32_t) * 3 + 367 sizeof(float) * 4 + 368 sizeof(int32_t) * 4 + 369 sizeof(bool) * 1; 370 if (size < fixedSize) { 371 return NO_MEMORY; 372 } 373 374 FlattenableUtils::read(buffer, size, mVersion); 375 FlattenableUtils::read(buffer, size, mHandle); 376 FlattenableUtils::read(buffer, size, mType); 377 FlattenableUtils::read(buffer, size, mMinValue); 378 FlattenableUtils::read(buffer, size, mMaxValue); 379 FlattenableUtils::read(buffer, size, mResolution); 380 FlattenableUtils::read(buffer, size, mPower); 381 FlattenableUtils::read(buffer, size, mMinDelay); 382 FlattenableUtils::read(buffer, size, mFifoReservedEventCount); 383 FlattenableUtils::read(buffer, size, mFifoMaxEventCount); 384 385 if (!unflattenString8(buffer, size, mStringType)) { 386 return NO_MEMORY; 387 } 388 if (!unflattenString8(buffer, size, mRequiredPermission)) { 389 return NO_MEMORY; 390 } 391 FlattenableUtils::read(buffer, size, mMaxDelay); 392 FlattenableUtils::read(buffer, size, mWakeUpSensor); 393 return NO_ERROR; 394} 395 396void Sensor::flattenString8(void*& buffer, size_t& size, 397 const String8& string8) { 398 uint32_t len = string8.length(); 399 FlattenableUtils::write(buffer, size, len); 400 memcpy(static_cast<char*>(buffer), string8.string(), len); 401 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len)); 402} 403 404bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) { 405 uint32_t len; 406 if (size < sizeof(len)) { 407 return false; 408 } 409 FlattenableUtils::read(buffer, size, len); 410 if (size < len) { 411 return false; 412 } 413 outputString8.setTo(static_cast<char const*>(buffer), len); 414 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len)); 415 return true; 416} 417 418// ---------------------------------------------------------------------------- 419}; // namespace android 420