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