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