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