Sensor.cpp revision adb65d9add2b7350b563d4583c5efbe3f0f0aca1
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 default: 255 // Only pipe the stringType, requiredPermission and flags for custom sensors. 256 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->stringType) { 257 mStringType = hwSensor->stringType; 258 } 259 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->requiredPermission) { 260 mRequiredPermission = hwSensor->requiredPermission; 261 } 262 263 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) { 264 mFlags = (int32_t) hwSensor->flags; 265 } else { 266 // This is an OEM defined sensor on an older HAL. Use minDelay to determine the 267 // reporting mode of the sensor. 268 if (mMinDelay > 0) { 269 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 270 } else if (mMinDelay == 0) { 271 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 272 } else if (mMinDelay < 0) { 273 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE; 274 } 275 } 276 break; 277 } 278} 279 280Sensor::~Sensor() 281{ 282} 283 284const String8& Sensor::getName() const { 285 return mName; 286} 287 288const String8& Sensor::getVendor() const { 289 return mVendor; 290} 291 292int32_t Sensor::getHandle() const { 293 return mHandle; 294} 295 296int32_t Sensor::getType() const { 297 return mType; 298} 299 300float Sensor::getMinValue() const { 301 return mMinValue; 302} 303 304float Sensor::getMaxValue() const { 305 return mMaxValue; 306} 307 308float Sensor::getResolution() const { 309 return mResolution; 310} 311 312float Sensor::getPowerUsage() const { 313 return mPower; 314} 315 316int32_t Sensor::getMinDelay() const { 317 return mMinDelay; 318} 319 320nsecs_t Sensor::getMinDelayNs() const { 321 return getMinDelay() * 1000; 322} 323 324int32_t Sensor::getVersion() const { 325 return mVersion; 326} 327 328int32_t Sensor::getFifoReservedEventCount() const { 329 return mFifoReservedEventCount; 330} 331 332int32_t Sensor::getFifoMaxEventCount() const { 333 return mFifoMaxEventCount; 334} 335 336const String8& Sensor::getStringType() const { 337 return mStringType; 338} 339 340const String8& Sensor::getRequiredPermission() const { 341 return mRequiredPermission; 342} 343 344int32_t Sensor::getMaxDelay() const { 345 return mMaxDelay; 346} 347 348int32_t Sensor::getFlags() const { 349 return mFlags; 350} 351 352bool Sensor::isWakeUpSensor() const { 353 return mFlags & SENSOR_FLAG_WAKE_UP; 354} 355 356int32_t Sensor::getReportingMode() const { 357 return ((mFlags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT); 358} 359 360size_t Sensor::getFlattenedSize() const 361{ 362 size_t fixedSize = 363 sizeof(int32_t) * 3 + 364 sizeof(float) * 4 + 365 sizeof(int32_t) * 5; 366 367 size_t variableSize = 368 sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) + 369 sizeof(uint32_t) + FlattenableUtils::align<4>(mVendor.length()) + 370 sizeof(uint32_t) + FlattenableUtils::align<4>(mStringType.length()) + 371 sizeof(uint32_t) + FlattenableUtils::align<4>(mRequiredPermission.length()); 372 373 return fixedSize + variableSize; 374} 375 376status_t Sensor::flatten(void* buffer, size_t size) const { 377 if (size < getFlattenedSize()) { 378 return NO_MEMORY; 379 } 380 381 flattenString8(buffer, size, mName); 382 flattenString8(buffer, size, mVendor); 383 FlattenableUtils::write(buffer, size, mVersion); 384 FlattenableUtils::write(buffer, size, mHandle); 385 FlattenableUtils::write(buffer, size, mType); 386 FlattenableUtils::write(buffer, size, mMinValue); 387 FlattenableUtils::write(buffer, size, mMaxValue); 388 FlattenableUtils::write(buffer, size, mResolution); 389 FlattenableUtils::write(buffer, size, mPower); 390 FlattenableUtils::write(buffer, size, mMinDelay); 391 FlattenableUtils::write(buffer, size, mFifoReservedEventCount); 392 FlattenableUtils::write(buffer, size, mFifoMaxEventCount); 393 flattenString8(buffer, size, mStringType); 394 flattenString8(buffer, size, mRequiredPermission); 395 FlattenableUtils::write(buffer, size, mMaxDelay); 396 FlattenableUtils::write(buffer, size, mFlags); 397 return NO_ERROR; 398} 399 400status_t Sensor::unflatten(void const* buffer, size_t size) { 401 if (!unflattenString8(buffer, size, mName)) { 402 return NO_MEMORY; 403 } 404 if (!unflattenString8(buffer, size, mVendor)) { 405 return NO_MEMORY; 406 } 407 408 size_t fixedSize = 409 sizeof(int32_t) * 3 + 410 sizeof(float) * 4 + 411 sizeof(int32_t) * 5; 412 if (size < fixedSize) { 413 return NO_MEMORY; 414 } 415 416 FlattenableUtils::read(buffer, size, mVersion); 417 FlattenableUtils::read(buffer, size, mHandle); 418 FlattenableUtils::read(buffer, size, mType); 419 FlattenableUtils::read(buffer, size, mMinValue); 420 FlattenableUtils::read(buffer, size, mMaxValue); 421 FlattenableUtils::read(buffer, size, mResolution); 422 FlattenableUtils::read(buffer, size, mPower); 423 FlattenableUtils::read(buffer, size, mMinDelay); 424 FlattenableUtils::read(buffer, size, mFifoReservedEventCount); 425 FlattenableUtils::read(buffer, size, mFifoMaxEventCount); 426 427 if (!unflattenString8(buffer, size, mStringType)) { 428 return NO_MEMORY; 429 } 430 if (!unflattenString8(buffer, size, mRequiredPermission)) { 431 return NO_MEMORY; 432 } 433 FlattenableUtils::read(buffer, size, mMaxDelay); 434 FlattenableUtils::read(buffer, size, mFlags); 435 return NO_ERROR; 436} 437 438void Sensor::flattenString8(void*& buffer, size_t& size, 439 const String8& string8) { 440 uint32_t len = string8.length(); 441 FlattenableUtils::write(buffer, size, len); 442 memcpy(static_cast<char*>(buffer), string8.string(), len); 443 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len)); 444} 445 446bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) { 447 uint32_t len; 448 if (size < sizeof(len)) { 449 return false; 450 } 451 FlattenableUtils::read(buffer, size, len); 452 if (size < len) { 453 return false; 454 } 455 outputString8.setTo(static_cast<char const*>(buffer), len); 456 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len)); 457 return true; 458} 459 460// ---------------------------------------------------------------------------- 461}; // namespace android 462