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