SensorService.cpp revision d9441e4c27bb7d0b1dfe2a8b5c1ee1714442648d
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 <math.h> 19#include <stdint.h> 20#include <sys/types.h> 21 22#include <cutils/properties.h> 23 24#include <utils/SortedVector.h> 25#include <utils/KeyedVector.h> 26#include <utils/threads.h> 27#include <utils/Atomic.h> 28#include <utils/Errors.h> 29#include <utils/RefBase.h> 30#include <utils/Singleton.h> 31#include <utils/String16.h> 32 33#include <binder/BinderService.h> 34#include <binder/IServiceManager.h> 35#include <binder/PermissionCache.h> 36 37#include <gui/ISensorServer.h> 38#include <gui/ISensorEventConnection.h> 39#include <gui/SensorEventQueue.h> 40 41#include <hardware/sensors.h> 42#include <hardware_legacy/power.h> 43 44#include "BatteryService.h" 45#include "CorrectedGyroSensor.h" 46#include "GravitySensor.h" 47#include "LinearAccelerationSensor.h" 48#include "OrientationSensor.h" 49#include "RotationVectorSensor.h" 50#include "SensorFusion.h" 51#include "SensorService.h" 52 53namespace android { 54// --------------------------------------------------------------------------- 55 56/* 57 * Notes: 58 * 59 * - what about a gyro-corrected magnetic-field sensor? 60 * - run mag sensor from time to time to force calibration 61 * - gravity sensor length is wrong (=> drift in linear-acc sensor) 62 * 63 */ 64 65const char* SensorService::WAKE_LOCK_NAME = "SensorService"; 66 67SensorService::SensorService() 68 : mInitCheck(NO_INIT) 69{ 70} 71 72void SensorService::onFirstRef() 73{ 74 ALOGD("nuSensorService starting..."); 75 76 SensorDevice& dev(SensorDevice::getInstance()); 77 78 if (dev.initCheck() == NO_ERROR) { 79 sensor_t const* list; 80 ssize_t count = dev.getSensorList(&list); 81 if (count > 0) { 82 ssize_t orientationIndex = -1; 83 bool hasGyro = false; 84 uint32_t virtualSensorsNeeds = 85 (1<<SENSOR_TYPE_GRAVITY) | 86 (1<<SENSOR_TYPE_LINEAR_ACCELERATION) | 87 (1<<SENSOR_TYPE_ROTATION_VECTOR); 88 89 mLastEventSeen.setCapacity(count); 90 for (ssize_t i=0 ; i<count ; i++) { 91 registerSensor( new HardwareSensor(list[i]) ); 92 switch (list[i].type) { 93 case SENSOR_TYPE_ORIENTATION: 94 orientationIndex = i; 95 break; 96 case SENSOR_TYPE_GYROSCOPE: 97 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 98 hasGyro = true; 99 break; 100 case SENSOR_TYPE_GRAVITY: 101 case SENSOR_TYPE_LINEAR_ACCELERATION: 102 case SENSOR_TYPE_ROTATION_VECTOR: 103 virtualSensorsNeeds &= ~(1<<list[i].type); 104 break; 105 } 106 } 107 108 // it's safe to instantiate the SensorFusion object here 109 // (it wants to be instantiated after h/w sensors have been 110 // registered) 111 const SensorFusion& fusion(SensorFusion::getInstance()); 112 113 // build the sensor list returned to users 114 mUserSensorList = mSensorList; 115 116 if (hasGyro) { 117 Sensor aSensor; 118 119 // Add Android virtual sensors if they're not already 120 // available in the HAL 121 122 aSensor = registerVirtualSensor( new RotationVectorSensor() ); 123 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 124 mUserSensorList.add(aSensor); 125 } 126 127 aSensor = registerVirtualSensor( new GravitySensor(list, count) ); 128 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) { 129 mUserSensorList.add(aSensor); 130 } 131 132 aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) ); 133 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) { 134 mUserSensorList.add(aSensor); 135 } 136 137 aSensor = registerVirtualSensor( new OrientationSensor() ); 138 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 139 // if we are doing our own rotation-vector, also add 140 // the orientation sensor and remove the HAL provided one. 141 mUserSensorList.replaceAt(aSensor, orientationIndex); 142 } 143 144 // virtual debugging sensors are not added to mUserSensorList 145 registerVirtualSensor( new CorrectedGyroSensor(list, count) ); 146 registerVirtualSensor( new GyroDriftSensor() ); 147 } 148 149 // debugging sensor list 150 mUserSensorListDebug = mSensorList; 151 152 mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED; 153 FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r"); 154 char line[128]; 155 if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) { 156 line[sizeof(line) - 1] = '\0'; 157 sscanf(line, "%zu", &mSocketBufferSize); 158 if (mSocketBufferSize > MAX_SOCKET_BUFFER_SIZE_BATCHED) { 159 mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED; 160 } 161 } 162 if (fp) { 163 fclose(fp); 164 } 165 166 mWakeLockAcquired = false; 167 run("SensorService", PRIORITY_URGENT_DISPLAY); 168 mInitCheck = NO_ERROR; 169 } 170 } 171} 172 173Sensor SensorService::registerSensor(SensorInterface* s) 174{ 175 sensors_event_t event; 176 memset(&event, 0, sizeof(event)); 177 178 const Sensor sensor(s->getSensor()); 179 // add to the sensor list (returned to clients) 180 mSensorList.add(sensor); 181 // add to our handle->SensorInterface mapping 182 mSensorMap.add(sensor.getHandle(), s); 183 // create an entry in the mLastEventSeen array 184 mLastEventSeen.add(sensor.getHandle(), event); 185 186 return sensor; 187} 188 189Sensor SensorService::registerVirtualSensor(SensorInterface* s) 190{ 191 Sensor sensor = registerSensor(s); 192 mVirtualSensorList.add( s ); 193 return sensor; 194} 195 196SensorService::~SensorService() 197{ 198 for (size_t i=0 ; i<mSensorMap.size() ; i++) 199 delete mSensorMap.valueAt(i); 200} 201 202static const String16 sDump("android.permission.DUMP"); 203 204status_t SensorService::dump(int fd, const Vector<String16>& /*args*/) 205{ 206 String8 result; 207 if (!PermissionCache::checkCallingPermission(sDump)) { 208 result.appendFormat("Permission Denial: " 209 "can't dump SensorService from pid=%d, uid=%d\n", 210 IPCThreadState::self()->getCallingPid(), 211 IPCThreadState::self()->getCallingUid()); 212 } else { 213 Mutex::Autolock _l(mLock); 214 result.append("Sensor List:\n"); 215 for (size_t i=0 ; i<mSensorList.size() ; i++) { 216 const Sensor& s(mSensorList[i]); 217 const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle())); 218 result.appendFormat( 219 "%-48s| %-32s| %-48s| 0x%08x | \"%s\"\n\t", 220 s.getName().string(), 221 s.getVendor().string(), 222 s.getStringType().string(), 223 s.getHandle(), 224 s.getRequiredPermission().string()); 225 226 if (s.getMinDelay() > 0) { 227 result.appendFormat( 228 "maxRate=%7.2fHz | ", 1e6f / s.getMinDelay()); 229 } else { 230 result.append(s.getMinDelay() == 0 231 ? "on-demand | " 232 : "one-shot | "); 233 } 234 if (s.getFifoMaxEventCount() > 0) { 235 result.appendFormat("FifoMax=%d events | ", 236 s.getFifoMaxEventCount()); 237 } else { 238 result.append("no batching support | "); 239 } 240 241 switch (s.getType()) { 242 case SENSOR_TYPE_ROTATION_VECTOR: 243 case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 244 result.appendFormat( 245 "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n", 246 e.data[0], e.data[1], e.data[2], e.data[3], e.data[4]); 247 break; 248 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 249 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 250 result.appendFormat( 251 "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n", 252 e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.data[5]); 253 break; 254 case SENSOR_TYPE_GAME_ROTATION_VECTOR: 255 result.appendFormat( 256 "last=<%5.1f,%5.1f,%5.1f,%5.1f>\n", 257 e.data[0], e.data[1], e.data[2], e.data[3]); 258 break; 259 case SENSOR_TYPE_SIGNIFICANT_MOTION: 260 case SENSOR_TYPE_STEP_DETECTOR: 261 result.appendFormat( "last=<%f>\n", e.data[0]); 262 break; 263 case SENSOR_TYPE_STEP_COUNTER: 264 result.appendFormat( "last=<%" PRIu64 ">\n", e.u64.step_counter); 265 break; 266 default: 267 // default to 3 values 268 result.appendFormat( 269 "last=<%5.1f,%5.1f,%5.1f>\n", 270 e.data[0], e.data[1], e.data[2]); 271 break; 272 } 273 } 274 SensorFusion::getInstance().dump(result); 275 SensorDevice::getInstance().dump(result); 276 277 result.append("Active sensors:\n"); 278 for (size_t i=0 ; i<mActiveSensors.size() ; i++) { 279 int handle = mActiveSensors.keyAt(i); 280 result.appendFormat("%s (handle=0x%08x, connections=%zu)\n", 281 getSensorName(handle).string(), 282 handle, 283 mActiveSensors.valueAt(i)->getNumConnections()); 284 } 285 286 result.appendFormat("%zu Max Socket Buffer size\n", mSocketBufferSize); 287 result.appendFormat("WakeLock Status: %s \n", mWakeLockAcquired ? "acquired" : "not held"); 288 result.appendFormat("%zd active connections\n", mActiveConnections.size()); 289 290 for (size_t i=0 ; i < mActiveConnections.size() ; i++) { 291 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 292 if (connection != 0) { 293 result.appendFormat("Connection Number: %zu \n", i); 294 connection->dump(result); 295 } 296 } 297 } 298 write(fd, result.string(), result.size()); 299 return NO_ERROR; 300} 301 302void SensorService::cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection, 303 sensors_event_t const* buffer, const int count) { 304 SensorInterface* sensor; 305 status_t err = NO_ERROR; 306 for (int i=0 ; i<count ; i++) { 307 int handle = buffer[i].sensor; 308 int type = buffer[i].type; 309 if (type == SENSOR_TYPE_SIGNIFICANT_MOTION) { 310 if (connection->hasSensor(handle)) { 311 sensor = mSensorMap.valueFor(handle); 312 if (sensor != NULL) { 313 sensor->autoDisable(connection.get(), handle); 314 } 315 cleanupWithoutDisableLocked(connection, handle); 316 } 317 } 318 } 319} 320 321bool SensorService::threadLoop() 322{ 323 ALOGD("nuSensorService thread starting..."); 324 325 // each virtual sensor could generate an event per "real" event, that's why we need 326 // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT. 327 // in practice, this is too aggressive, but guaranteed to be enough. 328 const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 329 const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size()); 330 331 sensors_event_t buffer[minBufferSize]; 332 sensors_event_t scratch[minBufferSize]; 333 SensorDevice& device(SensorDevice::getInstance()); 334 const size_t vcount = mVirtualSensorList.size(); 335 336 ssize_t count; 337 const int halVersion = device.getHalDeviceVersion(); 338 do { 339 count = device.poll(buffer, numEventMax); 340 if (count<0) { 341 ALOGE("sensor poll failed (%s)", strerror(-count)); 342 break; 343 } 344 Mutex::Autolock _l(mLock); 345 // Poll has returned. Hold a wakelock if one of the events is from a wake up sensor. The 346 // rest of this loop is under a critical section protected by mLock. Acquiring a wakeLock, 347 // sending events to clients (incrementing SensorEventConnection::mWakeLockRefCount) should 348 // not be interleaved with decrementing SensorEventConnection::mWakeLockRefCount and 349 // releasing the wakelock. 350 bool bufferHasWakeUpEvent = false; 351 for (int i = 0; i < count; i++) { 352 if (isWakeUpSensorEvent(buffer[i])) { 353 bufferHasWakeUpEvent = true; 354 break; 355 } 356 } 357 358 if (bufferHasWakeUpEvent && !mWakeLockAcquired) { 359 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 360 mWakeLockAcquired = true; 361 ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock %s", WAKE_LOCK_NAME); 362 } 363 recordLastValueLocked(buffer, count); 364 365 // handle virtual sensors 366 if (count && vcount) { 367 sensors_event_t const * const event = buffer; 368 const size_t activeVirtualSensorCount = mActiveVirtualSensors.size(); 369 if (activeVirtualSensorCount) { 370 size_t k = 0; 371 SensorFusion& fusion(SensorFusion::getInstance()); 372 if (fusion.isEnabled()) { 373 for (size_t i=0 ; i<size_t(count) ; i++) { 374 fusion.process(event[i]); 375 } 376 } 377 for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) { 378 for (size_t j=0 ; j<activeVirtualSensorCount ; j++) { 379 if (count + k >= minBufferSize) { 380 ALOGE("buffer too small to hold all events: " 381 "count=%u, k=%u, size=%u", 382 count, k, minBufferSize); 383 break; 384 } 385 sensors_event_t out; 386 SensorInterface* si = mActiveVirtualSensors.valueAt(j); 387 if (si->process(&out, event[i])) { 388 buffer[count + k] = out; 389 k++; 390 } 391 } 392 } 393 if (k) { 394 // record the last synthesized values 395 recordLastValueLocked(&buffer[count], k); 396 count += k; 397 // sort the buffer by time-stamps 398 sortEventBuffer(buffer, count); 399 } 400 } 401 } 402 403 // handle backward compatibility for RotationVector sensor 404 if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) { 405 for (int i = 0; i < count; i++) { 406 if (buffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) { 407 // All the 4 components of the quaternion should be available 408 // No heading accuracy. Set it to -1 409 buffer[i].data[4] = -1; 410 } 411 } 412 } 413 414 // Send our events to clients. Check the state of wake lock for each client and release the 415 // lock if none of the clients need it. 416 bool needsWakeLock = false; 417 for (size_t i=0 ; i < mActiveConnections.size(); i++) { 418 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 419 if (connection != 0) { 420 connection->sendEvents(buffer, count, scratch); 421 needsWakeLock |= connection->needsWakeLock(); 422 // Some sensors need to be auto disabled after the trigger 423 cleanupAutoDisabledSensorLocked(connection, buffer, count); 424 } 425 } 426 427 if (mWakeLockAcquired && !needsWakeLock) { 428 release_wake_lock(WAKE_LOCK_NAME); 429 mWakeLockAcquired = false; 430 ALOGD_IF(DEBUG_CONNECTIONS, "released wakelock %s", WAKE_LOCK_NAME); 431 } 432 } while (count >= 0 || Thread::exitPending()); 433 434 ALOGW("Exiting SensorService::threadLoop => aborting..."); 435 abort(); 436 return false; 437} 438 439void SensorService::recordLastValueLocked( 440 const sensors_event_t* buffer, size_t count) { 441 const sensors_event_t* last = NULL; 442 for (size_t i = 0; i < count; i++) { 443 const sensors_event_t* event = &buffer[i]; 444 if (event->type != SENSOR_TYPE_META_DATA) { 445 if (last && event->sensor != last->sensor) { 446 mLastEventSeen.editValueFor(last->sensor) = *last; 447 } 448 last = event; 449 } 450 } 451 if (last) { 452 mLastEventSeen.editValueFor(last->sensor) = *last; 453 } 454} 455 456void SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count) 457{ 458 struct compar { 459 static int cmp(void const* lhs, void const* rhs) { 460 sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs); 461 sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs); 462 return l->timestamp - r->timestamp; 463 } 464 }; 465 qsort(buffer, count, sizeof(sensors_event_t), compar::cmp); 466} 467 468String8 SensorService::getSensorName(int handle) const { 469 size_t count = mUserSensorList.size(); 470 for (size_t i=0 ; i<count ; i++) { 471 const Sensor& sensor(mUserSensorList[i]); 472 if (sensor.getHandle() == handle) { 473 return sensor.getName(); 474 } 475 } 476 String8 result("unknown"); 477 return result; 478} 479 480bool SensorService::isVirtualSensor(int handle) const { 481 SensorInterface* sensor = mSensorMap.valueFor(handle); 482 return sensor->isVirtual(); 483} 484 485bool SensorService::isWakeUpSensorEvent(const sensors_event_t& event) const { 486 SensorInterface* sensor = mSensorMap.valueFor(event.sensor); 487 return sensor->getSensor().isWakeUpSensor(); 488} 489 490Vector<Sensor> SensorService::getSensorList() 491{ 492 char value[PROPERTY_VALUE_MAX]; 493 property_get("debug.sensors", value, "0"); 494 const Vector<Sensor>& initialSensorList = (atoi(value)) ? 495 mUserSensorListDebug : mUserSensorList; 496 Vector<Sensor> accessibleSensorList; 497 for (size_t i = 0; i < initialSensorList.size(); i++) { 498 Sensor sensor = initialSensorList[i]; 499 if (canAccessSensor(sensor)) { 500 accessibleSensorList.add(sensor); 501 } else { 502 String8 infoMessage; 503 infoMessage.appendFormat( 504 "Skipped sensor %s because it requires permission %s", 505 sensor.getName().string(), 506 sensor.getRequiredPermission().string()); 507 ALOGI(infoMessage.string()); 508 } 509 } 510 return accessibleSensorList; 511} 512 513sp<ISensorEventConnection> SensorService::createSensorEventConnection() 514{ 515 uid_t uid = IPCThreadState::self()->getCallingUid(); 516 sp<SensorEventConnection> result(new SensorEventConnection(this, uid)); 517 return result; 518} 519 520void SensorService::cleanupConnection(SensorEventConnection* c) 521{ 522 Mutex::Autolock _l(mLock); 523 const wp<SensorEventConnection> connection(c); 524 size_t size = mActiveSensors.size(); 525 ALOGD_IF(DEBUG_CONNECTIONS, "%d active sensors", size); 526 for (size_t i=0 ; i<size ; ) { 527 int handle = mActiveSensors.keyAt(i); 528 if (c->hasSensor(handle)) { 529 ALOGD_IF(DEBUG_CONNECTIONS, "%i: disabling handle=0x%08x", i, handle); 530 SensorInterface* sensor = mSensorMap.valueFor( handle ); 531 ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle); 532 if (sensor) { 533 sensor->activate(c, false); 534 } 535 } 536 SensorRecord* rec = mActiveSensors.valueAt(i); 537 ALOGE_IF(!rec, "mActiveSensors[%d] is null (handle=0x%08x)!", i, handle); 538 ALOGD_IF(DEBUG_CONNECTIONS, 539 "removing connection %p for sensor[%d].handle=0x%08x", 540 c, i, handle); 541 542 if (rec && rec->removeConnection(connection)) { 543 ALOGD_IF(DEBUG_CONNECTIONS, "... and it was the last connection"); 544 mActiveSensors.removeItemsAt(i, 1); 545 mActiveVirtualSensors.removeItem(handle); 546 delete rec; 547 size--; 548 } else { 549 i++; 550 } 551 } 552 mActiveConnections.remove(connection); 553 BatteryService::cleanup(c->getUid()); 554 if (c->needsWakeLock()) { 555 checkWakeLockStateLocked(); 556 } 557} 558 559Sensor SensorService::getSensorFromHandle(int handle) const { 560 return mSensorMap.valueFor(handle)->getSensor(); 561} 562 563status_t SensorService::enable(const sp<SensorEventConnection>& connection, 564 int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags) 565{ 566 if (mInitCheck != NO_ERROR) 567 return mInitCheck; 568 569 SensorInterface* sensor = mSensorMap.valueFor(handle); 570 if (sensor == NULL) { 571 return BAD_VALUE; 572 } 573 574 if (!verifyCanAccessSensor(sensor->getSensor(), "Tried enabling")) { 575 return BAD_VALUE; 576 } 577 578 Mutex::Autolock _l(mLock); 579 SensorRecord* rec = mActiveSensors.valueFor(handle); 580 if (rec == 0) { 581 rec = new SensorRecord(connection); 582 mActiveSensors.add(handle, rec); 583 if (sensor->isVirtual()) { 584 mActiveVirtualSensors.add(handle, sensor); 585 } 586 } else { 587 if (rec->addConnection(connection)) { 588 // this sensor is already activated, but we are adding a connection that uses it. 589 // Immediately send down the last known value of the requested sensor if it's not a 590 // "continuous" sensor. 591 if (sensor->getSensor().getMinDelay() == 0) { 592 // NOTE: The wake_up flag of this event may get set to 593 // WAKE_UP_SENSOR_EVENT_NEEDS_ACK if this is a wake_up event. 594 sensors_event_t& event(mLastEventSeen.editValueFor(handle)); 595 if (event.version == sizeof(sensors_event_t)) { 596 if (isWakeUpSensorEvent(event) && !mWakeLockAcquired) { 597 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 598 mWakeLockAcquired = true; 599 ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock for on_change sensor %s", 600 WAKE_LOCK_NAME); 601 } 602 connection->sendEvents(&event, 1, NULL); 603 if (!connection->needsWakeLock() && mWakeLockAcquired) { 604 checkWakeLockStateLocked(); 605 } 606 } 607 } 608 } 609 } 610 611 if (connection->addSensor(handle)) { 612 BatteryService::enableSensor(connection->getUid(), handle); 613 // the sensor was added (which means it wasn't already there) 614 // so, see if this connection becomes active 615 if (mActiveConnections.indexOf(connection) < 0) { 616 mActiveConnections.add(connection); 617 } 618 } else { 619 ALOGW("sensor %08x already enabled in connection %p (ignoring)", 620 handle, connection.get()); 621 } 622 623 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 624 if (samplingPeriodNs < minDelayNs) { 625 samplingPeriodNs = minDelayNs; 626 } 627 628 ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d rate=%lld timeout== %lld", 629 handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs); 630 631 status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs, 632 maxBatchReportLatencyNs); 633 if (err == NO_ERROR) { 634 connection->setFirstFlushPending(handle, true); 635 status_t err_flush = sensor->flush(connection.get(), handle); 636 // Flush may return error if the sensor is not activated or the underlying h/w sensor does 637 // not support flush. 638 if (err_flush != NO_ERROR) { 639 connection->setFirstFlushPending(handle, false); 640 } 641 } 642 643 if (err == NO_ERROR) { 644 ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle); 645 err = sensor->activate(connection.get(), true); 646 } 647 648 if (err != NO_ERROR) { 649 // batch/activate has failed, reset our state. 650 cleanupWithoutDisableLocked(connection, handle); 651 } 652 return err; 653} 654 655status_t SensorService::disable(const sp<SensorEventConnection>& connection, 656 int handle) 657{ 658 if (mInitCheck != NO_ERROR) 659 return mInitCheck; 660 661 Mutex::Autolock _l(mLock); 662 status_t err = cleanupWithoutDisableLocked(connection, handle); 663 if (err == NO_ERROR) { 664 SensorInterface* sensor = mSensorMap.valueFor(handle); 665 err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE); 666 } 667 return err; 668} 669 670status_t SensorService::cleanupWithoutDisable( 671 const sp<SensorEventConnection>& connection, int handle) { 672 Mutex::Autolock _l(mLock); 673 return cleanupWithoutDisableLocked(connection, handle); 674} 675 676status_t SensorService::cleanupWithoutDisableLocked( 677 const sp<SensorEventConnection>& connection, int handle) { 678 SensorRecord* rec = mActiveSensors.valueFor(handle); 679 if (rec) { 680 // see if this connection becomes inactive 681 if (connection->removeSensor(handle)) { 682 BatteryService::disableSensor(connection->getUid(), handle); 683 } 684 if (connection->hasAnySensor() == false) { 685 mActiveConnections.remove(connection); 686 } 687 // see if this sensor becomes inactive 688 if (rec->removeConnection(connection)) { 689 mActiveSensors.removeItem(handle); 690 mActiveVirtualSensors.removeItem(handle); 691 delete rec; 692 } 693 return NO_ERROR; 694 } 695 return BAD_VALUE; 696} 697 698status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection, 699 int handle, nsecs_t ns) 700{ 701 if (mInitCheck != NO_ERROR) 702 return mInitCheck; 703 704 SensorInterface* sensor = mSensorMap.valueFor(handle); 705 if (!sensor) 706 return BAD_VALUE; 707 708 if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) { 709 return BAD_VALUE; 710 } 711 712 if (ns < 0) 713 return BAD_VALUE; 714 715 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 716 if (ns < minDelayNs) { 717 ns = minDelayNs; 718 } 719 720 return sensor->setDelay(connection.get(), handle, ns); 721} 722 723status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection, 724 int handle) { 725 if (mInitCheck != NO_ERROR) return mInitCheck; 726 SensorInterface* sensor = mSensorMap.valueFor(handle); 727 if (sensor == NULL) { 728 return BAD_VALUE; 729 } 730 731 if (!verifyCanAccessSensor(sensor->getSensor(), "Tried flushing")) { 732 return BAD_VALUE; 733 } 734 735 if (sensor->getSensor().getType() == SENSOR_TYPE_SIGNIFICANT_MOTION) { 736 ALOGE("flush called on Significant Motion sensor"); 737 return INVALID_OPERATION; 738 } 739 return sensor->flush(connection.get(), handle); 740} 741 742 743bool SensorService::canAccessSensor(const Sensor& sensor) { 744 String16 permissionString(sensor.getRequiredPermission()); 745 return permissionString.size() == 0 || 746 PermissionCache::checkCallingPermission(permissionString); 747} 748 749bool SensorService::verifyCanAccessSensor(const Sensor& sensor, const char* operation) { 750 if (canAccessSensor(sensor)) { 751 return true; 752 } else { 753 String8 errorMessage; 754 errorMessage.appendFormat( 755 "%s a sensor (%s) without holding its required permission: %s", 756 operation, 757 sensor.getName().string(), 758 sensor.getRequiredPermission().string()); 759 return false; 760 } 761} 762 763void SensorService::checkWakeLockState() { 764 Mutex::Autolock _l(mLock); 765 checkWakeLockStateLocked(); 766} 767 768void SensorService::checkWakeLockStateLocked() { 769 if (!mWakeLockAcquired) { 770 return; 771 } 772 bool releaseLock = true; 773 for (size_t i=0 ; i<mActiveConnections.size() ; i++) { 774 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 775 if (connection != 0) { 776 if (connection->needsWakeLock()) { 777 releaseLock = false; 778 break; 779 } 780 } 781 } 782 if (releaseLock) { 783 ALOGD_IF(DEBUG_CONNECTIONS, "releasing wakelock %s", WAKE_LOCK_NAME); 784 release_wake_lock(WAKE_LOCK_NAME); 785 mWakeLockAcquired = false; 786 } 787} 788// --------------------------------------------------------------------------- 789 790SensorService::SensorRecord::SensorRecord( 791 const sp<SensorEventConnection>& connection) 792{ 793 mConnections.add(connection); 794} 795 796bool SensorService::SensorRecord::addConnection( 797 const sp<SensorEventConnection>& connection) 798{ 799 if (mConnections.indexOf(connection) < 0) { 800 mConnections.add(connection); 801 return true; 802 } 803 return false; 804} 805 806bool SensorService::SensorRecord::removeConnection( 807 const wp<SensorEventConnection>& connection) 808{ 809 ssize_t index = mConnections.indexOf(connection); 810 if (index >= 0) { 811 mConnections.removeItemsAt(index, 1); 812 } 813 return mConnections.size() ? false : true; 814} 815 816// --------------------------------------------------------------------------- 817 818SensorService::SensorEventConnection::SensorEventConnection( 819 const sp<SensorService>& service, uid_t uid) 820 : mService(service), mUid(uid), mWakeLockRefCount(0) 821{ 822 const SensorDevice& device(SensorDevice::getInstance()); 823 if (device.getHalDeviceVersion() >= SENSORS_DEVICE_API_VERSION_1_1) { 824 // Increase socket buffer size to 1MB for batching capabilities. 825 mChannel = new BitTube(service->mSocketBufferSize); 826 } else { 827 mChannel = new BitTube(SOCKET_BUFFER_SIZE_NON_BATCHED); 828 } 829} 830 831SensorService::SensorEventConnection::~SensorEventConnection() 832{ 833 ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this); 834 mService->cleanupConnection(this); 835} 836 837void SensorService::SensorEventConnection::onFirstRef() 838{ 839} 840 841bool SensorService::SensorEventConnection::needsWakeLock() { 842 Mutex::Autolock _l(mConnectionLock); 843 return mWakeLockRefCount > 0; 844} 845 846void SensorService::SensorEventConnection::dump(String8& result) { 847 Mutex::Autolock _l(mConnectionLock); 848 result.appendFormat("%d WakeLockRefCount\n", mWakeLockRefCount); 849 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 850 const FlushInfo& flushInfo = mSensorInfo.valueAt(i); 851 result.appendFormat("\t %s | status: %s | pending flush events %d | uid %d\n", 852 mService->getSensorName(mSensorInfo.keyAt(i)).string(), 853 flushInfo.mFirstFlushPending ? "First flush pending" : 854 "active", 855 flushInfo.mPendingFlushEventsToSend, 856 mUid); 857 } 858} 859 860bool SensorService::SensorEventConnection::addSensor(int32_t handle) { 861 Mutex::Autolock _l(mConnectionLock); 862 if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) { 863 return false; 864 } 865 if (mSensorInfo.indexOfKey(handle) < 0) { 866 mSensorInfo.add(handle, FlushInfo()); 867 return true; 868 } 869 return false; 870} 871 872bool SensorService::SensorEventConnection::removeSensor(int32_t handle) { 873 Mutex::Autolock _l(mConnectionLock); 874 if (mSensorInfo.removeItem(handle) >= 0) { 875 return true; 876 } 877 return false; 878} 879 880bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const { 881 Mutex::Autolock _l(mConnectionLock); 882 return mSensorInfo.indexOfKey(handle) >= 0; 883} 884 885bool SensorService::SensorEventConnection::hasAnySensor() const { 886 Mutex::Autolock _l(mConnectionLock); 887 return mSensorInfo.size() ? true : false; 888} 889 890void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle, 891 bool value) { 892 Mutex::Autolock _l(mConnectionLock); 893 ssize_t index = mSensorInfo.indexOfKey(handle); 894 if (index >= 0) { 895 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 896 flushInfo.mFirstFlushPending = value; 897 } 898} 899 900status_t SensorService::SensorEventConnection::sendEvents( 901 sensors_event_t const* buffer, size_t numEvents, 902 sensors_event_t* scratch) 903{ 904 // filter out events not for this connection 905 size_t count = 0; 906 Mutex::Autolock _l(mConnectionLock); 907 if (scratch) { 908 size_t i=0; 909 while (i<numEvents) { 910 int32_t curr = buffer[i].sensor; 911 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 912 ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ", 913 buffer[i].meta_data.sensor); 914 // Setting curr to the correct sensor to ensure the sensor events per connection are 915 // filtered correctly. buffer[i].sensor is zero for meta_data events. 916 curr = buffer[i].meta_data.sensor; 917 } 918 ssize_t index = mSensorInfo.indexOfKey(curr); 919 if (index >= 0 && mSensorInfo[index].mFirstFlushPending == true && 920 buffer[i].type == SENSOR_TYPE_META_DATA) { 921 // This is the first flush before activate is called. Events can now be sent for 922 // this sensor on this connection. 923 ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ", 924 buffer[i].meta_data.sensor); 925 mSensorInfo.editValueAt(index).mFirstFlushPending = false; 926 } 927 if (index >= 0 && mSensorInfo[index].mFirstFlushPending == false) { 928 do { 929 scratch[count++] = buffer[i++]; 930 } while ((i<numEvents) && ((buffer[i].sensor == curr) || 931 (buffer[i].type == SENSOR_TYPE_META_DATA && 932 buffer[i].meta_data.sensor == curr))); 933 } else { 934 i++; 935 } 936 } 937 } else { 938 scratch = const_cast<sensors_event_t *>(buffer); 939 count = numEvents; 940 } 941 942 // Send pending flush events (if any) before sending events from the cache. 943 { 944 ASensorEvent flushCompleteEvent; 945 flushCompleteEvent.type = SENSOR_TYPE_META_DATA; 946 flushCompleteEvent.sensor = 0; 947 // Loop through all the sensors for this connection and check if there are any pending 948 // flush complete events to be sent. 949 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 950 FlushInfo& flushInfo = mSensorInfo.editValueAt(i); 951 while (flushInfo.mPendingFlushEventsToSend > 0) { 952 flushCompleteEvent.meta_data.sensor = mSensorInfo.keyAt(i); 953 ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1); 954 if (size < 0) { 955 // ALOGW("dropping %d events on the floor", count); 956 countFlushCompleteEventsLocked(scratch, count); 957 return size; 958 } 959 ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ", 960 flushCompleteEvent.meta_data.sensor); 961 flushInfo.mPendingFlushEventsToSend--; 962 } 963 } 964 } 965 966 // Early return if there are no events for this connection. 967 if (count == 0) { 968 return status_t(NO_ERROR); 969 } 970 971 int numWakeUpSensorEvents = countWakeUpSensorEventsLocked(scratch, count); 972 // NOTE: ASensorEvent and sensors_event_t are the same type 973 ssize_t size = SensorEventQueue::write(mChannel, 974 reinterpret_cast<ASensorEvent const*>(scratch), count); 975 if (size == -EAGAIN) { 976 // the destination doesn't accept events anymore, it's probably 977 // full. For now, we just drop the events on the floor. 978 // ALOGW("dropping %d events on the floor", count); 979 countFlushCompleteEventsLocked(scratch, count); 980 mWakeLockRefCount -= numWakeUpSensorEvents; 981 return size; 982 } 983 return size < 0 ? status_t(size) : status_t(NO_ERROR); 984} 985 986void SensorService::SensorEventConnection::countFlushCompleteEventsLocked( 987 sensors_event_t* scratch, const int numEventsDropped) { 988 ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped); 989 // Count flushComplete events in the events that are about to the dropped. These will be sent 990 // separately before the next batch of events. 991 for (int j = 0; j < numEventsDropped; ++j) { 992 if (scratch[j].type == SENSOR_TYPE_META_DATA) { 993 FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor); 994 flushInfo.mPendingFlushEventsToSend++; 995 ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d", 996 flushInfo.mPendingFlushEventsToSend); 997 } 998 } 999 return; 1000} 1001 1002int SensorService::SensorEventConnection::countWakeUpSensorEventsLocked( 1003 sensors_event_t* scratch, const int count) { 1004 for (int i = 0; i < count; ++i) { 1005 if (mService->isWakeUpSensorEvent(scratch[i])) { 1006 scratch[i].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1007 ++mWakeLockRefCount; 1008 return 1; 1009 } 1010 } 1011 return 0; 1012} 1013 1014sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const 1015{ 1016 return mChannel; 1017} 1018 1019status_t SensorService::SensorEventConnection::enableDisable( 1020 int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, 1021 int reservedFlags) 1022{ 1023 status_t err; 1024 if (enabled) { 1025 err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs, 1026 reservedFlags); 1027 } else { 1028 err = mService->disable(this, handle); 1029 } 1030 return err; 1031} 1032 1033status_t SensorService::SensorEventConnection::setEventRate( 1034 int handle, nsecs_t samplingPeriodNs) 1035{ 1036 return mService->setEventRate(this, handle, samplingPeriodNs); 1037} 1038 1039status_t SensorService::SensorEventConnection::flush() { 1040 SensorDevice& dev(SensorDevice::getInstance()); 1041 const int halVersion = dev.getHalDeviceVersion(); 1042 Mutex::Autolock _l(mConnectionLock); 1043 status_t err(NO_ERROR); 1044 // Loop through all sensors for this connection and call flush on each of them. 1045 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1046 const int handle = mSensorInfo.keyAt(i); 1047 if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 || mService->isVirtualSensor(handle)) { 1048 // For older devices just increment pending flush count which will send a trivial 1049 // flush complete event. 1050 FlushInfo& flushInfo = mSensorInfo.editValueFor(handle); 1051 flushInfo.mPendingFlushEventsToSend++; 1052 } else { 1053 status_t err_flush = mService->flushSensor(this, handle); 1054 if (err_flush != NO_ERROR) { 1055 ALOGE("Flush error handle=%d %s", handle, strerror(-err_flush)); 1056 } 1057 err = (err_flush != NO_ERROR) ? err_flush : err; 1058 } 1059 } 1060 return err; 1061} 1062 1063void SensorService::SensorEventConnection::decreaseWakeLockRefCount() { 1064 { 1065 Mutex::Autolock _l(mConnectionLock); 1066 --mWakeLockRefCount; 1067 } 1068 // Release the lock before calling checkWakeLockState which also needs the same connectionLock. 1069 if (mWakeLockRefCount == 0) { 1070 mService->checkWakeLockState(); 1071 } 1072} 1073 1074// --------------------------------------------------------------------------- 1075}; // namespace android 1076 1077