Sensor.cpp revision 9bb99b1570a1715cce1d02a776c06f1596d61ecd
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_0) { 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 // Set reportingMode for all android defined sensor types, set wake-up flag only for proximity 84 // sensor, significant motion, tilt, pick_up gesture, wake gesture and glance gesture on older 85 // HALs. Newer HALs can define both wake-up and non wake-up proximity sensors. 86 // All the OEM defined defined sensors have flags set to whatever is provided by the HAL. 87 switch (mType) { 88 case SENSOR_TYPE_ACCELEROMETER: 89 mStringType = SENSOR_STRING_TYPE_ACCELEROMETER; 90 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 91 break; 92 case SENSOR_TYPE_AMBIENT_TEMPERATURE: 93 mStringType = SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE; 94 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 95 break; 96 case SENSOR_TYPE_GAME_ROTATION_VECTOR: 97 mStringType = SENSOR_STRING_TYPE_GAME_ROTATION_VECTOR; 98 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 99 break; 100 case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 101 mStringType = SENSOR_STRING_TYPE_GEOMAGNETIC_ROTATION_VECTOR; 102 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 103 break; 104 case SENSOR_TYPE_GRAVITY: 105 mStringType = SENSOR_STRING_TYPE_GRAVITY; 106 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 107 break; 108 case SENSOR_TYPE_GYROSCOPE: 109 mStringType = SENSOR_STRING_TYPE_GYROSCOPE; 110 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 111 break; 112 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 113 mStringType = SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED; 114 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 115 break; 116 case SENSOR_TYPE_HEART_RATE: 117 mStringType = SENSOR_STRING_TYPE_HEART_RATE; 118 mRequiredPermission = SENSOR_PERMISSION_BODY_SENSORS; 119 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 120 break; 121 case SENSOR_TYPE_LIGHT: 122 mStringType = SENSOR_STRING_TYPE_LIGHT; 123 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 124 break; 125 case SENSOR_TYPE_LINEAR_ACCELERATION: 126 mStringType = SENSOR_STRING_TYPE_LINEAR_ACCELERATION; 127 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 128 break; 129 case SENSOR_TYPE_MAGNETIC_FIELD: 130 mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD; 131 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 132 break; 133 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 134 mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED; 135 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 136 break; 137 case SENSOR_TYPE_ORIENTATION: 138 mStringType = SENSOR_STRING_TYPE_ORIENTATION; 139 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 140 break; 141 case SENSOR_TYPE_PRESSURE: 142 mStringType = SENSOR_STRING_TYPE_PRESSURE; 143 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 144 break; 145 case SENSOR_TYPE_PROXIMITY: 146 mStringType = SENSOR_STRING_TYPE_PROXIMITY; 147 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 148 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) { 149 mFlags |= SENSOR_FLAG_WAKE_UP; 150 } 151 break; 152 case SENSOR_TYPE_RELATIVE_HUMIDITY: 153 mStringType = SENSOR_STRING_TYPE_RELATIVE_HUMIDITY; 154 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 155 break; 156 case SENSOR_TYPE_ROTATION_VECTOR: 157 mStringType = SENSOR_STRING_TYPE_ROTATION_VECTOR; 158 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 159 break; 160 case SENSOR_TYPE_SIGNIFICANT_MOTION: 161 mStringType = SENSOR_STRING_TYPE_SIGNIFICANT_MOTION; 162 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE; 163 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) { 164 mFlags |= SENSOR_FLAG_WAKE_UP; 165 } 166 break; 167 case SENSOR_TYPE_STEP_COUNTER: 168 mStringType = SENSOR_STRING_TYPE_STEP_COUNTER; 169 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 170 break; 171 case SENSOR_TYPE_STEP_DETECTOR: 172 mStringType = SENSOR_STRING_TYPE_STEP_DETECTOR; 173 mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE; 174 break; 175 case SENSOR_TYPE_TEMPERATURE: 176 mStringType = SENSOR_STRING_TYPE_TEMPERATURE; 177 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 178 break; 179 case SENSOR_TYPE_TILT_DETECTOR: 180 mStringType = SENSOR_STRING_TYPE_TILT_DETECTOR; 181 mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE; 182 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) { 183 mFlags |= SENSOR_FLAG_WAKE_UP; 184 } 185 break; 186 case SENSOR_TYPE_WAKE_GESTURE: 187 mStringType = SENSOR_STRING_TYPE_WAKE_GESTURE; 188 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE; 189 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) { 190 mFlags |= SENSOR_FLAG_WAKE_UP; 191 } 192 break; 193 case SENSOR_TYPE_GLANCE_GESTURE: 194 mStringType = SENSOR_STRING_TYPE_GLANCE_GESTURE; 195 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE; 196 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) { 197 mFlags |= SENSOR_FLAG_WAKE_UP; 198 } 199 break; 200 case SENSOR_TYPE_PICK_UP_GESTURE: 201 mStringType = SENSOR_STRING_TYPE_PICK_UP_GESTURE; 202 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE; 203 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) { 204 mFlags |= SENSOR_FLAG_WAKE_UP; 205 } 206 break; 207 case SENSOR_TYPE_WRIST_TILT_GESTURE: 208 mStringType = SENSOR_STRING_TYPE_WRIST_TILT_GESTURE; 209 mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE; 210 if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) { 211 mFlags |= SENSOR_FLAG_WAKE_UP; 212 } 213 break; 214 default: 215 // Only pipe the stringType, requiredPermission and flags for custom sensors. 216 if (halVersion > SENSORS_DEVICE_API_VERSION_1_0 && hwSensor->stringType) { 217 mStringType = hwSensor->stringType; 218 } 219 if (halVersion > SENSORS_DEVICE_API_VERSION_1_0 && hwSensor->requiredPermission) { 220 mRequiredPermission = hwSensor->requiredPermission; 221 } 222 223 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) { 224 mFlags = (int32_t) hwSensor->flags; 225 } else { 226 // This is an OEM defined sensor on an older HAL. Use minDelay to determine the 227 // reporting mode of the sensor. 228 if (mMinDelay > 0) { 229 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 230 } else if (mMinDelay == 0) { 231 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 232 } else if (mMinDelay < 0) { 233 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE; 234 } 235 } 236 break; 237 } 238 239 // For the newer HALs log errors if reporting mask flags are set incorrectly. 240 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) { 241 // Wake-up flag is set here. 242 mFlags |= (hwSensor->flags & SENSOR_FLAG_WAKE_UP); 243 if (mFlags != hwSensor->flags) { 244 int actualReportingMode = 245 (hwSensor->flags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT; 246 int expectedReportingMode = (mFlags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT; 247 if (actualReportingMode != expectedReportingMode) { 248 ALOGE("Reporting Mode incorrect: sensor %s handle=%d type=%d " 249 "actual=%d expected=%d", 250 mName.string(), mHandle, mType, actualReportingMode, expectedReportingMode); 251 } 252 253 } 254 } 255} 256 257Sensor::~Sensor() 258{ 259} 260 261const String8& Sensor::getName() const { 262 return mName; 263} 264 265const String8& Sensor::getVendor() const { 266 return mVendor; 267} 268 269int32_t Sensor::getHandle() const { 270 return mHandle; 271} 272 273int32_t Sensor::getType() const { 274 return mType; 275} 276 277float Sensor::getMinValue() const { 278 return mMinValue; 279} 280 281float Sensor::getMaxValue() const { 282 return mMaxValue; 283} 284 285float Sensor::getResolution() const { 286 return mResolution; 287} 288 289float Sensor::getPowerUsage() const { 290 return mPower; 291} 292 293int32_t Sensor::getMinDelay() const { 294 return mMinDelay; 295} 296 297nsecs_t Sensor::getMinDelayNs() const { 298 return getMinDelay() * 1000; 299} 300 301int32_t Sensor::getVersion() const { 302 return mVersion; 303} 304 305int32_t Sensor::getFifoReservedEventCount() const { 306 return mFifoReservedEventCount; 307} 308 309int32_t Sensor::getFifoMaxEventCount() const { 310 return mFifoMaxEventCount; 311} 312 313const String8& Sensor::getStringType() const { 314 return mStringType; 315} 316 317const String8& Sensor::getRequiredPermission() const { 318 return mRequiredPermission; 319} 320 321int32_t Sensor::getMaxDelay() const { 322 return mMaxDelay; 323} 324 325int32_t Sensor::getFlags() const { 326 return mFlags; 327} 328 329bool Sensor::isWakeUpSensor() const { 330 return mFlags & SENSOR_FLAG_WAKE_UP; 331} 332 333int32_t Sensor::getReportingMode() const { 334 return ((mFlags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT); 335} 336 337size_t Sensor::getFlattenedSize() const 338{ 339 size_t fixedSize = 340 sizeof(int32_t) * 3 + 341 sizeof(float) * 4 + 342 sizeof(int32_t) * 5; 343 344 size_t variableSize = 345 sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) + 346 sizeof(uint32_t) + FlattenableUtils::align<4>(mVendor.length()) + 347 sizeof(uint32_t) + FlattenableUtils::align<4>(mStringType.length()) + 348 sizeof(uint32_t) + FlattenableUtils::align<4>(mRequiredPermission.length()); 349 350 return fixedSize + variableSize; 351} 352 353status_t Sensor::flatten(void* buffer, size_t size) const { 354 if (size < getFlattenedSize()) { 355 return NO_MEMORY; 356 } 357 358 flattenString8(buffer, size, mName); 359 flattenString8(buffer, size, mVendor); 360 FlattenableUtils::write(buffer, size, mVersion); 361 FlattenableUtils::write(buffer, size, mHandle); 362 FlattenableUtils::write(buffer, size, mType); 363 FlattenableUtils::write(buffer, size, mMinValue); 364 FlattenableUtils::write(buffer, size, mMaxValue); 365 FlattenableUtils::write(buffer, size, mResolution); 366 FlattenableUtils::write(buffer, size, mPower); 367 FlattenableUtils::write(buffer, size, mMinDelay); 368 FlattenableUtils::write(buffer, size, mFifoReservedEventCount); 369 FlattenableUtils::write(buffer, size, mFifoMaxEventCount); 370 flattenString8(buffer, size, mStringType); 371 flattenString8(buffer, size, mRequiredPermission); 372 FlattenableUtils::write(buffer, size, mMaxDelay); 373 FlattenableUtils::write(buffer, size, mFlags); 374 return NO_ERROR; 375} 376 377status_t Sensor::unflatten(void const* buffer, size_t size) { 378 if (!unflattenString8(buffer, size, mName)) { 379 return NO_MEMORY; 380 } 381 if (!unflattenString8(buffer, size, mVendor)) { 382 return NO_MEMORY; 383 } 384 385 size_t fixedSize = 386 sizeof(int32_t) * 3 + 387 sizeof(float) * 4 + 388 sizeof(int32_t) * 5; 389 if (size < fixedSize) { 390 return NO_MEMORY; 391 } 392 393 FlattenableUtils::read(buffer, size, mVersion); 394 FlattenableUtils::read(buffer, size, mHandle); 395 FlattenableUtils::read(buffer, size, mType); 396 FlattenableUtils::read(buffer, size, mMinValue); 397 FlattenableUtils::read(buffer, size, mMaxValue); 398 FlattenableUtils::read(buffer, size, mResolution); 399 FlattenableUtils::read(buffer, size, mPower); 400 FlattenableUtils::read(buffer, size, mMinDelay); 401 FlattenableUtils::read(buffer, size, mFifoReservedEventCount); 402 FlattenableUtils::read(buffer, size, mFifoMaxEventCount); 403 404 if (!unflattenString8(buffer, size, mStringType)) { 405 return NO_MEMORY; 406 } 407 if (!unflattenString8(buffer, size, mRequiredPermission)) { 408 return NO_MEMORY; 409 } 410 FlattenableUtils::read(buffer, size, mMaxDelay); 411 FlattenableUtils::read(buffer, size, mFlags); 412 return NO_ERROR; 413} 414 415void Sensor::flattenString8(void*& buffer, size_t& size, 416 const String8& string8) { 417 uint32_t len = string8.length(); 418 FlattenableUtils::write(buffer, size, len); 419 memcpy(static_cast<char*>(buffer), string8.string(), len); 420 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len)); 421} 422 423bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) { 424 uint32_t len; 425 if (size < sizeof(len)) { 426 return false; 427 } 428 FlattenableUtils::read(buffer, size, len); 429 if (size < len) { 430 return false; 431 } 432 outputString8.setTo(static_cast<char const*>(buffer), len); 433 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len)); 434 return true; 435} 436 437// ---------------------------------------------------------------------------- 438}; // namespace android 439