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