SensorService.cpp revision 56ae42613c91f6a6fb0dc3f626daa24666fd18c2
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 54namespace 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 66const char* SensorService::WAKE_LOCK_NAME = "SensorService"; 67 68SensorService::SensorService() 69 : mInitCheck(NO_INIT) 70{ 71} 72 73void SensorService::onFirstRef() 74{ 75 ALOGD("nuSensorService starting..."); 76 77 SensorDevice& dev(SensorDevice::getInstance()); 78 79 if (dev.initCheck() == NO_ERROR) { 80 sensor_t const* list; 81 ssize_t count = dev.getSensorList(&list); 82 if (count > 0) { 83 ssize_t orientationIndex = -1; 84 bool hasGyro = false; 85 uint32_t virtualSensorsNeeds = 86 (1<<SENSOR_TYPE_GRAVITY) | 87 (1<<SENSOR_TYPE_LINEAR_ACCELERATION) | 88 (1<<SENSOR_TYPE_ROTATION_VECTOR); 89 90 mLastEventSeen.setCapacity(count); 91 for (ssize_t i=0 ; i<count ; i++) { 92 registerSensor( new HardwareSensor(list[i]) ); 93 switch (list[i].type) { 94 case SENSOR_TYPE_ORIENTATION: 95 orientationIndex = i; 96 break; 97 case SENSOR_TYPE_GYROSCOPE: 98 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 99 hasGyro = true; 100 break; 101 case SENSOR_TYPE_GRAVITY: 102 case SENSOR_TYPE_LINEAR_ACCELERATION: 103 case SENSOR_TYPE_ROTATION_VECTOR: 104 virtualSensorsNeeds &= ~(1<<list[i].type); 105 break; 106 } 107 } 108 109 // it's safe to instantiate the SensorFusion object here 110 // (it wants to be instantiated after h/w sensors have been 111 // registered) 112 const SensorFusion& fusion(SensorFusion::getInstance()); 113 114 // build the sensor list returned to users 115 mUserSensorList = mSensorList; 116 117 if (hasGyro) { 118 Sensor aSensor; 119 120 // Add Android virtual sensors if they're not already 121 // available in the HAL 122 123 aSensor = registerVirtualSensor( new RotationVectorSensor() ); 124 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 125 mUserSensorList.add(aSensor); 126 } 127 128 aSensor = registerVirtualSensor( new GravitySensor(list, count) ); 129 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) { 130 mUserSensorList.add(aSensor); 131 } 132 133 aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) ); 134 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) { 135 mUserSensorList.add(aSensor); 136 } 137 138 aSensor = registerVirtualSensor( new OrientationSensor() ); 139 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 140 // if we are doing our own rotation-vector, also add 141 // the orientation sensor and remove the HAL provided one. 142 mUserSensorList.replaceAt(aSensor, orientationIndex); 143 } 144 145 // virtual debugging sensors are not added to mUserSensorList 146 registerVirtualSensor( new CorrectedGyroSensor(list, count) ); 147 registerVirtualSensor( new GyroDriftSensor() ); 148 } 149 150 // debugging sensor list 151 mUserSensorListDebug = mSensorList; 152 153 mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED; 154 FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r"); 155 char line[128]; 156 if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) { 157 line[sizeof(line) - 1] = '\0'; 158 sscanf(line, "%zu", &mSocketBufferSize); 159 if (mSocketBufferSize > MAX_SOCKET_BUFFER_SIZE_BATCHED) { 160 mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED; 161 } 162 } 163 if (fp) { 164 fclose(fp); 165 } 166 167 mWakeLockAcquired = false; 168 run("SensorService", PRIORITY_URGENT_DISPLAY); 169 mLooper = new Looper(false); 170 mInitCheck = NO_ERROR; 171 } 172 } 173} 174 175Sensor SensorService::registerSensor(SensorInterface* s) 176{ 177 sensors_event_t event; 178 memset(&event, 0, sizeof(event)); 179 180 const Sensor sensor(s->getSensor()); 181 // add to the sensor list (returned to clients) 182 mSensorList.add(sensor); 183 // add to our handle->SensorInterface mapping 184 mSensorMap.add(sensor.getHandle(), s); 185 // create an entry in the mLastEventSeen array 186 mLastEventSeen.add(sensor.getHandle(), event); 187 188 return sensor; 189} 190 191Sensor SensorService::registerVirtualSensor(SensorInterface* s) 192{ 193 Sensor sensor = registerSensor(s); 194 mVirtualSensorList.add( s ); 195 return sensor; 196} 197 198SensorService::~SensorService() 199{ 200 for (size_t i=0 ; i<mSensorMap.size() ; i++) 201 delete mSensorMap.valueAt(i); 202} 203 204static const String16 sDump("android.permission.DUMP"); 205 206status_t SensorService::dump(int fd, const Vector<String16>& /*args*/) 207{ 208 String8 result; 209 if (!PermissionCache::checkCallingPermission(sDump)) { 210 result.appendFormat("Permission Denial: " 211 "can't dump SensorService from pid=%d, uid=%d\n", 212 IPCThreadState::self()->getCallingPid(), 213 IPCThreadState::self()->getCallingUid()); 214 } else { 215 Mutex::Autolock _l(mLock); 216 result.append("Sensor List:\n"); 217 for (size_t i=0 ; i<mSensorList.size() ; i++) { 218 const Sensor& s(mSensorList[i]); 219 const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle())); 220 result.appendFormat( 221 "%-48s| %-32s| %-48s| 0x%08x | \"%s\"\n\t", 222 s.getName().string(), 223 s.getVendor().string(), 224 s.getStringType().string(), 225 s.getHandle(), 226 s.getRequiredPermission().string()); 227 228 const int reportingMode = s.getReportingMode(); 229 if (reportingMode == AREPORTING_MODE_CONTINUOUS) { 230 result.append("continuous |"); 231 } else if (reportingMode == AREPORTING_MODE_ON_CHANGE) { 232 result.append("on-change | "); 233 } else if (reportingMode == AREPORTING_MODE_ONE_SHOT) { 234 result.append("one-shot | "); 235 } else { 236 result.append("special-trigger | "); 237 } 238 239 if (s.getMinDelay() > 0) { 240 result.appendFormat("maxRate=%7.2fHz | ", 1e6f / s.getMinDelay()); 241 } else { 242 result.appendFormat("minDelay=%5dus |", s.getMinDelay()); 243 } 244 245 if (s.getFifoMaxEventCount() > 0) { 246 result.appendFormat("FifoMax=%d events | ", 247 s.getFifoMaxEventCount()); 248 } else { 249 result.append("no batching support | "); 250 } 251 252 switch (s.getType()) { 253 case SENSOR_TYPE_ROTATION_VECTOR: 254 case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 255 result.appendFormat( 256 "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n", 257 e.data[0], e.data[1], e.data[2], e.data[3], e.data[4]); 258 break; 259 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 260 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 261 result.appendFormat( 262 "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n", 263 e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.data[5]); 264 break; 265 case SENSOR_TYPE_GAME_ROTATION_VECTOR: 266 result.appendFormat( 267 "last=<%5.1f,%5.1f,%5.1f,%5.1f>\n", 268 e.data[0], e.data[1], e.data[2], e.data[3]); 269 break; 270 case SENSOR_TYPE_SIGNIFICANT_MOTION: 271 case SENSOR_TYPE_STEP_DETECTOR: 272 result.appendFormat( "last=<%f>\n", e.data[0]); 273 break; 274 case SENSOR_TYPE_STEP_COUNTER: 275 result.appendFormat( "last=<%" PRIu64 ">\n", e.u64.step_counter); 276 break; 277 default: 278 // default to 3 values 279 result.appendFormat( 280 "last=<%5.1f,%5.1f,%5.1f>\n", 281 e.data[0], e.data[1], e.data[2]); 282 break; 283 } 284 } 285 SensorFusion::getInstance().dump(result); 286 SensorDevice::getInstance().dump(result); 287 288 result.append("Active sensors:\n"); 289 for (size_t i=0 ; i<mActiveSensors.size() ; i++) { 290 int handle = mActiveSensors.keyAt(i); 291 result.appendFormat("%s (handle=0x%08x, connections=%zu)\n", 292 getSensorName(handle).string(), 293 handle, 294 mActiveSensors.valueAt(i)->getNumConnections()); 295 } 296 297 result.appendFormat("%zu Max Socket Buffer size\n", mSocketBufferSize); 298 result.appendFormat("WakeLock Status: %s \n", mWakeLockAcquired ? "acquired" : "not held"); 299 result.appendFormat("%zd active connections\n", mActiveConnections.size()); 300 301 for (size_t i=0 ; i < mActiveConnections.size() ; i++) { 302 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 303 if (connection != 0) { 304 result.appendFormat("Connection Number: %zu \n", i); 305 connection->dump(result); 306 } 307 } 308 } 309 write(fd, result.string(), result.size()); 310 return NO_ERROR; 311} 312 313void SensorService::cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection, 314 sensors_event_t const* buffer, const int count) { 315 for (int i=0 ; i<count ; i++) { 316 int handle = buffer[i].sensor; 317 if (connection->hasSensor(handle)) { 318 SensorInterface* sensor = mSensorMap.valueFor(handle); 319 // If this buffer has an event from a one_shot sensor and this connection is registered 320 // for this particular one_shot sensor, try cleaning up the connection. 321 if (sensor != NULL && 322 sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 323 sensor->autoDisable(connection.get(), handle); 324 cleanupWithoutDisableLocked(connection, handle); 325 } 326 } 327 } 328} 329 330bool SensorService::threadLoop() 331{ 332 ALOGD("nuSensorService thread starting..."); 333 334 // each virtual sensor could generate an event per "real" event, that's why we need 335 // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT. 336 // in practice, this is too aggressive, but guaranteed to be enough. 337 const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 338 const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size()); 339 340 sensors_event_t buffer[minBufferSize]; 341 sensors_event_t scratch[minBufferSize]; 342 SensorDevice& device(SensorDevice::getInstance()); 343 const size_t vcount = mVirtualSensorList.size(); 344 345 SensorEventAckReceiver sender(this); 346 sender.run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY); 347 ssize_t count; 348 const int halVersion = device.getHalDeviceVersion(); 349 do { 350 count = device.poll(buffer, numEventMax); 351 if (count<0) { 352 ALOGE("sensor poll failed (%s)", strerror(-count)); 353 break; 354 } 355 356 // Reset sensors_event_t.flags to zero for all events in the buffer. 357 for (int i = 0; i < count; i++) { 358 buffer[i].flags = 0; 359 } 360 Mutex::Autolock _l(mLock); 361 // Poll has returned. Hold a wakelock if one of the events is from a wake up sensor. The 362 // rest of this loop is under a critical section protected by mLock. Acquiring a wakeLock, 363 // sending events to clients (incrementing SensorEventConnection::mWakeLockRefCount) should 364 // not be interleaved with decrementing SensorEventConnection::mWakeLockRefCount and 365 // releasing the wakelock. 366 bool bufferHasWakeUpEvent = false; 367 for (int i = 0; i < count; i++) { 368 if (isWakeUpSensorEvent(buffer[i])) { 369 bufferHasWakeUpEvent = true; 370 break; 371 } 372 } 373 374 if (bufferHasWakeUpEvent && !mWakeLockAcquired) { 375 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 376 mWakeLockAcquired = true; 377 ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock %s", WAKE_LOCK_NAME); 378 } 379 recordLastValueLocked(buffer, count); 380 381 // handle virtual sensors 382 if (count && vcount) { 383 sensors_event_t const * const event = buffer; 384 const size_t activeVirtualSensorCount = mActiveVirtualSensors.size(); 385 if (activeVirtualSensorCount) { 386 size_t k = 0; 387 SensorFusion& fusion(SensorFusion::getInstance()); 388 if (fusion.isEnabled()) { 389 for (size_t i=0 ; i<size_t(count) ; i++) { 390 fusion.process(event[i]); 391 } 392 } 393 for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) { 394 for (size_t j=0 ; j<activeVirtualSensorCount ; j++) { 395 if (count + k >= minBufferSize) { 396 ALOGE("buffer too small to hold all events: " 397 "count=%zd, k=%zu, size=%zu", 398 count, k, minBufferSize); 399 break; 400 } 401 sensors_event_t out; 402 SensorInterface* si = mActiveVirtualSensors.valueAt(j); 403 if (si->process(&out, event[i])) { 404 buffer[count + k] = out; 405 k++; 406 } 407 } 408 } 409 if (k) { 410 // record the last synthesized values 411 recordLastValueLocked(&buffer[count], k); 412 count += k; 413 // sort the buffer by time-stamps 414 sortEventBuffer(buffer, count); 415 } 416 } 417 } 418 419 // handle backward compatibility for RotationVector sensor 420 if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) { 421 for (int i = 0; i < count; i++) { 422 if (buffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) { 423 // All the 4 components of the quaternion should be available 424 // No heading accuracy. Set it to -1 425 buffer[i].data[4] = -1; 426 } 427 } 428 } 429 430 // Send our events to clients. Check the state of wake lock for each client and release the 431 // lock if none of the clients need it. 432 bool needsWakeLock = false; 433 for (size_t i=0 ; i < mActiveConnections.size(); i++) { 434 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 435 if (connection != 0) { 436 connection->sendEvents(buffer, count, scratch); 437 needsWakeLock |= connection->needsWakeLock(); 438 // Some sensors need to be auto disabled after the trigger 439 cleanupAutoDisabledSensorLocked(connection, buffer, count); 440 } 441 } 442 443 if (mWakeLockAcquired && !needsWakeLock) { 444 release_wake_lock(WAKE_LOCK_NAME); 445 mWakeLockAcquired = false; 446 ALOGD_IF(DEBUG_CONNECTIONS, "released wakelock %s", WAKE_LOCK_NAME); 447 } 448 } while (count >= 0 || Thread::exitPending()); 449 450 ALOGW("Exiting SensorService::threadLoop => aborting..."); 451 abort(); 452 return false; 453} 454 455sp<Looper> SensorService::getLooper() const { 456 return mLooper; 457} 458 459bool SensorService::SensorEventAckReceiver::threadLoop() { 460 ALOGD("new thread SensorEventAckReceiver"); 461 do { 462 sp<Looper> looper = mService->getLooper(); 463 looper->pollOnce(-1); 464 } while(!Thread::exitPending()); 465 return false; 466} 467 468void SensorService::recordLastValueLocked( 469 const sensors_event_t* buffer, size_t count) { 470 const sensors_event_t* last = NULL; 471 for (size_t i = 0; i < count; i++) { 472 const sensors_event_t* event = &buffer[i]; 473 if (event->type != SENSOR_TYPE_META_DATA) { 474 if (last && event->sensor != last->sensor) { 475 mLastEventSeen.editValueFor(last->sensor) = *last; 476 } 477 last = event; 478 } 479 } 480 if (last) { 481 mLastEventSeen.editValueFor(last->sensor) = *last; 482 } 483} 484 485void SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count) 486{ 487 struct compar { 488 static int cmp(void const* lhs, void const* rhs) { 489 sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs); 490 sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs); 491 return l->timestamp - r->timestamp; 492 } 493 }; 494 qsort(buffer, count, sizeof(sensors_event_t), compar::cmp); 495} 496 497String8 SensorService::getSensorName(int handle) const { 498 size_t count = mUserSensorList.size(); 499 for (size_t i=0 ; i<count ; i++) { 500 const Sensor& sensor(mUserSensorList[i]); 501 if (sensor.getHandle() == handle) { 502 return sensor.getName(); 503 } 504 } 505 String8 result("unknown"); 506 return result; 507} 508 509bool SensorService::isVirtualSensor(int handle) const { 510 SensorInterface* sensor = mSensorMap.valueFor(handle); 511 return sensor->isVirtual(); 512} 513 514bool SensorService::isWakeUpSensorEvent(const sensors_event_t& event) const { 515 int handle = event.sensor; 516 if (event.type == SENSOR_TYPE_META_DATA) { 517 handle = event.meta_data.sensor; 518 } 519 SensorInterface* sensor = mSensorMap.valueFor(handle); 520 return sensor != NULL && sensor->getSensor().isWakeUpSensor(); 521} 522 523Vector<Sensor> SensorService::getSensorList() 524{ 525 char value[PROPERTY_VALUE_MAX]; 526 property_get("debug.sensors", value, "0"); 527 const Vector<Sensor>& initialSensorList = (atoi(value)) ? 528 mUserSensorListDebug : mUserSensorList; 529 Vector<Sensor> accessibleSensorList; 530 for (size_t i = 0; i < initialSensorList.size(); i++) { 531 Sensor sensor = initialSensorList[i]; 532 if (canAccessSensor(sensor)) { 533 accessibleSensorList.add(sensor); 534 } else { 535 String8 infoMessage; 536 infoMessage.appendFormat( 537 "Skipped sensor %s because it requires permission %s", 538 sensor.getName().string(), 539 sensor.getRequiredPermission().string()); 540 ALOGI(infoMessage.string()); 541 } 542 } 543 return accessibleSensorList; 544} 545 546sp<ISensorEventConnection> SensorService::createSensorEventConnection() 547{ 548 uid_t uid = IPCThreadState::self()->getCallingUid(); 549 sp<SensorEventConnection> result(new SensorEventConnection(this, uid)); 550 return result; 551} 552 553void SensorService::cleanupConnection(SensorEventConnection* c) 554{ 555 Mutex::Autolock _l(mLock); 556 const wp<SensorEventConnection> connection(c); 557 size_t size = mActiveSensors.size(); 558 ALOGD_IF(DEBUG_CONNECTIONS, "%zu active sensors", size); 559 for (size_t i=0 ; i<size ; ) { 560 int handle = mActiveSensors.keyAt(i); 561 if (c->hasSensor(handle)) { 562 ALOGD_IF(DEBUG_CONNECTIONS, "%zu: disabling handle=0x%08x", i, handle); 563 SensorInterface* sensor = mSensorMap.valueFor( handle ); 564 ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle); 565 if (sensor) { 566 sensor->activate(c, false); 567 } 568 } 569 SensorRecord* rec = mActiveSensors.valueAt(i); 570 ALOGE_IF(!rec, "mActiveSensors[%zu] is null (handle=0x%08x)!", i, handle); 571 ALOGD_IF(DEBUG_CONNECTIONS, 572 "removing connection %p for sensor[%zu].handle=0x%08x", 573 c, i, handle); 574 575 if (rec && rec->removeConnection(connection)) { 576 ALOGD_IF(DEBUG_CONNECTIONS, "... and it was the last connection"); 577 mActiveSensors.removeItemsAt(i, 1); 578 mActiveVirtualSensors.removeItem(handle); 579 delete rec; 580 size--; 581 } else { 582 i++; 583 } 584 } 585 mActiveConnections.remove(connection); 586 BatteryService::cleanup(c->getUid()); 587 if (c->needsWakeLock()) { 588 checkWakeLockStateLocked(); 589 } 590} 591 592Sensor SensorService::getSensorFromHandle(int handle) const { 593 return mSensorMap.valueFor(handle)->getSensor(); 594} 595 596status_t SensorService::enable(const sp<SensorEventConnection>& connection, 597 int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags) 598{ 599 if (mInitCheck != NO_ERROR) 600 return mInitCheck; 601 602 SensorInterface* sensor = mSensorMap.valueFor(handle); 603 if (sensor == NULL) { 604 return BAD_VALUE; 605 } 606 607 if (!verifyCanAccessSensor(sensor->getSensor(), "Tried enabling")) { 608 return BAD_VALUE; 609 } 610 611 Mutex::Autolock _l(mLock); 612 SensorRecord* rec = mActiveSensors.valueFor(handle); 613 if (rec == 0) { 614 rec = new SensorRecord(connection); 615 mActiveSensors.add(handle, rec); 616 if (sensor->isVirtual()) { 617 mActiveVirtualSensors.add(handle, sensor); 618 } 619 } else { 620 if (rec->addConnection(connection)) { 621 // this sensor is already activated, but we are adding a connection that uses it. 622 // Immediately send down the last known value of the requested sensor if it's not a 623 // "continuous" sensor. 624 if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ON_CHANGE) { 625 // NOTE: The wake_up flag of this event may get set to 626 // WAKE_UP_SENSOR_EVENT_NEEDS_ACK if this is a wake_up event. 627 sensors_event_t& event(mLastEventSeen.editValueFor(handle)); 628 if (event.version == sizeof(sensors_event_t)) { 629 if (isWakeUpSensorEvent(event) && !mWakeLockAcquired) { 630 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 631 mWakeLockAcquired = true; 632 ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock for on_change sensor %s", 633 WAKE_LOCK_NAME); 634 } 635 connection->sendEvents(&event, 1, NULL); 636 if (!connection->needsWakeLock() && mWakeLockAcquired) { 637 checkWakeLockStateLocked(); 638 } 639 } 640 } 641 } 642 } 643 644 if (connection->addSensor(handle)) { 645 BatteryService::enableSensor(connection->getUid(), handle); 646 // the sensor was added (which means it wasn't already there) 647 // so, see if this connection becomes active 648 if (mActiveConnections.indexOf(connection) < 0) { 649 mActiveConnections.add(connection); 650 } 651 } else { 652 ALOGW("sensor %08x already enabled in connection %p (ignoring)", 653 handle, connection.get()); 654 } 655 656 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 657 if (samplingPeriodNs < minDelayNs) { 658 samplingPeriodNs = minDelayNs; 659 } 660 661 ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d rate=%" PRId64 " timeout== %" PRId64, 662 handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs); 663 664 status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs, 665 maxBatchReportLatencyNs); 666 if (err == NO_ERROR) { 667 connection->setFirstFlushPending(handle, true); 668 status_t err_flush = sensor->flush(connection.get(), handle); 669 // Flush may return error if the sensor is not activated or the underlying h/w sensor does 670 // not support flush. 671 if (err_flush != NO_ERROR) { 672 connection->setFirstFlushPending(handle, false); 673 } 674 } 675 676 if (err == NO_ERROR) { 677 ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle); 678 err = sensor->activate(connection.get(), true); 679 } 680 681 if (err == NO_ERROR && sensor->getSensor().isWakeUpSensor()) { 682 // Add the file descriptor to the Looper for receiving acknowledgments; 683 int ret = mLooper->addFd(connection->getSensorChannel()->getSendFd(), 0, 684 ALOOPER_EVENT_INPUT, connection.get(), NULL); 685 } 686 687 if (err != NO_ERROR) { 688 // batch/activate has failed, reset our state. 689 cleanupWithoutDisableLocked(connection, handle); 690 } 691 return err; 692} 693 694status_t SensorService::disable(const sp<SensorEventConnection>& connection, 695 int handle) 696{ 697 if (mInitCheck != NO_ERROR) 698 return mInitCheck; 699 700 Mutex::Autolock _l(mLock); 701 status_t err = cleanupWithoutDisableLocked(connection, handle); 702 if (err == NO_ERROR) { 703 SensorInterface* sensor = mSensorMap.valueFor(handle); 704 err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE); 705 } 706 return err; 707} 708 709status_t SensorService::cleanupWithoutDisable( 710 const sp<SensorEventConnection>& connection, int handle) { 711 Mutex::Autolock _l(mLock); 712 return cleanupWithoutDisableLocked(connection, handle); 713} 714 715status_t SensorService::cleanupWithoutDisableLocked( 716 const sp<SensorEventConnection>& connection, int handle) { 717 SensorRecord* rec = mActiveSensors.valueFor(handle); 718 if (rec) { 719 // see if this connection becomes inactive 720 if (connection->removeSensor(handle)) { 721 BatteryService::disableSensor(connection->getUid(), handle); 722 } 723 if (connection->hasAnySensor() == false) { 724 mActiveConnections.remove(connection); 725 } 726 // see if this sensor becomes inactive 727 if (rec->removeConnection(connection)) { 728 mActiveSensors.removeItem(handle); 729 mActiveVirtualSensors.removeItem(handle); 730 delete rec; 731 } 732 return NO_ERROR; 733 } 734 return BAD_VALUE; 735} 736 737status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection, 738 int handle, nsecs_t ns) 739{ 740 if (mInitCheck != NO_ERROR) 741 return mInitCheck; 742 743 SensorInterface* sensor = mSensorMap.valueFor(handle); 744 if (!sensor) 745 return BAD_VALUE; 746 747 if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) { 748 return BAD_VALUE; 749 } 750 751 if (ns < 0) 752 return BAD_VALUE; 753 754 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 755 if (ns < minDelayNs) { 756 ns = minDelayNs; 757 } 758 759 return sensor->setDelay(connection.get(), handle, ns); 760} 761 762status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection, 763 int handle) { 764 if (mInitCheck != NO_ERROR) return mInitCheck; 765 SensorInterface* sensor = mSensorMap.valueFor(handle); 766 if (sensor == NULL) { 767 return BAD_VALUE; 768 } 769 770 if (!verifyCanAccessSensor(sensor->getSensor(), "Tried flushing")) { 771 return BAD_VALUE; 772 } 773 774 if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 775 ALOGE("flush called on a one-shot sensor"); 776 return INVALID_OPERATION; 777 } 778 return sensor->flush(connection.get(), handle); 779} 780 781 782bool SensorService::canAccessSensor(const Sensor& sensor) { 783 return (sensor.getRequiredPermission().isEmpty()) || 784 PermissionCache::checkCallingPermission(String16(sensor.getRequiredPermission())); 785} 786 787bool SensorService::verifyCanAccessSensor(const Sensor& sensor, const char* operation) { 788 if (canAccessSensor(sensor)) { 789 return true; 790 } else { 791 String8 errorMessage; 792 errorMessage.appendFormat( 793 "%s a sensor (%s) without holding its required permission: %s", 794 operation, 795 sensor.getName().string(), 796 sensor.getRequiredPermission().string()); 797 return false; 798 } 799} 800 801void SensorService::checkWakeLockState() { 802 Mutex::Autolock _l(mLock); 803 checkWakeLockStateLocked(); 804} 805 806void SensorService::checkWakeLockStateLocked() { 807 if (!mWakeLockAcquired) { 808 return; 809 } 810 bool releaseLock = true; 811 for (size_t i=0 ; i<mActiveConnections.size() ; i++) { 812 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 813 if (connection != 0) { 814 if (connection->needsWakeLock()) { 815 releaseLock = false; 816 break; 817 } 818 } 819 } 820 if (releaseLock) { 821 ALOGD_IF(DEBUG_CONNECTIONS, "releasing wakelock %s", WAKE_LOCK_NAME); 822 release_wake_lock(WAKE_LOCK_NAME); 823 mWakeLockAcquired = false; 824 } 825} 826// --------------------------------------------------------------------------- 827SensorService::SensorRecord::SensorRecord( 828 const sp<SensorEventConnection>& connection) 829{ 830 mConnections.add(connection); 831} 832 833bool SensorService::SensorRecord::addConnection( 834 const sp<SensorEventConnection>& connection) 835{ 836 if (mConnections.indexOf(connection) < 0) { 837 mConnections.add(connection); 838 return true; 839 } 840 return false; 841} 842 843bool SensorService::SensorRecord::removeConnection( 844 const wp<SensorEventConnection>& connection) 845{ 846 ssize_t index = mConnections.indexOf(connection); 847 if (index >= 0) { 848 mConnections.removeItemsAt(index, 1); 849 } 850 return mConnections.size() ? false : true; 851} 852 853// --------------------------------------------------------------------------- 854 855SensorService::SensorEventConnection::SensorEventConnection( 856 const sp<SensorService>& service, uid_t uid) 857 : mService(service), mUid(uid), mWakeLockRefCount(0), mEventCache(NULL), mCacheSize(0), 858 mMaxCacheSize(0) { 859 const SensorDevice& device(SensorDevice::getInstance()); 860 if (device.getHalDeviceVersion() >= SENSORS_DEVICE_API_VERSION_1_1) { 861 // Increase socket buffer size to a max of 100 KB for batching capabilities. 862 mChannel = new BitTube(mService->mSocketBufferSize); 863 } else { 864 mChannel = new BitTube(SOCKET_BUFFER_SIZE_NON_BATCHED); 865 } 866#if DEBUG_CONNECTIONS 867 mEventsReceived = mEventsSentFromCache = mEventsSent = 0; 868#endif 869} 870 871SensorService::SensorEventConnection::~SensorEventConnection() { 872 ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this); 873 if (mEventCache != NULL) { 874 delete mEventCache; 875 } 876 mService->cleanupConnection(this); 877} 878 879void SensorService::SensorEventConnection::onFirstRef() { 880 LooperCallback::onFirstRef(); 881} 882 883bool SensorService::SensorEventConnection::needsWakeLock() { 884 Mutex::Autolock _l(mConnectionLock); 885 return mWakeLockRefCount > 0; 886} 887 888void SensorService::SensorEventConnection::dump(String8& result) { 889 Mutex::Autolock _l(mConnectionLock); 890 result.appendFormat("\t %d WakeLockRefCount \n", mWakeLockRefCount); 891 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 892 const FlushInfo& flushInfo = mSensorInfo.valueAt(i); 893 result.appendFormat("\t %s | status: %s | pending flush events %d | flush calls %d| uid %d|" 894 "cache size: %d max cache size %d\n", 895 mService->getSensorName(mSensorInfo.keyAt(i)).string(), 896 flushInfo.mFirstFlushPending ? "First flush pending" : 897 "active", 898 flushInfo.mPendingFlushEventsToSend, 899 flushInfo.mNumFlushCalls, 900 mUid, 901 mCacheSize, 902 mMaxCacheSize); 903#if DEBUG_CONNECTIONS 904 result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d\n", 905 mEventsReceived, 906 mEventsSent, 907 mEventsSentFromCache, 908 mEventsReceived - (mEventsSentFromCache + 909 mEventsSent + mCacheSize)); 910#endif 911 912 } 913} 914 915bool SensorService::SensorEventConnection::addSensor(int32_t handle) { 916 Mutex::Autolock _l(mConnectionLock); 917 if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) { 918 return false; 919 } 920 if (mSensorInfo.indexOfKey(handle) < 0) { 921 mSensorInfo.add(handle, FlushInfo()); 922 return true; 923 } 924 return false; 925} 926 927bool SensorService::SensorEventConnection::removeSensor(int32_t handle) { 928 Mutex::Autolock _l(mConnectionLock); 929 if (mSensorInfo.removeItem(handle) >= 0) { 930 return true; 931 } 932 return false; 933} 934 935bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const { 936 Mutex::Autolock _l(mConnectionLock); 937 return mSensorInfo.indexOfKey(handle) >= 0; 938} 939 940bool SensorService::SensorEventConnection::hasAnySensor() const { 941 Mutex::Autolock _l(mConnectionLock); 942 return mSensorInfo.size() ? true : false; 943} 944 945void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle, 946 bool value) { 947 Mutex::Autolock _l(mConnectionLock); 948 ssize_t index = mSensorInfo.indexOfKey(handle); 949 if (index >= 0) { 950 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 951 flushInfo.mFirstFlushPending = value; 952 } 953} 954 955status_t SensorService::SensorEventConnection::sendEvents( 956 sensors_event_t const* buffer, size_t numEvents, 957 sensors_event_t* scratch) { 958 // filter out events not for this connection 959 size_t count = 0; 960 Mutex::Autolock _l(mConnectionLock); 961 if (scratch) { 962 size_t i=0; 963 while (i<numEvents) { 964 int32_t curr = buffer[i].sensor; 965 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 966 ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ", 967 buffer[i].meta_data.sensor); 968 // Setting curr to the correct sensor to ensure the sensor events per connection are 969 // filtered correctly. buffer[i].sensor is zero for meta_data events. 970 curr = buffer[i].meta_data.sensor; 971 } 972 ssize_t index = mSensorInfo.indexOfKey(curr); 973 // Check if this connection has registered for this sensor. If not continue to the 974 // next sensor_event. 975 if (index < 0) { 976 ++i; 977 continue; 978 } 979 980 // Check if there is a pending flush_complete event for this sensor on this connection. 981 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 982 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 983 if (flushInfo.mFirstFlushPending == true) { 984 // This is the first flush before activate is called. Events can now be sent for 985 // this sensor on this connection. 986 ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ", 987 buffer[i].meta_data.sensor); 988 flushInfo.mFirstFlushPending = false; 989 ++i; 990 continue; 991 } 992 } 993 994 // If there is a pending flush complete event for this sensor on this connection, 995 // ignore the event and proceed to the next. 996 if (flushInfo.mFirstFlushPending) { 997 ++i; 998 continue; 999 } 1000 1001 do { 1002 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1003 // Send flush complete event only if flush() has been explicitly called by 1004 // this app else ignore. 1005 if (flushInfo.mNumFlushCalls > 0) { 1006 scratch[count++] = buffer[i]; 1007 flushInfo.mNumFlushCalls--; 1008 } 1009 ++i; 1010 } else { 1011 // Regular sensor event, just copy it to the scratch buffer. 1012 scratch[count++] = buffer[i++]; 1013 } 1014 } while ((i<numEvents) && ((buffer[i].sensor == curr) || 1015 (buffer[i].type == SENSOR_TYPE_META_DATA && 1016 buffer[i].meta_data.sensor == curr))); 1017 } 1018 } else { 1019 scratch = const_cast<sensors_event_t *>(buffer); 1020 count = numEvents; 1021 } 1022 1023 // Early return if there are no events for this connection. 1024 if (count == 0) { 1025 return status_t(NO_ERROR); 1026 } 1027 1028#if DEBUG_CONNECTIONS 1029 mEventsReceived += count; 1030#endif 1031 if (mCacheSize != 0) { 1032 // There are some events in the cache which need to be sent first. Copy this buffer to 1033 // the end of cache. 1034 if (mCacheSize + count <= mMaxCacheSize) { 1035 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1036 mCacheSize += count; 1037 } else { 1038 // Some events need to be dropped. 1039 int remaningCacheSize = mMaxCacheSize - mCacheSize; 1040 if (remaningCacheSize != 0) { 1041 memcpy(&mEventCache[mCacheSize], scratch, 1042 remaningCacheSize * sizeof(sensors_event_t)); 1043 } 1044 int numEventsDropped = count - remaningCacheSize; 1045 countFlushCompleteEventsLocked(mEventCache, numEventsDropped); 1046 // Drop the first "numEventsDropped" in the cache. 1047 memmove(mEventCache, &mEventCache[numEventsDropped], 1048 (mCacheSize - numEventsDropped) * sizeof(sensors_event_t)); 1049 1050 // Copy the remainingEvents in scratch buffer to the end of cache. 1051 memcpy(&mEventCache[mCacheSize - numEventsDropped], scratch + remaningCacheSize, 1052 numEventsDropped * sizeof(sensors_event_t)); 1053 } 1054 return status_t(NO_ERROR); 1055 } 1056 1057 int numWakeUpSensorEvents = countWakeUpSensorEventsLocked(scratch, count); 1058 mWakeLockRefCount += numWakeUpSensorEvents; 1059 1060 // NOTE: ASensorEvent and sensors_event_t are the same type. 1061 ssize_t size = SensorEventQueue::write(mChannel, 1062 reinterpret_cast<ASensorEvent const*>(scratch), count); 1063 if (size < 0) { 1064 // Write error, copy events to local cache. 1065 mWakeLockRefCount -= numWakeUpSensorEvents; 1066 if (mEventCache == NULL) { 1067 mMaxCacheSize = computeMaxCacheSizeLocked(); 1068 mEventCache = new sensors_event_t[mMaxCacheSize]; 1069 mCacheSize = 0; 1070 } 1071 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1072 mCacheSize += count; 1073 1074 // Add this file descriptor to the looper to get a callback when this fd is available for 1075 // writing. 1076 mService->getLooper()->addFd(mChannel->getSendFd(), 0, 1077 ALOOPER_EVENT_OUTPUT | ALOOPER_EVENT_INPUT, this, NULL); 1078 return size; 1079 } 1080 1081#if DEBUG_CONNECTIONS 1082 if (size > 0) { 1083 mEventsSent += count; 1084 } 1085#endif 1086 1087 return size < 0 ? status_t(size) : status_t(NO_ERROR); 1088} 1089 1090void SensorService::SensorEventConnection::writeToSocketFromCacheLocked() { 1091 // At a time write at most half the size of the receiver buffer in SensorEventQueue. 1092 const int maxWriteSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT/2; 1093 // Send pending flush events (if any) before sending events from the buffer. 1094 { 1095 ASensorEvent flushCompleteEvent; 1096 flushCompleteEvent.type = SENSOR_TYPE_META_DATA; 1097 flushCompleteEvent.sensor = 0; 1098 // Loop through all the sensors for this connection and check if there are any pending 1099 // flush complete events to be sent. 1100 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1101 FlushInfo& flushInfo = mSensorInfo.editValueAt(i); 1102 while (flushInfo.mPendingFlushEventsToSend > 0) { 1103 flushCompleteEvent.meta_data.sensor = mSensorInfo.keyAt(i); 1104 ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1); 1105 if (size < 0) { 1106 return; 1107 } 1108 ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ", 1109 flushCompleteEvent.meta_data.sensor); 1110 flushInfo.mPendingFlushEventsToSend--; 1111 } 1112 } 1113 } 1114 // Write "count" events at a time. 1115 for (int numEventsSent = 0; numEventsSent < mCacheSize;) { 1116 const int count = (mCacheSize - numEventsSent) < maxWriteSize ? 1117 mCacheSize - numEventsSent : maxWriteSize; 1118 int numWakeUpSensorEvents = 1119 countWakeUpSensorEventsLocked(mEventCache + numEventsSent, count); 1120 mWakeLockRefCount += numWakeUpSensorEvents; 1121 1122 ssize_t size = SensorEventQueue::write(mChannel, 1123 reinterpret_cast<ASensorEvent const*>(mEventCache + numEventsSent), 1124 count); 1125 if (size < 0) { 1126 memmove(mEventCache, &mEventCache[numEventsSent], 1127 (mCacheSize - numEventsSent) * sizeof(sensors_event_t)); 1128 ALOGD_IF(DEBUG_CONNECTIONS, "wrote %d events from cache size==%d ", 1129 numEventsSent, mCacheSize); 1130 mCacheSize -= numEventsSent; 1131 mWakeLockRefCount -= numWakeUpSensorEvents; 1132 return; 1133 } 1134 numEventsSent += count; 1135#if DEBUG_CONNECTIONS 1136 mEventsSentFromCache += count; 1137#endif 1138 } 1139 ALOGD_IF(DEBUG_CONNECTIONS, "wrote all events from cache size=%d ", mCacheSize); 1140 // All events from the cache have been sent. Reset cache size to zero. 1141 mCacheSize = 0; 1142 // Poll only for ALOOPER_EVENT_INPUT(read) on the file descriptor. 1143 mService->getLooper()->addFd(mChannel->getSendFd(), 0, ALOOPER_EVENT_INPUT, this, NULL); 1144} 1145 1146void SensorService::SensorEventConnection::countFlushCompleteEventsLocked( 1147 sensors_event_t* scratch, const int numEventsDropped) { 1148 ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped); 1149 // Count flushComplete events in the events that are about to the dropped. These will be sent 1150 // separately before the next batch of events. 1151 for (int j = 0; j < numEventsDropped; ++j) { 1152 if (scratch[j].type == SENSOR_TYPE_META_DATA) { 1153 FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor); 1154 flushInfo.mPendingFlushEventsToSend++; 1155 ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d", 1156 flushInfo.mPendingFlushEventsToSend); 1157 } 1158 } 1159 return; 1160} 1161 1162int SensorService::SensorEventConnection::countWakeUpSensorEventsLocked( 1163 sensors_event_t* scratch, const int count) { 1164 for (int i = 0; i < count; ++i) { 1165 if (mService->isWakeUpSensorEvent(scratch[i])) { 1166 scratch[i].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1167 return 1; 1168 } 1169 } 1170 return 0; 1171} 1172 1173sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const 1174{ 1175 return mChannel; 1176} 1177 1178status_t SensorService::SensorEventConnection::enableDisable( 1179 int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, 1180 int reservedFlags) 1181{ 1182 status_t err; 1183 if (enabled) { 1184 err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs, 1185 reservedFlags); 1186 1187 } else { 1188 err = mService->disable(this, handle); 1189 } 1190 return err; 1191} 1192 1193status_t SensorService::SensorEventConnection::setEventRate( 1194 int handle, nsecs_t samplingPeriodNs) 1195{ 1196 return mService->setEventRate(this, handle, samplingPeriodNs); 1197} 1198 1199status_t SensorService::SensorEventConnection::flush() { 1200 SensorDevice& dev(SensorDevice::getInstance()); 1201 const int halVersion = dev.getHalDeviceVersion(); 1202 Mutex::Autolock _l(mConnectionLock); 1203 status_t err(NO_ERROR); 1204 // Loop through all sensors for this connection and call flush on each of them. 1205 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1206 const int handle = mSensorInfo.keyAt(i); 1207 FlushInfo& flushInfo = mSensorInfo.editValueFor(handle); 1208 if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 || mService->isVirtualSensor(handle)) { 1209 // For older devices just increment pending flush count which will send a trivial 1210 // flush complete event. 1211 flushInfo.mPendingFlushEventsToSend++; 1212 } else { 1213 status_t err_flush = mService->flushSensor(this, handle); 1214 if (err_flush == NO_ERROR) { 1215 flushInfo.mNumFlushCalls++; 1216 } else { 1217 ALOGE("Flush error handle=%d %s", handle, strerror(-err_flush)); 1218 } 1219 err = (err_flush != NO_ERROR) ? err_flush : err; 1220 } 1221 } 1222 return err; 1223} 1224 1225int SensorService::SensorEventConnection::handleEvent(int fd, int events, void* data) { 1226 if (events & ALOOPER_EVENT_HANGUP || events & ALOOPER_EVENT_ERROR) { 1227 return 0; 1228 } 1229 1230 if (events & ALOOPER_EVENT_INPUT) { 1231 char buf; 1232 ssize_t ret = ::recv(fd, &buf, sizeof(buf), MSG_DONTWAIT); 1233 1234 { 1235 Mutex::Autolock _l(mConnectionLock); 1236 --mWakeLockRefCount; 1237 } 1238 // Check if wakelock can be released by sensorservice. mConnectionLock needs to be released 1239 // here as checkWakeLockState() will need it. 1240 if (mWakeLockRefCount == 0) { 1241 mService->checkWakeLockState(); 1242 } 1243 // continue getting callbacks. 1244 return 1; 1245 } 1246 1247 if (events & ALOOPER_EVENT_OUTPUT) { 1248 // send sensor data that is stored in mEventCache. 1249 Mutex::Autolock _l(mConnectionLock); 1250 writeToSocketFromCacheLocked(); 1251 } 1252 return 1; 1253} 1254 1255int SensorService::SensorEventConnection::computeMaxCacheSizeLocked() const { 1256 int fifoWakeUpSensors = 0; 1257 int fifoNonWakeUpSensors = 0; 1258 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1259 const Sensor& sensor = mService->getSensorFromHandle(mSensorInfo.keyAt(i)); 1260 if (sensor.getFifoReservedEventCount() == sensor.getFifoMaxEventCount()) { 1261 // Each sensor has a reserved fifo. Sum up the fifo sizes for all wake up sensors and 1262 // non wake_up sensors. 1263 if (sensor.isWakeUpSensor()) { 1264 fifoWakeUpSensors += sensor.getFifoReservedEventCount(); 1265 } else { 1266 fifoNonWakeUpSensors += sensor.getFifoReservedEventCount(); 1267 } 1268 } else { 1269 // Shared fifo. Compute the max of the fifo sizes for wake_up and non_wake up sensors. 1270 if (sensor.isWakeUpSensor()) { 1271 fifoWakeUpSensors = fifoWakeUpSensors > sensor.getFifoMaxEventCount() ? 1272 fifoWakeUpSensors : sensor.getFifoMaxEventCount(); 1273 1274 } else { 1275 fifoNonWakeUpSensors = fifoNonWakeUpSensors > sensor.getFifoMaxEventCount() ? 1276 fifoNonWakeUpSensors : sensor.getFifoMaxEventCount(); 1277 1278 } 1279 } 1280 } 1281 if (fifoWakeUpSensors + fifoNonWakeUpSensors == 0) { 1282 // It is extremely unlikely that there is a write failure in non batch mode. Return a cache 1283 // size of 100. 1284 ALOGI("Write failure in non-batch mode"); 1285 return 100; 1286 } 1287 return fifoWakeUpSensors + fifoNonWakeUpSensors; 1288} 1289 1290// --------------------------------------------------------------------------- 1291}; // namespace android 1292 1293