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 #include <sys/socket.h> 22 23 #include <cutils/properties.h> 24 25 #include <utils/SortedVector.h> 26 #include <utils/KeyedVector.h> 27 #include <utils/threads.h> 28 #include <utils/Atomic.h> 29 #include <utils/Errors.h> 30 #include <utils/RefBase.h> 31 #include <utils/Singleton.h> 32 #include <utils/String16.h> 33 34 #include <binder/BinderService.h> 35 #include <binder/IServiceManager.h> 36 #include <binder/PermissionCache.h> 37 38 #include <gui/ISensorServer.h> 39 #include <gui/ISensorEventConnection.h> 40 #include <gui/SensorEventQueue.h> 41 42 #include <hardware/sensors.h> 43 #include <hardware_legacy/power.h> 44 45 #include "BatteryService.h" 46 #include "CorrectedGyroSensor.h" 47 #include "GravitySensor.h" 48 #include "LinearAccelerationSensor.h" 49 #include "OrientationSensor.h" 50 #include "RotationVectorSensor.h" 51 #include "SensorFusion.h" 52 #include "SensorService.h" 53 54 namespace android { 55 // --------------------------------------------------------------------------- 56 57 /* 58 * Notes: 59 * 60 * - what about a gyro-corrected magnetic-field sensor? 61 * - run mag sensor from time to time to force calibration 62 * - gravity sensor length is wrong (=> drift in linear-acc sensor) 63 * 64 */ 65 66 const char* SensorService::WAKE_LOCK_NAME = "SensorService"; 67 68 SensorService::SensorService() 69 : mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED), 70 mWakeLockAcquired(false) 71 { 72 } 73 74 void SensorService::onFirstRef() 75 { 76 ALOGD("nuSensorService starting..."); 77 78 SensorDevice& dev(SensorDevice::getInstance()); 79 80 if (dev.initCheck() == NO_ERROR) { 81 sensor_t const* list; 82 ssize_t count = dev.getSensorList(&list); 83 if (count > 0) { 84 ssize_t orientationIndex = -1; 85 bool hasGyro = false; 86 uint32_t virtualSensorsNeeds = 87 (1<<SENSOR_TYPE_GRAVITY) | 88 (1<<SENSOR_TYPE_LINEAR_ACCELERATION) | 89 (1<<SENSOR_TYPE_ROTATION_VECTOR); 90 91 mLastEventSeen.setCapacity(count); 92 for (ssize_t i=0 ; i<count ; i++) { 93 registerSensor( new HardwareSensor(list[i]) ); 94 switch (list[i].type) { 95 case SENSOR_TYPE_ORIENTATION: 96 orientationIndex = i; 97 break; 98 case SENSOR_TYPE_GYROSCOPE: 99 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 100 hasGyro = true; 101 break; 102 case SENSOR_TYPE_GRAVITY: 103 case SENSOR_TYPE_LINEAR_ACCELERATION: 104 case SENSOR_TYPE_ROTATION_VECTOR: 105 virtualSensorsNeeds &= ~(1<<list[i].type); 106 break; 107 } 108 } 109 110 // it's safe to instantiate the SensorFusion object here 111 // (it wants to be instantiated after h/w sensors have been 112 // registered) 113 const SensorFusion& fusion(SensorFusion::getInstance()); 114 115 // build the sensor list returned to users 116 mUserSensorList = mSensorList; 117 118 if (hasGyro) { 119 Sensor aSensor; 120 121 // Add Android virtual sensors if they're not already 122 // available in the HAL 123 124 aSensor = registerVirtualSensor( new RotationVectorSensor() ); 125 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 126 mUserSensorList.add(aSensor); 127 } 128 129 aSensor = registerVirtualSensor( new GravitySensor(list, count) ); 130 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) { 131 mUserSensorList.add(aSensor); 132 } 133 134 aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) ); 135 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) { 136 mUserSensorList.add(aSensor); 137 } 138 139 aSensor = registerVirtualSensor( new OrientationSensor() ); 140 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 141 // if we are doing our own rotation-vector, also add 142 // the orientation sensor and remove the HAL provided one. 143 mUserSensorList.replaceAt(aSensor, orientationIndex); 144 } 145 146 // virtual debugging sensors are not added to mUserSensorList 147 registerVirtualSensor( new CorrectedGyroSensor(list, count) ); 148 registerVirtualSensor( new GyroDriftSensor() ); 149 } 150 151 // debugging sensor list 152 mUserSensorListDebug = mSensorList; 153 154 // Check if the device really supports batching by looking at the FIFO event 155 // counts for each sensor. 156 bool batchingSupported = false; 157 for (int i = 0; i < mSensorList.size(); ++i) { 158 if (mSensorList[i].getFifoMaxEventCount() > 0) { 159 batchingSupported = true; 160 break; 161 } 162 } 163 164 if (batchingSupported) { 165 // Increase socket buffer size to a max of 100 KB for batching capabilities. 166 mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED; 167 } else { 168 mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED; 169 } 170 171 // Compare the socketBufferSize value against the system limits and limit 172 // it to maxSystemSocketBufferSize if necessary. 173 FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r"); 174 char line[128]; 175 if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) { 176 line[sizeof(line) - 1] = '\0'; 177 size_t maxSystemSocketBufferSize; 178 sscanf(line, "%zu", &maxSystemSocketBufferSize); 179 if (mSocketBufferSize > maxSystemSocketBufferSize) { 180 mSocketBufferSize = maxSystemSocketBufferSize; 181 } 182 } 183 if (fp) { 184 fclose(fp); 185 } 186 187 mWakeLockAcquired = false; 188 mLooper = new Looper(false); 189 const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 190 mSensorEventBuffer = new sensors_event_t[minBufferSize]; 191 mSensorEventScratch = new sensors_event_t[minBufferSize]; 192 mMapFlushEventsToConnections = new SensorEventConnection const * [minBufferSize]; 193 194 mAckReceiver = new SensorEventAckReceiver(this); 195 mAckReceiver->run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY); 196 mInitCheck = NO_ERROR; 197 run("SensorService", PRIORITY_URGENT_DISPLAY); 198 } 199 } 200 } 201 202 Sensor SensorService::registerSensor(SensorInterface* s) 203 { 204 sensors_event_t event; 205 memset(&event, 0, sizeof(event)); 206 207 const Sensor sensor(s->getSensor()); 208 // add to the sensor list (returned to clients) 209 mSensorList.add(sensor); 210 // add to our handle->SensorInterface mapping 211 mSensorMap.add(sensor.getHandle(), s); 212 // create an entry in the mLastEventSeen array 213 mLastEventSeen.add(sensor.getHandle(), event); 214 215 return sensor; 216 } 217 218 Sensor SensorService::registerVirtualSensor(SensorInterface* s) 219 { 220 Sensor sensor = registerSensor(s); 221 mVirtualSensorList.add( s ); 222 return sensor; 223 } 224 225 SensorService::~SensorService() 226 { 227 for (size_t i=0 ; i<mSensorMap.size() ; i++) 228 delete mSensorMap.valueAt(i); 229 } 230 231 static const String16 sDump("android.permission.DUMP"); 232 233 status_t SensorService::dump(int fd, const Vector<String16>& /*args*/) 234 { 235 String8 result; 236 if (!PermissionCache::checkCallingPermission(sDump)) { 237 result.appendFormat("Permission Denial: " 238 "can't dump SensorService from pid=%d, uid=%d\n", 239 IPCThreadState::self()->getCallingPid(), 240 IPCThreadState::self()->getCallingUid()); 241 } else { 242 Mutex::Autolock _l(mLock); 243 result.append("Sensor List:\n"); 244 for (size_t i=0 ; i<mSensorList.size() ; i++) { 245 const Sensor& s(mSensorList[i]); 246 const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle())); 247 result.appendFormat( 248 "%-15s| %-10s| version=%d |%-20s| 0x%08x | \"%s\" | type=%d |", 249 s.getName().string(), 250 s.getVendor().string(), 251 s.getVersion(), 252 s.getStringType().string(), 253 s.getHandle(), 254 s.getRequiredPermission().string(), 255 s.getType()); 256 257 const int reportingMode = s.getReportingMode(); 258 if (reportingMode == AREPORTING_MODE_CONTINUOUS) { 259 result.append(" continuous | "); 260 } else if (reportingMode == AREPORTING_MODE_ON_CHANGE) { 261 result.append(" on-change | "); 262 } else if (reportingMode == AREPORTING_MODE_ONE_SHOT) { 263 result.append(" one-shot | "); 264 } else { 265 result.append(" special-trigger | "); 266 } 267 268 if (s.getMaxDelay() > 0) { 269 result.appendFormat("minRate=%.2fHz | ", 1e6f / s.getMaxDelay()); 270 } else { 271 result.appendFormat("maxDelay=%dus |", s.getMaxDelay()); 272 } 273 274 if (s.getMinDelay() > 0) { 275 result.appendFormat("maxRate=%.2fHz | ", 1e6f / s.getMinDelay()); 276 } else { 277 result.appendFormat("minDelay=%dus |", s.getMinDelay()); 278 } 279 280 if (s.getFifoMaxEventCount() > 0) { 281 result.appendFormat("FifoMax=%d events | ", 282 s.getFifoMaxEventCount()); 283 } else { 284 result.append("no batching | "); 285 } 286 287 if (s.isWakeUpSensor()) { 288 result.appendFormat("wakeUp | "); 289 } else { 290 result.appendFormat("non-wakeUp | "); 291 } 292 293 switch (s.getType()) { 294 case SENSOR_TYPE_ROTATION_VECTOR: 295 case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 296 result.appendFormat( 297 "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 298 e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.timestamp); 299 break; 300 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 301 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 302 result.appendFormat( 303 "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 304 e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.data[5], 305 e.timestamp); 306 break; 307 case SENSOR_TYPE_GAME_ROTATION_VECTOR: 308 result.appendFormat( 309 "last=<%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 310 e.data[0], e.data[1], e.data[2], e.data[3], e.timestamp); 311 break; 312 case SENSOR_TYPE_SIGNIFICANT_MOTION: 313 case SENSOR_TYPE_STEP_DETECTOR: 314 result.appendFormat( "last=<%f %" PRId64 ">\n", e.data[0], e.timestamp); 315 break; 316 case SENSOR_TYPE_STEP_COUNTER: 317 result.appendFormat( "last=<%" PRIu64 ", %" PRId64 ">\n", e.u64.step_counter, 318 e.timestamp); 319 break; 320 default: 321 // default to 3 values 322 result.appendFormat( 323 "last=<%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 324 e.data[0], e.data[1], e.data[2], e.timestamp); 325 break; 326 } 327 result.append("\n"); 328 } 329 SensorFusion::getInstance().dump(result); 330 SensorDevice::getInstance().dump(result); 331 332 result.append("Active sensors:\n"); 333 for (size_t i=0 ; i<mActiveSensors.size() ; i++) { 334 int handle = mActiveSensors.keyAt(i); 335 result.appendFormat("%s (handle=0x%08x, connections=%zu)\n", 336 getSensorName(handle).string(), 337 handle, 338 mActiveSensors.valueAt(i)->getNumConnections()); 339 } 340 341 result.appendFormat("Socket Buffer size = %d events\n", 342 mSocketBufferSize/sizeof(sensors_event_t)); 343 result.appendFormat("WakeLock Status: %s \n", mWakeLockAcquired ? "acquired" : "not held"); 344 result.appendFormat("%zd active connections\n", mActiveConnections.size()); 345 346 for (size_t i=0 ; i < mActiveConnections.size() ; i++) { 347 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 348 if (connection != 0) { 349 result.appendFormat("Connection Number: %zu \n", i); 350 connection->dump(result); 351 } 352 } 353 } 354 write(fd, result.string(), result.size()); 355 return NO_ERROR; 356 } 357 358 void SensorService::cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection, 359 sensors_event_t const* buffer, const int count) { 360 for (int i=0 ; i<count ; i++) { 361 int handle = buffer[i].sensor; 362 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 363 handle = buffer[i].meta_data.sensor; 364 } 365 if (connection->hasSensor(handle)) { 366 SensorInterface* sensor = mSensorMap.valueFor(handle); 367 // If this buffer has an event from a one_shot sensor and this connection is registered 368 // for this particular one_shot sensor, try cleaning up the connection. 369 if (sensor != NULL && 370 sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 371 sensor->autoDisable(connection.get(), handle); 372 cleanupWithoutDisableLocked(connection, handle); 373 } 374 } 375 } 376 } 377 378 bool SensorService::threadLoop() 379 { 380 ALOGD("nuSensorService thread starting..."); 381 382 // each virtual sensor could generate an event per "real" event, that's why we need 383 // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT. 384 // in practice, this is too aggressive, but guaranteed to be enough. 385 const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 386 const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size()); 387 388 SensorDevice& device(SensorDevice::getInstance()); 389 const size_t vcount = mVirtualSensorList.size(); 390 391 const int halVersion = device.getHalDeviceVersion(); 392 do { 393 ssize_t count = device.poll(mSensorEventBuffer, numEventMax); 394 if (count < 0) { 395 ALOGE("sensor poll failed (%s)", strerror(-count)); 396 break; 397 } 398 399 // Reset sensors_event_t.flags to zero for all events in the buffer. 400 for (int i = 0; i < count; i++) { 401 mSensorEventBuffer[i].flags = 0; 402 } 403 404 // Make a copy of the connection vector as some connections may be removed during the 405 // course of this loop (especially when one-shot sensor events are present in the 406 // sensor_event buffer). Promote all connections to StrongPointers before the lock is 407 // acquired. If the destructor of the sp gets called when the lock is acquired, it may 408 // result in a deadlock as ~SensorEventConnection() needs to acquire mLock again for 409 // cleanup. So copy all the strongPointers to a vector before the lock is acquired. 410 SortedVector< sp<SensorEventConnection> > activeConnections; 411 populateActiveConnections(&activeConnections); 412 Mutex::Autolock _l(mLock); 413 // Poll has returned. Hold a wakelock if one of the events is from a wake up sensor. The 414 // rest of this loop is under a critical section protected by mLock. Acquiring a wakeLock, 415 // sending events to clients (incrementing SensorEventConnection::mWakeLockRefCount) should 416 // not be interleaved with decrementing SensorEventConnection::mWakeLockRefCount and 417 // releasing the wakelock. 418 bool bufferHasWakeUpEvent = false; 419 for (int i = 0; i < count; i++) { 420 if (isWakeUpSensorEvent(mSensorEventBuffer[i])) { 421 bufferHasWakeUpEvent = true; 422 break; 423 } 424 } 425 426 if (bufferHasWakeUpEvent && !mWakeLockAcquired) { 427 setWakeLockAcquiredLocked(true); 428 } 429 recordLastValueLocked(mSensorEventBuffer, count); 430 431 // handle virtual sensors 432 if (count && vcount) { 433 sensors_event_t const * const event = mSensorEventBuffer; 434 const size_t activeVirtualSensorCount = mActiveVirtualSensors.size(); 435 if (activeVirtualSensorCount) { 436 size_t k = 0; 437 SensorFusion& fusion(SensorFusion::getInstance()); 438 if (fusion.isEnabled()) { 439 for (size_t i=0 ; i<size_t(count) ; i++) { 440 fusion.process(event[i]); 441 } 442 } 443 for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) { 444 for (size_t j=0 ; j<activeVirtualSensorCount ; j++) { 445 if (count + k >= minBufferSize) { 446 ALOGE("buffer too small to hold all events: " 447 "count=%zd, k=%zu, size=%zu", 448 count, k, minBufferSize); 449 break; 450 } 451 sensors_event_t out; 452 SensorInterface* si = mActiveVirtualSensors.valueAt(j); 453 if (si->process(&out, event[i])) { 454 mSensorEventBuffer[count + k] = out; 455 k++; 456 } 457 } 458 } 459 if (k) { 460 // record the last synthesized values 461 recordLastValueLocked(&mSensorEventBuffer[count], k); 462 count += k; 463 // sort the buffer by time-stamps 464 sortEventBuffer(mSensorEventBuffer, count); 465 } 466 } 467 } 468 469 // handle backward compatibility for RotationVector sensor 470 if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) { 471 for (int i = 0; i < count; i++) { 472 if (mSensorEventBuffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) { 473 // All the 4 components of the quaternion should be available 474 // No heading accuracy. Set it to -1 475 mSensorEventBuffer[i].data[4] = -1; 476 } 477 } 478 } 479 480 // Map flush_complete_events in the buffer to SensorEventConnections which called 481 // flush on the hardware sensor. mapFlushEventsToConnections[i] will be the 482 // SensorEventConnection mapped to the corresponding flush_complete_event in 483 // mSensorEventBuffer[i] if such a mapping exists (NULL otherwise). 484 for (int i = 0; i < count; ++i) { 485 mMapFlushEventsToConnections[i] = NULL; 486 if (mSensorEventBuffer[i].type == SENSOR_TYPE_META_DATA) { 487 const int sensor_handle = mSensorEventBuffer[i].meta_data.sensor; 488 SensorRecord* rec = mActiveSensors.valueFor(sensor_handle); 489 if (rec != NULL) { 490 mMapFlushEventsToConnections[i] = rec->getFirstPendingFlushConnection(); 491 rec->removeFirstPendingFlushConnection(); 492 } 493 } 494 } 495 496 // Send our events to clients. Check the state of wake lock for each client and release the 497 // lock if none of the clients need it. 498 bool needsWakeLock = false; 499 size_t numConnections = activeConnections.size(); 500 for (size_t i=0 ; i < numConnections; ++i) { 501 if (activeConnections[i] != 0) { 502 activeConnections[i]->sendEvents(mSensorEventBuffer, count, mSensorEventScratch, 503 mMapFlushEventsToConnections); 504 needsWakeLock |= activeConnections[i]->needsWakeLock(); 505 // If the connection has one-shot sensors, it may be cleaned up after first trigger. 506 // Early check for one-shot sensors. 507 if (activeConnections[i]->hasOneShotSensors()) { 508 cleanupAutoDisabledSensorLocked(activeConnections[i], mSensorEventBuffer, 509 count); 510 } 511 } 512 } 513 514 if (mWakeLockAcquired && !needsWakeLock) { 515 setWakeLockAcquiredLocked(false); 516 } 517 } while (!Thread::exitPending()); 518 519 ALOGW("Exiting SensorService::threadLoop => aborting..."); 520 abort(); 521 return false; 522 } 523 524 sp<Looper> SensorService::getLooper() const { 525 return mLooper; 526 } 527 528 void SensorService::resetAllWakeLockRefCounts() { 529 SortedVector< sp<SensorEventConnection> > activeConnections; 530 populateActiveConnections(&activeConnections); 531 { 532 Mutex::Autolock _l(mLock); 533 for (size_t i=0 ; i < activeConnections.size(); ++i) { 534 if (activeConnections[i] != 0) { 535 activeConnections[i]->resetWakeLockRefCount(); 536 } 537 } 538 setWakeLockAcquiredLocked(false); 539 } 540 } 541 542 void SensorService::setWakeLockAcquiredLocked(bool acquire) { 543 if (acquire) { 544 if (!mWakeLockAcquired) { 545 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 546 mWakeLockAcquired = true; 547 } 548 mLooper->wake(); 549 } else { 550 if (mWakeLockAcquired) { 551 release_wake_lock(WAKE_LOCK_NAME); 552 mWakeLockAcquired = false; 553 } 554 } 555 } 556 557 558 bool SensorService::isWakeLockAcquired() { 559 Mutex::Autolock _l(mLock); 560 return mWakeLockAcquired; 561 } 562 563 bool SensorService::SensorEventAckReceiver::threadLoop() { 564 ALOGD("new thread SensorEventAckReceiver"); 565 sp<Looper> looper = mService->getLooper(); 566 do { 567 bool wakeLockAcquired = mService->isWakeLockAcquired(); 568 int timeout = -1; 569 if (wakeLockAcquired) timeout = 5000; 570 int ret = looper->pollOnce(timeout); 571 if (ret == ALOOPER_POLL_TIMEOUT) { 572 mService->resetAllWakeLockRefCounts(); 573 } 574 } while(!Thread::exitPending()); 575 return false; 576 } 577 578 void SensorService::recordLastValueLocked( 579 const sensors_event_t* buffer, size_t count) { 580 const sensors_event_t* last = NULL; 581 for (size_t i = 0; i < count; i++) { 582 const sensors_event_t* event = &buffer[i]; 583 if (event->type != SENSOR_TYPE_META_DATA) { 584 if (last && event->sensor != last->sensor) { 585 mLastEventSeen.editValueFor(last->sensor) = *last; 586 } 587 last = event; 588 } 589 } 590 if (last) { 591 mLastEventSeen.editValueFor(last->sensor) = *last; 592 } 593 } 594 595 void SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count) 596 { 597 struct compar { 598 static int cmp(void const* lhs, void const* rhs) { 599 sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs); 600 sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs); 601 return l->timestamp - r->timestamp; 602 } 603 }; 604 qsort(buffer, count, sizeof(sensors_event_t), compar::cmp); 605 } 606 607 String8 SensorService::getSensorName(int handle) const { 608 size_t count = mUserSensorList.size(); 609 for (size_t i=0 ; i<count ; i++) { 610 const Sensor& sensor(mUserSensorList[i]); 611 if (sensor.getHandle() == handle) { 612 return sensor.getName(); 613 } 614 } 615 String8 result("unknown"); 616 return result; 617 } 618 619 bool SensorService::isVirtualSensor(int handle) const { 620 SensorInterface* sensor = mSensorMap.valueFor(handle); 621 return sensor->isVirtual(); 622 } 623 624 bool SensorService::isWakeUpSensorEvent(const sensors_event_t& event) const { 625 int handle = event.sensor; 626 if (event.type == SENSOR_TYPE_META_DATA) { 627 handle = event.meta_data.sensor; 628 } 629 SensorInterface* sensor = mSensorMap.valueFor(handle); 630 return sensor != NULL && sensor->getSensor().isWakeUpSensor(); 631 } 632 633 634 SensorService::SensorRecord * SensorService::getSensorRecord(int handle) { 635 return mActiveSensors.valueFor(handle); 636 } 637 638 Vector<Sensor> SensorService::getSensorList() 639 { 640 char value[PROPERTY_VALUE_MAX]; 641 property_get("debug.sensors", value, "0"); 642 const Vector<Sensor>& initialSensorList = (atoi(value)) ? 643 mUserSensorListDebug : mUserSensorList; 644 Vector<Sensor> accessibleSensorList; 645 for (size_t i = 0; i < initialSensorList.size(); i++) { 646 Sensor sensor = initialSensorList[i]; 647 if (canAccessSensor(sensor)) { 648 accessibleSensorList.add(sensor); 649 } else { 650 String8 infoMessage; 651 infoMessage.appendFormat( 652 "Skipped sensor %s because it requires permission %s", 653 sensor.getName().string(), 654 sensor.getRequiredPermission().string()); 655 ALOGI(infoMessage.string()); 656 } 657 } 658 return accessibleSensorList; 659 } 660 661 sp<ISensorEventConnection> SensorService::createSensorEventConnection() 662 { 663 uid_t uid = IPCThreadState::self()->getCallingUid(); 664 sp<SensorEventConnection> result(new SensorEventConnection(this, uid)); 665 return result; 666 } 667 668 void SensorService::cleanupConnection(SensorEventConnection* c) 669 { 670 Mutex::Autolock _l(mLock); 671 const wp<SensorEventConnection> connection(c); 672 size_t size = mActiveSensors.size(); 673 ALOGD_IF(DEBUG_CONNECTIONS, "%zu active sensors", size); 674 for (size_t i=0 ; i<size ; ) { 675 int handle = mActiveSensors.keyAt(i); 676 if (c->hasSensor(handle)) { 677 ALOGD_IF(DEBUG_CONNECTIONS, "%zu: disabling handle=0x%08x", i, handle); 678 SensorInterface* sensor = mSensorMap.valueFor( handle ); 679 ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle); 680 if (sensor) { 681 sensor->activate(c, false); 682 } 683 c->removeSensor(handle); 684 } 685 SensorRecord* rec = mActiveSensors.valueAt(i); 686 ALOGE_IF(!rec, "mActiveSensors[%zu] is null (handle=0x%08x)!", i, handle); 687 ALOGD_IF(DEBUG_CONNECTIONS, 688 "removing connection %p for sensor[%zu].handle=0x%08x", 689 c, i, handle); 690 691 if (rec && rec->removeConnection(connection)) { 692 ALOGD_IF(DEBUG_CONNECTIONS, "... and it was the last connection"); 693 mActiveSensors.removeItemsAt(i, 1); 694 mActiveVirtualSensors.removeItem(handle); 695 delete rec; 696 size--; 697 } else { 698 i++; 699 } 700 } 701 c->updateLooperRegistration(mLooper); 702 mActiveConnections.remove(connection); 703 BatteryService::cleanup(c->getUid()); 704 if (c->needsWakeLock()) { 705 checkWakeLockStateLocked(); 706 } 707 } 708 709 Sensor SensorService::getSensorFromHandle(int handle) const { 710 return mSensorMap.valueFor(handle)->getSensor(); 711 } 712 713 status_t SensorService::enable(const sp<SensorEventConnection>& connection, 714 int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags) 715 { 716 if (mInitCheck != NO_ERROR) 717 return mInitCheck; 718 719 SensorInterface* sensor = mSensorMap.valueFor(handle); 720 if (sensor == NULL) { 721 return BAD_VALUE; 722 } 723 724 if (!verifyCanAccessSensor(sensor->getSensor(), "Tried enabling")) { 725 return BAD_VALUE; 726 } 727 728 Mutex::Autolock _l(mLock); 729 SensorRecord* rec = mActiveSensors.valueFor(handle); 730 if (rec == 0) { 731 rec = new SensorRecord(connection); 732 mActiveSensors.add(handle, rec); 733 if (sensor->isVirtual()) { 734 mActiveVirtualSensors.add(handle, sensor); 735 } 736 } else { 737 if (rec->addConnection(connection)) { 738 // this sensor is already activated, but we are adding a connection that uses it. 739 // Immediately send down the last known value of the requested sensor if it's not a 740 // "continuous" sensor. 741 if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ON_CHANGE) { 742 // NOTE: The wake_up flag of this event may get set to 743 // WAKE_UP_SENSOR_EVENT_NEEDS_ACK if this is a wake_up event. 744 sensors_event_t& event(mLastEventSeen.editValueFor(handle)); 745 if (event.version == sizeof(sensors_event_t)) { 746 if (isWakeUpSensorEvent(event) && !mWakeLockAcquired) { 747 setWakeLockAcquiredLocked(true); 748 } 749 connection->sendEvents(&event, 1, NULL); 750 if (!connection->needsWakeLock() && mWakeLockAcquired) { 751 checkWakeLockStateLocked(); 752 } 753 } 754 } 755 } 756 } 757 758 if (connection->addSensor(handle)) { 759 BatteryService::enableSensor(connection->getUid(), handle); 760 // the sensor was added (which means it wasn't already there) 761 // so, see if this connection becomes active 762 if (mActiveConnections.indexOf(connection) < 0) { 763 mActiveConnections.add(connection); 764 } 765 } else { 766 ALOGW("sensor %08x already enabled in connection %p (ignoring)", 767 handle, connection.get()); 768 } 769 770 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 771 if (samplingPeriodNs < minDelayNs) { 772 samplingPeriodNs = minDelayNs; 773 } 774 775 ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d" 776 "rate=%" PRId64 " timeout== %" PRId64"", 777 handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs); 778 779 status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs, 780 maxBatchReportLatencyNs); 781 782 // Call flush() before calling activate() on the sensor. Wait for a first flush complete 783 // event before sending events on this connection. Ignore one-shot sensors which don't 784 // support flush(). Also if this sensor isn't already active, don't call flush(). 785 if (err == NO_ERROR && sensor->getSensor().getReportingMode() != AREPORTING_MODE_ONE_SHOT && 786 rec->getNumConnections() > 1) { 787 connection->setFirstFlushPending(handle, true); 788 status_t err_flush = sensor->flush(connection.get(), handle); 789 // Flush may return error if the underlying h/w sensor uses an older HAL. 790 if (err_flush == NO_ERROR) { 791 rec->addPendingFlushConnection(connection.get()); 792 } else { 793 connection->setFirstFlushPending(handle, false); 794 } 795 } 796 797 if (err == NO_ERROR) { 798 ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle); 799 err = sensor->activate(connection.get(), true); 800 } 801 802 if (err == NO_ERROR) { 803 connection->updateLooperRegistration(mLooper); 804 } 805 806 if (err != NO_ERROR) { 807 // batch/activate has failed, reset our state. 808 cleanupWithoutDisableLocked(connection, handle); 809 } 810 return err; 811 } 812 813 status_t SensorService::disable(const sp<SensorEventConnection>& connection, 814 int handle) 815 { 816 if (mInitCheck != NO_ERROR) 817 return mInitCheck; 818 819 Mutex::Autolock _l(mLock); 820 status_t err = cleanupWithoutDisableLocked(connection, handle); 821 if (err == NO_ERROR) { 822 SensorInterface* sensor = mSensorMap.valueFor(handle); 823 err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE); 824 } 825 return err; 826 } 827 828 status_t SensorService::cleanupWithoutDisable( 829 const sp<SensorEventConnection>& connection, int handle) { 830 Mutex::Autolock _l(mLock); 831 return cleanupWithoutDisableLocked(connection, handle); 832 } 833 834 status_t SensorService::cleanupWithoutDisableLocked( 835 const sp<SensorEventConnection>& connection, int handle) { 836 SensorRecord* rec = mActiveSensors.valueFor(handle); 837 if (rec) { 838 // see if this connection becomes inactive 839 if (connection->removeSensor(handle)) { 840 BatteryService::disableSensor(connection->getUid(), handle); 841 } 842 if (connection->hasAnySensor() == false) { 843 connection->updateLooperRegistration(mLooper); 844 mActiveConnections.remove(connection); 845 } 846 // see if this sensor becomes inactive 847 if (rec->removeConnection(connection)) { 848 mActiveSensors.removeItem(handle); 849 mActiveVirtualSensors.removeItem(handle); 850 delete rec; 851 } 852 return NO_ERROR; 853 } 854 return BAD_VALUE; 855 } 856 857 status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection, 858 int handle, nsecs_t ns) 859 { 860 if (mInitCheck != NO_ERROR) 861 return mInitCheck; 862 863 SensorInterface* sensor = mSensorMap.valueFor(handle); 864 if (!sensor) 865 return BAD_VALUE; 866 867 if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) { 868 return BAD_VALUE; 869 } 870 871 if (ns < 0) 872 return BAD_VALUE; 873 874 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 875 if (ns < minDelayNs) { 876 ns = minDelayNs; 877 } 878 879 return sensor->setDelay(connection.get(), handle, ns); 880 } 881 882 status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection) { 883 if (mInitCheck != NO_ERROR) return mInitCheck; 884 SensorDevice& dev(SensorDevice::getInstance()); 885 const int halVersion = dev.getHalDeviceVersion(); 886 status_t err(NO_ERROR); 887 Mutex::Autolock _l(mLock); 888 // Loop through all sensors for this connection and call flush on each of them. 889 for (size_t i = 0; i < connection->mSensorInfo.size(); ++i) { 890 const int handle = connection->mSensorInfo.keyAt(i); 891 SensorInterface* sensor = mSensorMap.valueFor(handle); 892 if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 893 ALOGE("flush called on a one-shot sensor"); 894 err = INVALID_OPERATION; 895 continue; 896 } 897 if (halVersion <= SENSORS_DEVICE_API_VERSION_1_0 || isVirtualSensor(handle)) { 898 // For older devices just increment pending flush count which will send a trivial 899 // flush complete event. 900 connection->incrementPendingFlushCount(handle); 901 } else { 902 status_t err_flush = sensor->flush(connection.get(), handle); 903 if (err_flush == NO_ERROR) { 904 SensorRecord* rec = mActiveSensors.valueFor(handle); 905 if (rec != NULL) rec->addPendingFlushConnection(connection); 906 } 907 err = (err_flush != NO_ERROR) ? err_flush : err; 908 } 909 } 910 return err; 911 } 912 913 bool SensorService::canAccessSensor(const Sensor& sensor) { 914 return (sensor.getRequiredPermission().isEmpty()) || 915 PermissionCache::checkCallingPermission(String16(sensor.getRequiredPermission())); 916 } 917 918 bool SensorService::verifyCanAccessSensor(const Sensor& sensor, const char* operation) { 919 if (canAccessSensor(sensor)) { 920 return true; 921 } else { 922 String8 errorMessage; 923 errorMessage.appendFormat( 924 "%s a sensor (%s) without holding its required permission: %s", 925 operation, 926 sensor.getName().string(), 927 sensor.getRequiredPermission().string()); 928 return false; 929 } 930 } 931 932 void SensorService::checkWakeLockState() { 933 Mutex::Autolock _l(mLock); 934 checkWakeLockStateLocked(); 935 } 936 937 void SensorService::checkWakeLockStateLocked() { 938 if (!mWakeLockAcquired) { 939 return; 940 } 941 bool releaseLock = true; 942 for (size_t i=0 ; i<mActiveConnections.size() ; i++) { 943 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 944 if (connection != 0) { 945 if (connection->needsWakeLock()) { 946 releaseLock = false; 947 break; 948 } 949 } 950 } 951 if (releaseLock) { 952 setWakeLockAcquiredLocked(false); 953 } 954 } 955 956 void SensorService::sendEventsFromCache(const sp<SensorEventConnection>& connection) { 957 Mutex::Autolock _l(mLock); 958 connection->writeToSocketFromCache(); 959 if (connection->needsWakeLock()) { 960 setWakeLockAcquiredLocked(true); 961 } 962 } 963 964 void SensorService::populateActiveConnections( 965 SortedVector< sp<SensorEventConnection> >* activeConnections) { 966 Mutex::Autolock _l(mLock); 967 for (size_t i=0 ; i < mActiveConnections.size(); ++i) { 968 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 969 if (connection != 0) { 970 activeConnections->add(connection); 971 } 972 } 973 } 974 975 // --------------------------------------------------------------------------- 976 SensorService::SensorRecord::SensorRecord( 977 const sp<SensorEventConnection>& connection) 978 { 979 mConnections.add(connection); 980 } 981 982 bool SensorService::SensorRecord::addConnection( 983 const sp<SensorEventConnection>& connection) 984 { 985 if (mConnections.indexOf(connection) < 0) { 986 mConnections.add(connection); 987 return true; 988 } 989 return false; 990 } 991 992 bool SensorService::SensorRecord::removeConnection( 993 const wp<SensorEventConnection>& connection) 994 { 995 ssize_t index = mConnections.indexOf(connection); 996 if (index >= 0) { 997 mConnections.removeItemsAt(index, 1); 998 } 999 // Remove this connections from the queue of flush() calls made on this sensor. 1000 for (Vector< wp<SensorEventConnection> >::iterator it = 1001 mPendingFlushConnections.begin(); it != mPendingFlushConnections.end();) { 1002 1003 if (it->unsafe_get() == connection.unsafe_get()) { 1004 it = mPendingFlushConnections.erase(it); 1005 } else { 1006 ++it; 1007 } 1008 } 1009 return mConnections.size() ? false : true; 1010 } 1011 1012 void SensorService::SensorRecord::addPendingFlushConnection( 1013 const sp<SensorEventConnection>& connection) { 1014 mPendingFlushConnections.add(connection); 1015 } 1016 1017 void SensorService::SensorRecord::removeFirstPendingFlushConnection() { 1018 if (mPendingFlushConnections.size() > 0) { 1019 mPendingFlushConnections.removeAt(0); 1020 } 1021 } 1022 1023 SensorService::SensorEventConnection * 1024 SensorService::SensorRecord::getFirstPendingFlushConnection() { 1025 if (mPendingFlushConnections.size() > 0) { 1026 return mPendingFlushConnections[0].unsafe_get(); 1027 } 1028 return NULL; 1029 } 1030 1031 // --------------------------------------------------------------------------- 1032 1033 SensorService::SensorEventConnection::SensorEventConnection( 1034 const sp<SensorService>& service, uid_t uid) 1035 : mService(service), mUid(uid), mWakeLockRefCount(0), mHasLooperCallbacks(false), 1036 mDead(false), mEventCache(NULL), mCacheSize(0), mMaxCacheSize(0) { 1037 mChannel = new BitTube(mService->mSocketBufferSize); 1038 #if DEBUG_CONNECTIONS 1039 mEventsReceived = mEventsSentFromCache = mEventsSent = 0; 1040 mTotalAcksNeeded = mTotalAcksReceived = 0; 1041 #endif 1042 } 1043 1044 SensorService::SensorEventConnection::~SensorEventConnection() { 1045 ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this); 1046 mService->cleanupConnection(this); 1047 if (mEventCache != NULL) { 1048 delete mEventCache; 1049 } 1050 } 1051 1052 void SensorService::SensorEventConnection::onFirstRef() { 1053 LooperCallback::onFirstRef(); 1054 } 1055 1056 bool SensorService::SensorEventConnection::needsWakeLock() { 1057 Mutex::Autolock _l(mConnectionLock); 1058 return !mDead && mWakeLockRefCount > 0; 1059 } 1060 1061 void SensorService::SensorEventConnection::resetWakeLockRefCount() { 1062 Mutex::Autolock _l(mConnectionLock); 1063 mWakeLockRefCount = 0; 1064 } 1065 1066 void SensorService::SensorEventConnection::dump(String8& result) { 1067 Mutex::Autolock _l(mConnectionLock); 1068 result.appendFormat("\t WakeLockRefCount %d | uid %d | cache size %d | max cache size %d\n", 1069 mWakeLockRefCount, mUid, mCacheSize, mMaxCacheSize); 1070 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1071 const FlushInfo& flushInfo = mSensorInfo.valueAt(i); 1072 result.appendFormat("\t %s 0x%08x | status: %s | pending flush events %d \n", 1073 mService->getSensorName(mSensorInfo.keyAt(i)).string(), 1074 mSensorInfo.keyAt(i), 1075 flushInfo.mFirstFlushPending ? "First flush pending" : 1076 "active", 1077 flushInfo.mPendingFlushEventsToSend); 1078 } 1079 #if DEBUG_CONNECTIONS 1080 result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d |" 1081 " total_acks_needed %d | total_acks_recvd %d\n", 1082 mEventsReceived, 1083 mEventsSent, 1084 mEventsSentFromCache, 1085 mEventsReceived - (mEventsSentFromCache + mEventsSent + mCacheSize), 1086 mTotalAcksNeeded, 1087 mTotalAcksReceived); 1088 #endif 1089 } 1090 1091 bool SensorService::SensorEventConnection::addSensor(int32_t handle) { 1092 Mutex::Autolock _l(mConnectionLock); 1093 if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) { 1094 return false; 1095 } 1096 if (mSensorInfo.indexOfKey(handle) < 0) { 1097 mSensorInfo.add(handle, FlushInfo()); 1098 return true; 1099 } 1100 return false; 1101 } 1102 1103 bool SensorService::SensorEventConnection::removeSensor(int32_t handle) { 1104 Mutex::Autolock _l(mConnectionLock); 1105 if (mSensorInfo.removeItem(handle) >= 0) { 1106 return true; 1107 } 1108 return false; 1109 } 1110 1111 bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const { 1112 Mutex::Autolock _l(mConnectionLock); 1113 return mSensorInfo.indexOfKey(handle) >= 0; 1114 } 1115 1116 bool SensorService::SensorEventConnection::hasAnySensor() const { 1117 Mutex::Autolock _l(mConnectionLock); 1118 return mSensorInfo.size() ? true : false; 1119 } 1120 1121 bool SensorService::SensorEventConnection::hasOneShotSensors() const { 1122 Mutex::Autolock _l(mConnectionLock); 1123 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1124 const int handle = mSensorInfo.keyAt(i); 1125 if (mService->getSensorFromHandle(handle).getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 1126 return true; 1127 } 1128 } 1129 return false; 1130 } 1131 1132 void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle, 1133 bool value) { 1134 Mutex::Autolock _l(mConnectionLock); 1135 ssize_t index = mSensorInfo.indexOfKey(handle); 1136 if (index >= 0) { 1137 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1138 flushInfo.mFirstFlushPending = value; 1139 } 1140 } 1141 1142 void SensorService::SensorEventConnection::updateLooperRegistration(const sp<Looper>& looper) { 1143 Mutex::Autolock _l(mConnectionLock); 1144 updateLooperRegistrationLocked(looper); 1145 } 1146 1147 void SensorService::SensorEventConnection::updateLooperRegistrationLocked( 1148 const sp<Looper>& looper) { 1149 bool isConnectionActive = mSensorInfo.size() > 0; 1150 // If all sensors are unregistered OR Looper has encountered an error, we 1151 // can remove the Fd from the Looper if it has been previously added. 1152 if (!isConnectionActive || mDead) { 1153 if (mHasLooperCallbacks) { 1154 ALOGD_IF(DEBUG_CONNECTIONS, "%p removeFd fd=%d", this, mChannel->getSendFd()); 1155 looper->removeFd(mChannel->getSendFd()); 1156 mHasLooperCallbacks = false; 1157 } 1158 return; 1159 } 1160 1161 int looper_flags = 0; 1162 if (mCacheSize > 0) looper_flags |= ALOOPER_EVENT_OUTPUT; 1163 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1164 const int handle = mSensorInfo.keyAt(i); 1165 if (mService->getSensorFromHandle(handle).isWakeUpSensor()) { 1166 looper_flags |= ALOOPER_EVENT_INPUT; 1167 break; 1168 } 1169 } 1170 // If flags is still set to zero, we don't need to add this fd to the Looper, if 1171 // the fd has already been added, remove it. This is likely to happen when ALL the 1172 // events stored in the cache have been sent to the corresponding app. 1173 if (looper_flags == 0) { 1174 if (mHasLooperCallbacks) { 1175 ALOGD_IF(DEBUG_CONNECTIONS, "removeFd fd=%d", mChannel->getSendFd()); 1176 looper->removeFd(mChannel->getSendFd()); 1177 mHasLooperCallbacks = false; 1178 } 1179 return; 1180 } 1181 // Add the file descriptor to the Looper for receiving acknowledegments if the app has 1182 // registered for wake-up sensors OR for sending events in the cache. 1183 int ret = looper->addFd(mChannel->getSendFd(), 0, looper_flags, this, NULL); 1184 if (ret == 1) { 1185 ALOGD_IF(DEBUG_CONNECTIONS, "%p addFd fd=%d", this, mChannel->getSendFd()); 1186 mHasLooperCallbacks = true; 1187 } else { 1188 ALOGE("Looper::addFd failed ret=%d fd=%d", ret, mChannel->getSendFd()); 1189 } 1190 } 1191 1192 void SensorService::SensorEventConnection::incrementPendingFlushCount(int32_t handle) { 1193 Mutex::Autolock _l(mConnectionLock); 1194 ssize_t index = mSensorInfo.indexOfKey(handle); 1195 if (index >= 0) { 1196 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1197 flushInfo.mPendingFlushEventsToSend++; 1198 } 1199 } 1200 1201 status_t SensorService::SensorEventConnection::sendEvents( 1202 sensors_event_t const* buffer, size_t numEvents, 1203 sensors_event_t* scratch, 1204 SensorEventConnection const * const * mapFlushEventsToConnections) { 1205 // filter out events not for this connection 1206 size_t count = 0; 1207 Mutex::Autolock _l(mConnectionLock); 1208 if (scratch) { 1209 size_t i=0; 1210 while (i<numEvents) { 1211 int32_t sensor_handle = buffer[i].sensor; 1212 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1213 ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ", 1214 buffer[i].meta_data.sensor); 1215 // Setting sensor_handle to the correct sensor to ensure the sensor events per 1216 // connection are filtered correctly. buffer[i].sensor is zero for meta_data 1217 // events. 1218 sensor_handle = buffer[i].meta_data.sensor; 1219 } 1220 ssize_t index = mSensorInfo.indexOfKey(sensor_handle); 1221 // Check if this connection has registered for this sensor. If not continue to the 1222 // next sensor_event. 1223 if (index < 0) { 1224 ++i; 1225 continue; 1226 } 1227 1228 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1229 // Check if there is a pending flush_complete event for this sensor on this connection. 1230 if (buffer[i].type == SENSOR_TYPE_META_DATA && flushInfo.mFirstFlushPending == true && 1231 this == mapFlushEventsToConnections[i]) { 1232 flushInfo.mFirstFlushPending = false; 1233 ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ", 1234 buffer[i].meta_data.sensor); 1235 ++i; 1236 continue; 1237 } 1238 1239 // If there is a pending flush complete event for this sensor on this connection, 1240 // ignore the event and proceed to the next. 1241 if (flushInfo.mFirstFlushPending) { 1242 ++i; 1243 continue; 1244 } 1245 1246 do { 1247 // Keep copying events into the scratch buffer as long as they are regular 1248 // sensor_events are from the same sensor_handle OR they are flush_complete_events 1249 // from the same sensor_handle AND the current connection is mapped to the 1250 // corresponding flush_complete_event. 1251 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1252 if (this == mapFlushEventsToConnections[i]) { 1253 scratch[count++] = buffer[i]; 1254 } 1255 ++i; 1256 } else { 1257 // Regular sensor event, just copy it to the scratch buffer. 1258 scratch[count++] = buffer[i++]; 1259 } 1260 } while ((i<numEvents) && ((buffer[i].sensor == sensor_handle && 1261 buffer[i].type != SENSOR_TYPE_META_DATA) || 1262 (buffer[i].type == SENSOR_TYPE_META_DATA && 1263 buffer[i].meta_data.sensor == sensor_handle))); 1264 } 1265 } else { 1266 scratch = const_cast<sensors_event_t *>(buffer); 1267 count = numEvents; 1268 } 1269 1270 sendPendingFlushEventsLocked(); 1271 // Early return if there are no events for this connection. 1272 if (count == 0) { 1273 return status_t(NO_ERROR); 1274 } 1275 1276 #if DEBUG_CONNECTIONS 1277 mEventsReceived += count; 1278 #endif 1279 if (mCacheSize != 0) { 1280 // There are some events in the cache which need to be sent first. Copy this buffer to 1281 // the end of cache. 1282 if (mCacheSize + count <= mMaxCacheSize) { 1283 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1284 mCacheSize += count; 1285 } else { 1286 // Check if any new sensors have registered on this connection which may have increased 1287 // the max cache size that is desired. 1288 if (mCacheSize + count < computeMaxCacheSizeLocked()) { 1289 reAllocateCacheLocked(scratch, count); 1290 return status_t(NO_ERROR); 1291 } 1292 // Some events need to be dropped. 1293 int remaningCacheSize = mMaxCacheSize - mCacheSize; 1294 if (remaningCacheSize != 0) { 1295 memcpy(&mEventCache[mCacheSize], scratch, 1296 remaningCacheSize * sizeof(sensors_event_t)); 1297 } 1298 int numEventsDropped = count - remaningCacheSize; 1299 countFlushCompleteEventsLocked(mEventCache, numEventsDropped); 1300 // Drop the first "numEventsDropped" in the cache. 1301 memmove(mEventCache, &mEventCache[numEventsDropped], 1302 (mCacheSize - numEventsDropped) * sizeof(sensors_event_t)); 1303 1304 // Copy the remainingEvents in scratch buffer to the end of cache. 1305 memcpy(&mEventCache[mCacheSize - numEventsDropped], scratch + remaningCacheSize, 1306 numEventsDropped * sizeof(sensors_event_t)); 1307 } 1308 return status_t(NO_ERROR); 1309 } 1310 1311 int index_wake_up_event = findWakeUpSensorEventLocked(scratch, count); 1312 if (index_wake_up_event >= 0) { 1313 scratch[index_wake_up_event].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1314 ++mWakeLockRefCount; 1315 #if DEBUG_CONNECTIONS 1316 ++mTotalAcksNeeded; 1317 #endif 1318 } 1319 1320 // NOTE: ASensorEvent and sensors_event_t are the same type. 1321 ssize_t size = SensorEventQueue::write(mChannel, 1322 reinterpret_cast<ASensorEvent const*>(scratch), count); 1323 if (size < 0) { 1324 // Write error, copy events to local cache. 1325 if (index_wake_up_event >= 0) { 1326 // If there was a wake_up sensor_event, reset the flag. 1327 scratch[index_wake_up_event].flags &= ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1328 if (mWakeLockRefCount > 0) { 1329 --mWakeLockRefCount; 1330 } 1331 #if DEBUG_CONNECTIONS 1332 --mTotalAcksNeeded; 1333 #endif 1334 } 1335 if (mEventCache == NULL) { 1336 mMaxCacheSize = computeMaxCacheSizeLocked(); 1337 mEventCache = new sensors_event_t[mMaxCacheSize]; 1338 mCacheSize = 0; 1339 } 1340 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1341 mCacheSize += count; 1342 1343 // Add this file descriptor to the looper to get a callback when this fd is available for 1344 // writing. 1345 updateLooperRegistrationLocked(mService->getLooper()); 1346 return size; 1347 } 1348 1349 #if DEBUG_CONNECTIONS 1350 if (size > 0) { 1351 mEventsSent += count; 1352 } 1353 #endif 1354 1355 return size < 0 ? status_t(size) : status_t(NO_ERROR); 1356 } 1357 1358 void SensorService::SensorEventConnection::reAllocateCacheLocked(sensors_event_t const* scratch, 1359 int count) { 1360 sensors_event_t *eventCache_new; 1361 const int new_cache_size = computeMaxCacheSizeLocked(); 1362 // Allocate new cache, copy over events from the old cache & scratch, free up memory. 1363 eventCache_new = new sensors_event_t[new_cache_size]; 1364 memcpy(eventCache_new, mEventCache, mCacheSize * sizeof(sensors_event_t)); 1365 memcpy(&eventCache_new[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1366 1367 ALOGD_IF(DEBUG_CONNECTIONS, "reAllocateCacheLocked maxCacheSize=%d %d", mMaxCacheSize, 1368 new_cache_size); 1369 1370 delete mEventCache; 1371 mEventCache = eventCache_new; 1372 mCacheSize += count; 1373 mMaxCacheSize = new_cache_size; 1374 } 1375 1376 void SensorService::SensorEventConnection::sendPendingFlushEventsLocked() { 1377 ASensorEvent flushCompleteEvent; 1378 memset(&flushCompleteEvent, 0, sizeof(flushCompleteEvent)); 1379 flushCompleteEvent.type = SENSOR_TYPE_META_DATA; 1380 // Loop through all the sensors for this connection and check if there are any pending 1381 // flush complete events to be sent. 1382 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1383 FlushInfo& flushInfo = mSensorInfo.editValueAt(i); 1384 while (flushInfo.mPendingFlushEventsToSend > 0) { 1385 const int sensor_handle = mSensorInfo.keyAt(i); 1386 flushCompleteEvent.meta_data.sensor = sensor_handle; 1387 bool wakeUpSensor = mService->getSensorFromHandle(sensor_handle).isWakeUpSensor(); 1388 if (wakeUpSensor) { 1389 ++mWakeLockRefCount; 1390 flushCompleteEvent.flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1391 } 1392 ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1); 1393 if (size < 0) { 1394 if (wakeUpSensor) --mWakeLockRefCount; 1395 return; 1396 } 1397 ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ", 1398 flushCompleteEvent.meta_data.sensor); 1399 flushInfo.mPendingFlushEventsToSend--; 1400 } 1401 } 1402 } 1403 1404 void SensorService::SensorEventConnection::writeToSocketFromCache() { 1405 // At a time write at most half the size of the receiver buffer in SensorEventQueue OR 1406 // half the size of the socket buffer allocated in BitTube whichever is smaller. 1407 const int maxWriteSize = helpers::min(SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT/2, 1408 int(mService->mSocketBufferSize/(sizeof(sensors_event_t)*2))); 1409 Mutex::Autolock _l(mConnectionLock); 1410 // Send pending flush complete events (if any) 1411 sendPendingFlushEventsLocked(); 1412 for (int numEventsSent = 0; numEventsSent < mCacheSize;) { 1413 const int numEventsToWrite = helpers::min(mCacheSize - numEventsSent, maxWriteSize); 1414 int index_wake_up_event = 1415 findWakeUpSensorEventLocked(mEventCache + numEventsSent, numEventsToWrite); 1416 if (index_wake_up_event >= 0) { 1417 mEventCache[index_wake_up_event + numEventsSent].flags |= 1418 WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1419 ++mWakeLockRefCount; 1420 #if DEBUG_CONNECTIONS 1421 ++mTotalAcksNeeded; 1422 #endif 1423 } 1424 1425 ssize_t size = SensorEventQueue::write(mChannel, 1426 reinterpret_cast<ASensorEvent const*>(mEventCache + numEventsSent), 1427 numEventsToWrite); 1428 if (size < 0) { 1429 if (index_wake_up_event >= 0) { 1430 // If there was a wake_up sensor_event, reset the flag. 1431 mEventCache[index_wake_up_event + numEventsSent].flags &= 1432 ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1433 if (mWakeLockRefCount > 0) { 1434 --mWakeLockRefCount; 1435 } 1436 #if DEBUG_CONNECTIONS 1437 --mTotalAcksNeeded; 1438 #endif 1439 } 1440 memmove(mEventCache, &mEventCache[numEventsSent], 1441 (mCacheSize - numEventsSent) * sizeof(sensors_event_t)); 1442 ALOGD_IF(DEBUG_CONNECTIONS, "wrote %d events from cache size==%d ", 1443 numEventsSent, mCacheSize); 1444 mCacheSize -= numEventsSent; 1445 return; 1446 } 1447 numEventsSent += numEventsToWrite; 1448 #if DEBUG_CONNECTIONS 1449 mEventsSentFromCache += numEventsToWrite; 1450 #endif 1451 } 1452 ALOGD_IF(DEBUG_CONNECTIONS, "wrote all events from cache size=%d ", mCacheSize); 1453 // All events from the cache have been sent. Reset cache size to zero. 1454 mCacheSize = 0; 1455 // There are no more events in the cache. We don't need to poll for write on the fd. 1456 // Update Looper registration. 1457 updateLooperRegistrationLocked(mService->getLooper()); 1458 } 1459 1460 void SensorService::SensorEventConnection::countFlushCompleteEventsLocked( 1461 sensors_event_t const* scratch, const int numEventsDropped) { 1462 ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped); 1463 // Count flushComplete events in the events that are about to the dropped. These will be sent 1464 // separately before the next batch of events. 1465 for (int j = 0; j < numEventsDropped; ++j) { 1466 if (scratch[j].type == SENSOR_TYPE_META_DATA) { 1467 FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor); 1468 flushInfo.mPendingFlushEventsToSend++; 1469 ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d", 1470 flushInfo.mPendingFlushEventsToSend); 1471 } 1472 } 1473 return; 1474 } 1475 1476 int SensorService::SensorEventConnection::findWakeUpSensorEventLocked( 1477 sensors_event_t const* scratch, const int count) { 1478 for (int i = 0; i < count; ++i) { 1479 if (mService->isWakeUpSensorEvent(scratch[i])) { 1480 return i; 1481 } 1482 } 1483 return -1; 1484 } 1485 1486 sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const 1487 { 1488 return mChannel; 1489 } 1490 1491 status_t SensorService::SensorEventConnection::enableDisable( 1492 int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, 1493 int reservedFlags) 1494 { 1495 status_t err; 1496 if (enabled) { 1497 err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs, 1498 reservedFlags); 1499 1500 } else { 1501 err = mService->disable(this, handle); 1502 } 1503 return err; 1504 } 1505 1506 status_t SensorService::SensorEventConnection::setEventRate( 1507 int handle, nsecs_t samplingPeriodNs) 1508 { 1509 return mService->setEventRate(this, handle, samplingPeriodNs); 1510 } 1511 1512 status_t SensorService::SensorEventConnection::flush() { 1513 return mService->flushSensor(this); 1514 } 1515 1516 int SensorService::SensorEventConnection::handleEvent(int fd, int events, void* /*data*/) { 1517 if (events & ALOOPER_EVENT_HANGUP || events & ALOOPER_EVENT_ERROR) { 1518 { 1519 // If the Looper encounters some error, set the flag mDead, reset mWakeLockRefCount, 1520 // and remove the fd from Looper. Call checkWakeLockState to know if SensorService 1521 // can release the wake-lock. 1522 ALOGD_IF(DEBUG_CONNECTIONS, "%p Looper error %d", this, fd); 1523 Mutex::Autolock _l(mConnectionLock); 1524 mDead = true; 1525 mWakeLockRefCount = 0; 1526 updateLooperRegistrationLocked(mService->getLooper()); 1527 } 1528 mService->checkWakeLockState(); 1529 return 1; 1530 } 1531 1532 if (events & ALOOPER_EVENT_INPUT) { 1533 uint32_t numAcks = 0; 1534 ssize_t ret = ::recv(fd, &numAcks, sizeof(numAcks), MSG_DONTWAIT); 1535 { 1536 Mutex::Autolock _l(mConnectionLock); 1537 // Sanity check to ensure there are no read errors in recv, numAcks is always 1538 // within the range and not zero. If any of the above don't hold reset mWakeLockRefCount 1539 // to zero. 1540 if (ret != sizeof(numAcks) || numAcks > mWakeLockRefCount || numAcks == 0) { 1541 ALOGE("Looper read error ret=%d numAcks=%d", ret, numAcks); 1542 mWakeLockRefCount = 0; 1543 } else { 1544 mWakeLockRefCount -= numAcks; 1545 } 1546 #if DEBUG_CONNECTIONS 1547 mTotalAcksReceived += numAcks; 1548 #endif 1549 } 1550 // Check if wakelock can be released by sensorservice. mConnectionLock needs to be released 1551 // here as checkWakeLockState() will need it. 1552 if (mWakeLockRefCount == 0) { 1553 mService->checkWakeLockState(); 1554 } 1555 // continue getting callbacks. 1556 return 1; 1557 } 1558 1559 if (events & ALOOPER_EVENT_OUTPUT) { 1560 // send sensor data that is stored in mEventCache for this connection. 1561 mService->sendEventsFromCache(this); 1562 } 1563 return 1; 1564 } 1565 1566 int SensorService::SensorEventConnection::computeMaxCacheSizeLocked() const { 1567 int fifoWakeUpSensors = 0; 1568 int fifoNonWakeUpSensors = 0; 1569 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1570 const Sensor& sensor = mService->getSensorFromHandle(mSensorInfo.keyAt(i)); 1571 if (sensor.getFifoReservedEventCount() == sensor.getFifoMaxEventCount()) { 1572 // Each sensor has a reserved fifo. Sum up the fifo sizes for all wake up sensors and 1573 // non wake_up sensors. 1574 if (sensor.isWakeUpSensor()) { 1575 fifoWakeUpSensors += sensor.getFifoReservedEventCount(); 1576 } else { 1577 fifoNonWakeUpSensors += sensor.getFifoReservedEventCount(); 1578 } 1579 } else { 1580 // Shared fifo. Compute the max of the fifo sizes for wake_up and non_wake up sensors. 1581 if (sensor.isWakeUpSensor()) { 1582 fifoWakeUpSensors = fifoWakeUpSensors > sensor.getFifoMaxEventCount() ? 1583 fifoWakeUpSensors : sensor.getFifoMaxEventCount(); 1584 1585 } else { 1586 fifoNonWakeUpSensors = fifoNonWakeUpSensors > sensor.getFifoMaxEventCount() ? 1587 fifoNonWakeUpSensors : sensor.getFifoMaxEventCount(); 1588 1589 } 1590 } 1591 } 1592 if (fifoWakeUpSensors + fifoNonWakeUpSensors == 0) { 1593 // It is extremely unlikely that there is a write failure in non batch mode. Return a cache 1594 // size that is equal to that of the batch mode. 1595 // ALOGW("Write failure in non-batch mode"); 1596 return MAX_SOCKET_BUFFER_SIZE_BATCHED/sizeof(sensors_event_t); 1597 } 1598 return fifoWakeUpSensors + fifoNonWakeUpSensors; 1599 } 1600 1601 // --------------------------------------------------------------------------- 1602 }; // namespace android 1603 1604
