Sensor.cpp revision fd8498c41e8904e3636e47cf81466d439aed46a8
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_WAKE_UP_TILT_DETECTOR: 170 mStringType = SENSOR_STRING_TYPE_WAKE_UP_TILT_DETECTOR; 171 mFlags |= (SENSOR_FLAG_SPECIAL_REPORTING_MODE | SENSOR_FLAG_WAKE_UP); 172 break; 173 case SENSOR_TYPE_WAKE_GESTURE: 174 mStringType = SENSOR_STRING_TYPE_WAKE_GESTURE; 175 mFlags |= (SENSOR_FLAG_ONE_SHOT_MODE | SENSOR_FLAG_WAKE_UP); 176 break; 177 case SENSOR_TYPE_GLANCE_GESTURE: 178 mStringType = SENSOR_STRING_TYPE_GLANCE_GESTURE; 179 mFlags |= (SENSOR_FLAG_ONE_SHOT_MODE | SENSOR_FLAG_WAKE_UP); 180 break; 181 case SENSOR_TYPE_PICK_UP_GESTURE: 182 mStringType = SENSOR_STRING_TYPE_PICK_UP_GESTURE; 183 mFlags |= (SENSOR_FLAG_ONE_SHOT_MODE | SENSOR_FLAG_WAKE_UP); 184 break; 185 default: 186 // Only pipe the stringType, requiredPermission and flags for custom sensors. 187 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->stringType) { 188 mStringType = hwSensor->stringType; 189 } 190 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->requiredPermission) { 191 mRequiredPermission = hwSensor->requiredPermission; 192 } 193 194 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) { 195 mFlags = (int32_t) hwSensor->flags; 196 } else { 197 // This is an OEM defined sensor on an older HAL. Use minDelay to determine the 198 // reporting mode of the sensor. 199 if (mMinDelay > 0) { 200 mFlags |= SENSOR_FLAG_CONTINUOUS_MODE; 201 } else if (mMinDelay == 0) { 202 mFlags |= SENSOR_FLAG_ON_CHANGE_MODE; 203 } else if (mMinDelay < 0) { 204 mFlags |= SENSOR_FLAG_ONE_SHOT_MODE; 205 } 206 } 207 break; 208 } 209} 210 211Sensor::~Sensor() 212{ 213} 214 215const String8& Sensor::getName() const { 216 return mName; 217} 218 219const String8& Sensor::getVendor() const { 220 return mVendor; 221} 222 223int32_t Sensor::getHandle() const { 224 return mHandle; 225} 226 227int32_t Sensor::getType() const { 228 return mType; 229} 230 231float Sensor::getMinValue() const { 232 return mMinValue; 233} 234 235float Sensor::getMaxValue() const { 236 return mMaxValue; 237} 238 239float Sensor::getResolution() const { 240 return mResolution; 241} 242 243float Sensor::getPowerUsage() const { 244 return mPower; 245} 246 247int32_t Sensor::getMinDelay() const { 248 return mMinDelay; 249} 250 251nsecs_t Sensor::getMinDelayNs() const { 252 return getMinDelay() * 1000; 253} 254 255int32_t Sensor::getVersion() const { 256 return mVersion; 257} 258 259int32_t Sensor::getFifoReservedEventCount() const { 260 return mFifoReservedEventCount; 261} 262 263int32_t Sensor::getFifoMaxEventCount() const { 264 return mFifoMaxEventCount; 265} 266 267const String8& Sensor::getStringType() const { 268 return mStringType; 269} 270 271const String8& Sensor::getRequiredPermission() const { 272 return mRequiredPermission; 273} 274 275int32_t Sensor::getMaxDelay() const { 276 return mMaxDelay; 277} 278 279int32_t Sensor::getFlags() const { 280 return mFlags; 281} 282 283bool Sensor::isWakeUpSensor() const { 284 return mFlags & SENSOR_FLAG_WAKE_UP; 285} 286 287int32_t Sensor::getReportingMode() const { 288 return ((mFlags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT); 289} 290 291size_t Sensor::getFlattenedSize() const 292{ 293 size_t fixedSize = 294 sizeof(int32_t) * 3 + 295 sizeof(float) * 4 + 296 sizeof(int32_t) * 5; 297 298 size_t variableSize = 299 sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) + 300 sizeof(uint32_t) + FlattenableUtils::align<4>(mVendor.length()) + 301 sizeof(uint32_t) + FlattenableUtils::align<4>(mStringType.length()) + 302 sizeof(uint32_t) + FlattenableUtils::align<4>(mRequiredPermission.length()); 303 304 return fixedSize + variableSize; 305} 306 307status_t Sensor::flatten(void* buffer, size_t size) const { 308 if (size < getFlattenedSize()) { 309 return NO_MEMORY; 310 } 311 312 flattenString8(buffer, size, mName); 313 flattenString8(buffer, size, mVendor); 314 FlattenableUtils::write(buffer, size, mVersion); 315 FlattenableUtils::write(buffer, size, mHandle); 316 FlattenableUtils::write(buffer, size, mType); 317 FlattenableUtils::write(buffer, size, mMinValue); 318 FlattenableUtils::write(buffer, size, mMaxValue); 319 FlattenableUtils::write(buffer, size, mResolution); 320 FlattenableUtils::write(buffer, size, mPower); 321 FlattenableUtils::write(buffer, size, mMinDelay); 322 FlattenableUtils::write(buffer, size, mFifoReservedEventCount); 323 FlattenableUtils::write(buffer, size, mFifoMaxEventCount); 324 flattenString8(buffer, size, mStringType); 325 flattenString8(buffer, size, mRequiredPermission); 326 FlattenableUtils::write(buffer, size, mMaxDelay); 327 FlattenableUtils::write(buffer, size, mFlags); 328 return NO_ERROR; 329} 330 331status_t Sensor::unflatten(void const* buffer, size_t size) { 332 if (!unflattenString8(buffer, size, mName)) { 333 return NO_MEMORY; 334 } 335 if (!unflattenString8(buffer, size, mVendor)) { 336 return NO_MEMORY; 337 } 338 339 size_t fixedSize = 340 sizeof(int32_t) * 3 + 341 sizeof(float) * 4 + 342 sizeof(int32_t) * 5; 343 if (size < fixedSize) { 344 return NO_MEMORY; 345 } 346 347 FlattenableUtils::read(buffer, size, mVersion); 348 FlattenableUtils::read(buffer, size, mHandle); 349 FlattenableUtils::read(buffer, size, mType); 350 FlattenableUtils::read(buffer, size, mMinValue); 351 FlattenableUtils::read(buffer, size, mMaxValue); 352 FlattenableUtils::read(buffer, size, mResolution); 353 FlattenableUtils::read(buffer, size, mPower); 354 FlattenableUtils::read(buffer, size, mMinDelay); 355 FlattenableUtils::read(buffer, size, mFifoReservedEventCount); 356 FlattenableUtils::read(buffer, size, mFifoMaxEventCount); 357 358 if (!unflattenString8(buffer, size, mStringType)) { 359 return NO_MEMORY; 360 } 361 if (!unflattenString8(buffer, size, mRequiredPermission)) { 362 return NO_MEMORY; 363 } 364 FlattenableUtils::read(buffer, size, mMaxDelay); 365 FlattenableUtils::read(buffer, size, mFlags); 366 return NO_ERROR; 367} 368 369void Sensor::flattenString8(void*& buffer, size_t& size, 370 const String8& string8) { 371 uint32_t len = string8.length(); 372 FlattenableUtils::write(buffer, size, len); 373 memcpy(static_cast<char*>(buffer), string8.string(), len); 374 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len)); 375} 376 377bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) { 378 uint32_t len; 379 if (size < sizeof(len)) { 380 return false; 381 } 382 FlattenableUtils::read(buffer, size, len); 383 if (size < len) { 384 return false; 385 } 386 outputString8.setTo(static_cast<char const*>(buffer), len); 387 FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len)); 388 return true; 389} 390 391// ---------------------------------------------------------------------------- 392}; // namespace android 393