SensorService.cpp revision e148bc29c27ae7a346fa686fdda6425ba202d97a
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 // Check if the device really supports batching by looking at the FIFO event 154 // counts for each sensor. 155 bool batchingSupported = false; 156 for (int i = 0; i < mSensorList.size(); ++i) { 157 if (mSensorList[i].getFifoMaxEventCount() > 0) { 158 batchingSupported = true; 159 break; 160 } 161 } 162 163 if (batchingSupported) { 164 // Increase socket buffer size to a max of 100 KB for batching capabilities. 165 mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED; 166 } else { 167 mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED; 168 } 169 170 // Compare the socketBufferSize value against the system limits and limit 171 // it to maxSystemSocketBufferSize if necessary. 172 FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r"); 173 char line[128]; 174 if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) { 175 line[sizeof(line) - 1] = '\0'; 176 size_t maxSystemSocketBufferSize; 177 sscanf(line, "%zu", &maxSystemSocketBufferSize); 178 if (mSocketBufferSize > maxSystemSocketBufferSize) { 179 mSocketBufferSize = maxSystemSocketBufferSize; 180 } 181 } 182 if (fp) { 183 fclose(fp); 184 } 185 186 mWakeLockAcquired = false; 187 run("SensorService", PRIORITY_URGENT_DISPLAY); 188 mLooper = new Looper(false); 189 190 const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 191 mSensorEventBuffer = new sensors_event_t[minBufferSize]; 192 mSensorEventScratch = new sensors_event_t[minBufferSize]; 193 mMapFlushEventsToConnections = new SensorEventConnection const * [minBufferSize]; 194 mInitCheck = NO_ERROR; 195 } 196 } 197} 198 199Sensor SensorService::registerSensor(SensorInterface* s) 200{ 201 sensors_event_t event; 202 memset(&event, 0, sizeof(event)); 203 204 const Sensor sensor(s->getSensor()); 205 // add to the sensor list (returned to clients) 206 mSensorList.add(sensor); 207 // add to our handle->SensorInterface mapping 208 mSensorMap.add(sensor.getHandle(), s); 209 // create an entry in the mLastEventSeen array 210 mLastEventSeen.add(sensor.getHandle(), event); 211 212 return sensor; 213} 214 215Sensor SensorService::registerVirtualSensor(SensorInterface* s) 216{ 217 Sensor sensor = registerSensor(s); 218 mVirtualSensorList.add( s ); 219 return sensor; 220} 221 222SensorService::~SensorService() 223{ 224 for (size_t i=0 ; i<mSensorMap.size() ; i++) 225 delete mSensorMap.valueAt(i); 226} 227 228static const String16 sDump("android.permission.DUMP"); 229 230status_t SensorService::dump(int fd, const Vector<String16>& /*args*/) 231{ 232 String8 result; 233 if (!PermissionCache::checkCallingPermission(sDump)) { 234 result.appendFormat("Permission Denial: " 235 "can't dump SensorService from pid=%d, uid=%d\n", 236 IPCThreadState::self()->getCallingPid(), 237 IPCThreadState::self()->getCallingUid()); 238 } else { 239 Mutex::Autolock _l(mLock); 240 result.append("Sensor List:\n"); 241 for (size_t i=0 ; i<mSensorList.size() ; i++) { 242 const Sensor& s(mSensorList[i]); 243 const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle())); 244 result.appendFormat( 245 "%-15s| %-10s| %-20s| 0x%08x | \"%s\" | type=%d |", 246 s.getName().string(), 247 s.getVendor().string(), 248 s.getStringType().string(), 249 s.getHandle(), 250 s.getRequiredPermission().string(), 251 s.getType()); 252 253 const int reportingMode = s.getReportingMode(); 254 if (reportingMode == AREPORTING_MODE_CONTINUOUS) { 255 result.append(" continuous | "); 256 } else if (reportingMode == AREPORTING_MODE_ON_CHANGE) { 257 result.append(" on-change | "); 258 } else if (reportingMode == AREPORTING_MODE_ONE_SHOT) { 259 result.append(" one-shot | "); 260 } else { 261 result.append(" special-trigger | "); 262 } 263 264 if (s.getMaxDelay() > 0) { 265 result.appendFormat("minRate=%.2fHz | ", 1e6f / s.getMaxDelay()); 266 } else { 267 result.appendFormat("maxDelay=%dus |", s.getMaxDelay()); 268 } 269 270 if (s.getMinDelay() > 0) { 271 result.appendFormat("maxRate=%.2fHz | ", 1e6f / s.getMinDelay()); 272 } else { 273 result.appendFormat("minDelay=%dus |", s.getMinDelay()); 274 } 275 276 if (s.getFifoMaxEventCount() > 0) { 277 result.appendFormat("FifoMax=%d events | ", 278 s.getFifoMaxEventCount()); 279 } else { 280 result.append("no batching | "); 281 } 282 283 if (s.isWakeUpSensor()) { 284 result.appendFormat("wakeUp | "); 285 } else { 286 result.appendFormat("non-wakeUp | "); 287 } 288 289 switch (s.getType()) { 290 case SENSOR_TYPE_ROTATION_VECTOR: 291 case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 292 result.appendFormat( 293 "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 294 e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.timestamp); 295 break; 296 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 297 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 298 result.appendFormat( 299 "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 300 e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.data[5], 301 e.timestamp); 302 break; 303 case SENSOR_TYPE_GAME_ROTATION_VECTOR: 304 result.appendFormat( 305 "last=<%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 306 e.data[0], e.data[1], e.data[2], e.data[3], e.timestamp); 307 break; 308 case SENSOR_TYPE_SIGNIFICANT_MOTION: 309 case SENSOR_TYPE_STEP_DETECTOR: 310 result.appendFormat( "last=<%f %" PRId64 ">\n", e.data[0], e.timestamp); 311 break; 312 case SENSOR_TYPE_STEP_COUNTER: 313 result.appendFormat( "last=<%" PRIu64 ", %" PRId64 ">\n", e.u64.step_counter, 314 e.timestamp); 315 break; 316 default: 317 // default to 3 values 318 result.appendFormat( 319 "last=<%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 320 e.data[0], e.data[1], e.data[2], e.timestamp); 321 break; 322 } 323 result.append("\n"); 324 } 325 SensorFusion::getInstance().dump(result); 326 SensorDevice::getInstance().dump(result); 327 328 result.append("Active sensors:\n"); 329 for (size_t i=0 ; i<mActiveSensors.size() ; i++) { 330 int handle = mActiveSensors.keyAt(i); 331 result.appendFormat("%s (handle=0x%08x, connections=%zu)\n", 332 getSensorName(handle).string(), 333 handle, 334 mActiveSensors.valueAt(i)->getNumConnections()); 335 } 336 337 result.appendFormat("Socket Buffer size = %d events\n", 338 mSocketBufferSize/sizeof(sensors_event_t)); 339 result.appendFormat("WakeLock Status: %s \n", mWakeLockAcquired ? "acquired" : "not held"); 340 result.appendFormat("%zd active connections\n", mActiveConnections.size()); 341 342 for (size_t i=0 ; i < mActiveConnections.size() ; i++) { 343 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 344 if (connection != 0) { 345 result.appendFormat("Connection Number: %zu \n", i); 346 connection->dump(result); 347 } 348 } 349 } 350 write(fd, result.string(), result.size()); 351 return NO_ERROR; 352} 353 354void SensorService::cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection, 355 sensors_event_t const* buffer, const int count) { 356 for (int i=0 ; i<count ; i++) { 357 int handle = buffer[i].sensor; 358 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 359 handle = buffer[i].meta_data.sensor; 360 } 361 if (connection->hasSensor(handle)) { 362 SensorInterface* sensor = mSensorMap.valueFor(handle); 363 // If this buffer has an event from a one_shot sensor and this connection is registered 364 // for this particular one_shot sensor, try cleaning up the connection. 365 if (sensor != NULL && 366 sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 367 sensor->autoDisable(connection.get(), handle); 368 cleanupWithoutDisableLocked(connection, handle); 369 } 370 } 371 } 372} 373 374bool SensorService::threadLoop() 375{ 376 ALOGD("nuSensorService thread starting..."); 377 378 // each virtual sensor could generate an event per "real" event, that's why we need 379 // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT. 380 // in practice, this is too aggressive, but guaranteed to be enough. 381 const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 382 const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size()); 383 384 SensorDevice& device(SensorDevice::getInstance()); 385 const size_t vcount = mVirtualSensorList.size(); 386 387 SensorEventAckReceiver sender(this); 388 sender.run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY); 389 const int halVersion = device.getHalDeviceVersion(); 390 do { 391 ssize_t count = device.poll(mSensorEventBuffer, numEventMax); 392 if (count < 0) { 393 ALOGE("sensor poll failed (%s)", strerror(-count)); 394 break; 395 } 396 397 // Reset sensors_event_t.flags to zero for all events in the buffer. 398 for (int i = 0; i < count; i++) { 399 mSensorEventBuffer[i].flags = 0; 400 } 401 402 // Make a copy of the connection vector as some connections may be removed during the 403 // course of this loop (especially when one-shot sensor events are present in the 404 // sensor_event buffer). Promote all connections to StrongPointers before the lock is 405 // acquired. If the destructor of the sp gets called when the lock is acquired, it may 406 // result in a deadlock as ~SensorEventConnection() needs to acquire mLock again for 407 // cleanup. So copy all the strongPointers to a vector before the lock is acquired. 408 SortedVector< sp<SensorEventConnection> > activeConnections; 409 { 410 Mutex::Autolock _l(mLock); 411 for (size_t i=0 ; i < mActiveConnections.size(); ++i) { 412 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 413 if (connection != 0) { 414 activeConnections.add(connection); 415 } 416 } 417 } 418 419 Mutex::Autolock _l(mLock); 420 // Poll has returned. Hold a wakelock if one of the events is from a wake up sensor. The 421 // rest of this loop is under a critical section protected by mLock. Acquiring a wakeLock, 422 // sending events to clients (incrementing SensorEventConnection::mWakeLockRefCount) should 423 // not be interleaved with decrementing SensorEventConnection::mWakeLockRefCount and 424 // releasing the wakelock. 425 bool bufferHasWakeUpEvent = false; 426 for (int i = 0; i < count; i++) { 427 if (isWakeUpSensorEvent(mSensorEventBuffer[i])) { 428 bufferHasWakeUpEvent = true; 429 break; 430 } 431 } 432 433 if (bufferHasWakeUpEvent && !mWakeLockAcquired) { 434 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 435 mWakeLockAcquired = true; 436 ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock %s", WAKE_LOCK_NAME); 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 ALOGD_IF(DEBUG_CONNECTIONS, "released wakelock %s", WAKE_LOCK_NAME); 527 } 528 } while (!Thread::exitPending()); 529 530 ALOGW("Exiting SensorService::threadLoop => aborting..."); 531 abort(); 532 return false; 533} 534 535sp<Looper> SensorService::getLooper() const { 536 return mLooper; 537} 538 539bool SensorService::SensorEventAckReceiver::threadLoop() { 540 ALOGD("new thread SensorEventAckReceiver"); 541 do { 542 sp<Looper> looper = mService->getLooper(); 543 looper->pollOnce(-1); 544 } while(!Thread::exitPending()); 545 return false; 546} 547 548void SensorService::recordLastValueLocked( 549 const sensors_event_t* buffer, size_t count) { 550 const sensors_event_t* last = NULL; 551 for (size_t i = 0; i < count; i++) { 552 const sensors_event_t* event = &buffer[i]; 553 if (event->type != SENSOR_TYPE_META_DATA) { 554 if (last && event->sensor != last->sensor) { 555 mLastEventSeen.editValueFor(last->sensor) = *last; 556 } 557 last = event; 558 } 559 } 560 if (last) { 561 mLastEventSeen.editValueFor(last->sensor) = *last; 562 } 563} 564 565void SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count) 566{ 567 struct compar { 568 static int cmp(void const* lhs, void const* rhs) { 569 sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs); 570 sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs); 571 return l->timestamp - r->timestamp; 572 } 573 }; 574 qsort(buffer, count, sizeof(sensors_event_t), compar::cmp); 575} 576 577String8 SensorService::getSensorName(int handle) const { 578 size_t count = mUserSensorList.size(); 579 for (size_t i=0 ; i<count ; i++) { 580 const Sensor& sensor(mUserSensorList[i]); 581 if (sensor.getHandle() == handle) { 582 return sensor.getName(); 583 } 584 } 585 String8 result("unknown"); 586 return result; 587} 588 589bool SensorService::isVirtualSensor(int handle) const { 590 SensorInterface* sensor = mSensorMap.valueFor(handle); 591 return sensor->isVirtual(); 592} 593 594bool SensorService::isWakeUpSensorEvent(const sensors_event_t& event) const { 595 int handle = event.sensor; 596 if (event.type == SENSOR_TYPE_META_DATA) { 597 handle = event.meta_data.sensor; 598 } 599 SensorInterface* sensor = mSensorMap.valueFor(handle); 600 return sensor != NULL && sensor->getSensor().isWakeUpSensor(); 601} 602 603 604SensorService::SensorRecord * SensorService::getSensorRecord(int handle) { 605 return mActiveSensors.valueFor(handle); 606} 607 608Vector<Sensor> SensorService::getSensorList() 609{ 610 char value[PROPERTY_VALUE_MAX]; 611 property_get("debug.sensors", value, "0"); 612 const Vector<Sensor>& initialSensorList = (atoi(value)) ? 613 mUserSensorListDebug : mUserSensorList; 614 Vector<Sensor> accessibleSensorList; 615 for (size_t i = 0; i < initialSensorList.size(); i++) { 616 Sensor sensor = initialSensorList[i]; 617 if (canAccessSensor(sensor)) { 618 accessibleSensorList.add(sensor); 619 } else { 620 String8 infoMessage; 621 infoMessage.appendFormat( 622 "Skipped sensor %s because it requires permission %s", 623 sensor.getName().string(), 624 sensor.getRequiredPermission().string()); 625 ALOGI(infoMessage.string()); 626 } 627 } 628 return accessibleSensorList; 629} 630 631sp<ISensorEventConnection> SensorService::createSensorEventConnection() 632{ 633 uid_t uid = IPCThreadState::self()->getCallingUid(); 634 sp<SensorEventConnection> result(new SensorEventConnection(this, uid)); 635 return result; 636} 637 638void SensorService::cleanupConnection(SensorEventConnection* c) 639{ 640 Mutex::Autolock _l(mLock); 641 const wp<SensorEventConnection> connection(c); 642 size_t size = mActiveSensors.size(); 643 ALOGD_IF(DEBUG_CONNECTIONS, "%zu active sensors", size); 644 for (size_t i=0 ; i<size ; ) { 645 int handle = mActiveSensors.keyAt(i); 646 if (c->hasSensor(handle)) { 647 ALOGD_IF(DEBUG_CONNECTIONS, "%zu: disabling handle=0x%08x", i, handle); 648 SensorInterface* sensor = mSensorMap.valueFor( handle ); 649 ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle); 650 if (sensor) { 651 sensor->activate(c, false); 652 } 653 } 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 mLooper->removeFd(c->getSensorChannel()->getSendFd()); 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 && sensor->getSensor().isWakeUpSensor()) { 775 // Add the file descriptor to the Looper for receiving acknowledgments; 776 int ret = mLooper->addFd(connection->getSensorChannel()->getSendFd(), 0, 777 ALOOPER_EVENT_INPUT, connection.get(), NULL); 778 } 779 780 if (err != NO_ERROR) { 781 // batch/activate has failed, reset our state. 782 cleanupWithoutDisableLocked(connection, handle); 783 } 784 return err; 785} 786 787status_t SensorService::disable(const sp<SensorEventConnection>& connection, 788 int handle) 789{ 790 if (mInitCheck != NO_ERROR) 791 return mInitCheck; 792 793 Mutex::Autolock _l(mLock); 794 status_t err = cleanupWithoutDisableLocked(connection, handle); 795 if (err == NO_ERROR) { 796 SensorInterface* sensor = mSensorMap.valueFor(handle); 797 err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE); 798 } 799 return err; 800} 801 802status_t SensorService::cleanupWithoutDisable( 803 const sp<SensorEventConnection>& connection, int handle) { 804 Mutex::Autolock _l(mLock); 805 return cleanupWithoutDisableLocked(connection, handle); 806} 807 808status_t SensorService::cleanupWithoutDisableLocked( 809 const sp<SensorEventConnection>& connection, int handle) { 810 SensorRecord* rec = mActiveSensors.valueFor(handle); 811 if (rec) { 812 // see if this connection becomes inactive 813 if (connection->removeSensor(handle)) { 814 BatteryService::disableSensor(connection->getUid(), handle); 815 } 816 if (connection->hasAnySensor() == false) { 817 mLooper->removeFd(connection->getSensorChannel()->getSendFd()); 818 mActiveConnections.remove(connection); 819 } 820 // see if this sensor becomes inactive 821 if (rec->removeConnection(connection)) { 822 mActiveSensors.removeItem(handle); 823 mActiveVirtualSensors.removeItem(handle); 824 delete rec; 825 } 826 return NO_ERROR; 827 } 828 return BAD_VALUE; 829} 830 831status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection, 832 int handle, nsecs_t ns) 833{ 834 if (mInitCheck != NO_ERROR) 835 return mInitCheck; 836 837 SensorInterface* sensor = mSensorMap.valueFor(handle); 838 if (!sensor) 839 return BAD_VALUE; 840 841 if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) { 842 return BAD_VALUE; 843 } 844 845 if (ns < 0) 846 return BAD_VALUE; 847 848 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 849 if (ns < minDelayNs) { 850 ns = minDelayNs; 851 } 852 853 return sensor->setDelay(connection.get(), handle, ns); 854} 855 856status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection) { 857 if (mInitCheck != NO_ERROR) return mInitCheck; 858 SensorDevice& dev(SensorDevice::getInstance()); 859 const int halVersion = dev.getHalDeviceVersion(); 860 status_t err(NO_ERROR); 861 Mutex::Autolock _l(mLock); 862 // Loop through all sensors for this connection and call flush on each of them. 863 for (size_t i = 0; i < connection->mSensorInfo.size(); ++i) { 864 const int handle = connection->mSensorInfo.keyAt(i); 865 SensorInterface* sensor = mSensorMap.valueFor(handle); 866 if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 867 ALOGE("flush called on a one-shot sensor"); 868 err = INVALID_OPERATION; 869 continue; 870 } 871 SensorEventConnection::FlushInfo& flushInfo = connection->mSensorInfo.editValueFor(handle); 872 if (halVersion <= SENSORS_DEVICE_API_VERSION_1_0 || isVirtualSensor(handle)) { 873 // For older devices just increment pending flush count which will send a trivial 874 // flush complete event. 875 flushInfo.mPendingFlushEventsToSend++; 876 } else { 877 status_t err_flush = sensor->flush(connection.get(), handle); 878 if (err_flush == NO_ERROR) { 879 SensorRecord* rec = mActiveSensors.valueFor(handle); 880 if (rec != NULL) rec->addPendingFlushConnection(connection); 881 } 882 err = (err_flush != NO_ERROR) ? err_flush : err; 883 } 884 } 885 return err; 886} 887 888bool SensorService::canAccessSensor(const Sensor& sensor) { 889 return (sensor.getRequiredPermission().isEmpty()) || 890 PermissionCache::checkCallingPermission(String16(sensor.getRequiredPermission())); 891} 892 893bool SensorService::verifyCanAccessSensor(const Sensor& sensor, const char* operation) { 894 if (canAccessSensor(sensor)) { 895 return true; 896 } else { 897 String8 errorMessage; 898 errorMessage.appendFormat( 899 "%s a sensor (%s) without holding its required permission: %s", 900 operation, 901 sensor.getName().string(), 902 sensor.getRequiredPermission().string()); 903 return false; 904 } 905} 906 907void SensorService::checkWakeLockState() { 908 Mutex::Autolock _l(mLock); 909 checkWakeLockStateLocked(); 910} 911 912void SensorService::checkWakeLockStateLocked() { 913 if (!mWakeLockAcquired) { 914 return; 915 } 916 bool releaseLock = true; 917 for (size_t i=0 ; i<mActiveConnections.size() ; i++) { 918 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 919 if (connection != 0) { 920 if (connection->needsWakeLock()) { 921 releaseLock = false; 922 break; 923 } 924 } 925 } 926 if (releaseLock) { 927 ALOGD_IF(DEBUG_CONNECTIONS, "releasing wakelock %s", WAKE_LOCK_NAME); 928 release_wake_lock(WAKE_LOCK_NAME); 929 mWakeLockAcquired = false; 930 } 931} 932 933// --------------------------------------------------------------------------- 934SensorService::SensorRecord::SensorRecord( 935 const sp<SensorEventConnection>& connection) 936{ 937 mConnections.add(connection); 938} 939 940bool SensorService::SensorRecord::addConnection( 941 const sp<SensorEventConnection>& connection) 942{ 943 if (mConnections.indexOf(connection) < 0) { 944 mConnections.add(connection); 945 return true; 946 } 947 return false; 948} 949 950bool SensorService::SensorRecord::removeConnection( 951 const wp<SensorEventConnection>& connection) 952{ 953 ssize_t index = mConnections.indexOf(connection); 954 if (index >= 0) { 955 mConnections.removeItemsAt(index, 1); 956 } 957 // Remove this connections from the queue of flush() calls made on this sensor. 958 for (Vector< wp<SensorEventConnection> >::iterator it = 959 mPendingFlushConnections.begin(); it != mPendingFlushConnections.end();) { 960 if (it->unsafe_get() == connection.unsafe_get()) { 961 it = mPendingFlushConnections.erase(it); 962 } else { 963 ++it; 964 } 965 } 966 return mConnections.size() ? false : true; 967} 968 969void SensorService::SensorRecord::addPendingFlushConnection( 970 const sp<SensorEventConnection>& connection) { 971 mPendingFlushConnections.add(connection); 972} 973 974void SensorService::SensorRecord::removeFirstPendingFlushConnection() { 975 if (mPendingFlushConnections.size() > 0) { 976 mPendingFlushConnections.removeAt(0); 977 } 978} 979 980SensorService::SensorEventConnection * 981SensorService::SensorRecord::getFirstPendingFlushConnection() { 982 if (mPendingFlushConnections.size() > 0) { 983 return mPendingFlushConnections[0].unsafe_get(); 984 } 985 return NULL; 986} 987 988// --------------------------------------------------------------------------- 989 990SensorService::SensorEventConnection::SensorEventConnection( 991 const sp<SensorService>& service, uid_t uid) 992 : mService(service), mUid(uid), mWakeLockRefCount(0), mEventCache(NULL), mCacheSize(0), 993 mMaxCacheSize(0) { 994 const SensorDevice& device(SensorDevice::getInstance()); 995 mChannel = new BitTube(mService->mSocketBufferSize); 996#if DEBUG_CONNECTIONS 997 mEventsReceived = mEventsSentFromCache = mEventsSent = 0; 998 mTotalAcksNeeded = mTotalAcksReceived = 0; 999#endif 1000} 1001 1002SensorService::SensorEventConnection::~SensorEventConnection() { 1003 ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this); 1004 mService->cleanupConnection(this); 1005 if (mEventCache != NULL) { 1006 delete mEventCache; 1007 } 1008} 1009 1010void SensorService::SensorEventConnection::onFirstRef() { 1011 LooperCallback::onFirstRef(); 1012} 1013 1014bool SensorService::SensorEventConnection::needsWakeLock() { 1015 Mutex::Autolock _l(mConnectionLock); 1016 return mWakeLockRefCount > 0; 1017} 1018 1019void SensorService::SensorEventConnection::dump(String8& result) { 1020 Mutex::Autolock _l(mConnectionLock); 1021 result.appendFormat("\t WakeLockRefCount %d | uid %d | cache size %d | max cache size %d\n", 1022 mWakeLockRefCount, mUid, mCacheSize, mMaxCacheSize); 1023 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1024 const FlushInfo& flushInfo = mSensorInfo.valueAt(i); 1025 result.appendFormat("\t %s 0x%08x | status: %s | pending flush events %d \n", 1026 mService->getSensorName(mSensorInfo.keyAt(i)).string(), 1027 mSensorInfo.keyAt(i), 1028 flushInfo.mFirstFlushPending ? "First flush pending" : 1029 "active", 1030 flushInfo.mPendingFlushEventsToSend); 1031 } 1032#if DEBUG_CONNECTIONS 1033 result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d |" 1034 " total_acks_needed %d | total_acks_recvd %d\n", 1035 mEventsReceived, 1036 mEventsSent, 1037 mEventsSentFromCache, 1038 mEventsReceived - (mEventsSentFromCache + mEventsSent + mCacheSize), 1039 mTotalAcksNeeded, 1040 mTotalAcksReceived); 1041#endif 1042} 1043 1044bool SensorService::SensorEventConnection::addSensor(int32_t handle) { 1045 Mutex::Autolock _l(mConnectionLock); 1046 if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) { 1047 return false; 1048 } 1049 if (mSensorInfo.indexOfKey(handle) < 0) { 1050 mSensorInfo.add(handle, FlushInfo()); 1051 return true; 1052 } 1053 return false; 1054} 1055 1056bool SensorService::SensorEventConnection::removeSensor(int32_t handle) { 1057 Mutex::Autolock _l(mConnectionLock); 1058 if (mSensorInfo.removeItem(handle) >= 0) { 1059 return true; 1060 } 1061 return false; 1062} 1063 1064bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const { 1065 Mutex::Autolock _l(mConnectionLock); 1066 return mSensorInfo.indexOfKey(handle) >= 0; 1067} 1068 1069bool SensorService::SensorEventConnection::hasAnySensor() const { 1070 Mutex::Autolock _l(mConnectionLock); 1071 return mSensorInfo.size() ? true : false; 1072} 1073 1074bool SensorService::SensorEventConnection::hasOneShotSensors() const { 1075 Mutex::Autolock _l(mConnectionLock); 1076 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1077 const int handle = mSensorInfo.keyAt(i); 1078 if (mService->getSensorFromHandle(handle).getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 1079 return true; 1080 } 1081 } 1082 return false; 1083} 1084 1085void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle, 1086 bool value) { 1087 Mutex::Autolock _l(mConnectionLock); 1088 ssize_t index = mSensorInfo.indexOfKey(handle); 1089 if (index >= 0) { 1090 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1091 flushInfo.mFirstFlushPending = value; 1092 } 1093} 1094 1095status_t SensorService::SensorEventConnection::sendEvents( 1096 sensors_event_t const* buffer, size_t numEvents, 1097 sensors_event_t* scratch, 1098 SensorEventConnection const * const * mapFlushEventsToConnections) { 1099 // filter out events not for this connection 1100 size_t count = 0; 1101 Mutex::Autolock _l(mConnectionLock); 1102 if (scratch) { 1103 size_t i=0; 1104 while (i<numEvents) { 1105 int32_t sensor_handle = buffer[i].sensor; 1106 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1107 ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ", 1108 buffer[i].meta_data.sensor); 1109 // Setting sensor_handle to the correct sensor to ensure the sensor events per connection are 1110 // filtered correctly. buffer[i].sensor is zero for meta_data events. 1111 sensor_handle = buffer[i].meta_data.sensor; 1112 } 1113 ssize_t index = mSensorInfo.indexOfKey(sensor_handle); 1114 // Check if this connection has registered for this sensor. If not continue to the 1115 // next sensor_event. 1116 if (index < 0) { 1117 ++i; 1118 continue; 1119 } 1120 1121 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1122 // Check if there is a pending flush_complete event for this sensor on this connection. 1123 if (buffer[i].type == SENSOR_TYPE_META_DATA && flushInfo.mFirstFlushPending == true && 1124 this == mapFlushEventsToConnections[i]) { 1125 flushInfo.mFirstFlushPending = false; 1126 ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ", 1127 buffer[i].meta_data.sensor); 1128 ++i; 1129 continue; 1130 } 1131 1132 // If there is a pending flush complete event for this sensor on this connection, 1133 // ignore the event and proceed to the next. 1134 if (flushInfo.mFirstFlushPending) { 1135 ++i; 1136 continue; 1137 } 1138 1139 do { 1140 // Keep copying events into the scratch buffer as long as they are regular 1141 // sensor_events are from the same sensor_handle OR they are flush_complete_events 1142 // from the same sensor_handle AND the current connection is mapped to the 1143 // corresponding flush_complete_event. 1144 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1145 if (this == mapFlushEventsToConnections[i]) { 1146 scratch[count++] = buffer[i]; 1147 } 1148 ++i; 1149 } else { 1150 // Regular sensor event, just copy it to the scratch buffer. 1151 scratch[count++] = buffer[i++]; 1152 } 1153 } while ((i<numEvents) && ((buffer[i].sensor == sensor_handle && 1154 buffer[i].type != SENSOR_TYPE_META_DATA) || 1155 (buffer[i].type == SENSOR_TYPE_META_DATA && 1156 buffer[i].meta_data.sensor == sensor_handle))); 1157 } 1158 } else { 1159 scratch = const_cast<sensors_event_t *>(buffer); 1160 count = numEvents; 1161 } 1162 1163 sendPendingFlushEventsLocked(); 1164 // Early return if there are no events for this connection. 1165 if (count == 0) { 1166 return status_t(NO_ERROR); 1167 } 1168 1169#if DEBUG_CONNECTIONS 1170 mEventsReceived += count; 1171#endif 1172 if (mCacheSize != 0) { 1173 // There are some events in the cache which need to be sent first. Copy this buffer to 1174 // the end of cache. 1175 if (mCacheSize + count <= mMaxCacheSize) { 1176 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1177 mCacheSize += count; 1178 } else { 1179 // Check if any new sensors have registered on this connection which may have increased 1180 // the max cache size that is desired. 1181 if (mCacheSize + count < computeMaxCacheSizeLocked()) { 1182 reAllocateCacheLocked(scratch, count); 1183 return status_t(NO_ERROR); 1184 } 1185 // Some events need to be dropped. 1186 int remaningCacheSize = mMaxCacheSize - mCacheSize; 1187 if (remaningCacheSize != 0) { 1188 memcpy(&mEventCache[mCacheSize], scratch, 1189 remaningCacheSize * sizeof(sensors_event_t)); 1190 } 1191 int numEventsDropped = count - remaningCacheSize; 1192 countFlushCompleteEventsLocked(mEventCache, numEventsDropped); 1193 // Drop the first "numEventsDropped" in the cache. 1194 memmove(mEventCache, &mEventCache[numEventsDropped], 1195 (mCacheSize - numEventsDropped) * sizeof(sensors_event_t)); 1196 1197 // Copy the remainingEvents in scratch buffer to the end of cache. 1198 memcpy(&mEventCache[mCacheSize - numEventsDropped], scratch + remaningCacheSize, 1199 numEventsDropped * sizeof(sensors_event_t)); 1200 } 1201 return status_t(NO_ERROR); 1202 } 1203 1204 int index_wake_up_event = findWakeUpSensorEventLocked(scratch, count); 1205 if (index_wake_up_event >= 0) { 1206 scratch[index_wake_up_event].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1207 ++mWakeLockRefCount; 1208#if DEBUG_CONNECTIONS 1209 ++mTotalAcksNeeded; 1210#endif 1211 } 1212 1213 // NOTE: ASensorEvent and sensors_event_t are the same type. 1214 ssize_t size = SensorEventQueue::write(mChannel, 1215 reinterpret_cast<ASensorEvent const*>(scratch), count); 1216 if (size < 0) { 1217 // Write error, copy events to local cache. 1218 if (index_wake_up_event >= 0) { 1219 // If there was a wake_up sensor_event, reset the flag. 1220 scratch[index_wake_up_event].flags &= ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1221 if (mWakeLockRefCount > 0) { 1222 --mWakeLockRefCount; 1223 } 1224#if DEBUG_CONNECTIONS 1225 --mTotalAcksNeeded; 1226#endif 1227 } 1228 if (mEventCache == NULL) { 1229 mMaxCacheSize = computeMaxCacheSizeLocked(); 1230 mEventCache = new sensors_event_t[mMaxCacheSize]; 1231 mCacheSize = 0; 1232 } 1233 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1234 mCacheSize += count; 1235 1236 // Add this file descriptor to the looper to get a callback when this fd is available for 1237 // writing. 1238 mService->getLooper()->addFd(mChannel->getSendFd(), 0, 1239 ALOOPER_EVENT_OUTPUT | ALOOPER_EVENT_INPUT, this, NULL); 1240 return size; 1241 } 1242 1243#if DEBUG_CONNECTIONS 1244 if (size > 0) { 1245 mEventsSent += count; 1246 } 1247#endif 1248 1249 return size < 0 ? status_t(size) : status_t(NO_ERROR); 1250} 1251 1252void SensorService::SensorEventConnection::reAllocateCacheLocked(sensors_event_t const* scratch, 1253 int count) { 1254 sensors_event_t *eventCache_new; 1255 const int new_cache_size = computeMaxCacheSizeLocked(); 1256 // Allocate new cache, copy over events from the old cache & scratch, free up memory. 1257 eventCache_new = new sensors_event_t[new_cache_size]; 1258 memcpy(eventCache_new, mEventCache, mCacheSize * sizeof(sensors_event_t)); 1259 memcpy(&eventCache_new[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1260 1261 ALOGD_IF(DEBUG_CONNECTIONS, "reAllocateCacheLocked maxCacheSize=%d %d", mMaxCacheSize, 1262 new_cache_size); 1263 1264 delete mEventCache; 1265 mEventCache = eventCache_new; 1266 mCacheSize += count; 1267 mMaxCacheSize = new_cache_size; 1268} 1269 1270void SensorService::SensorEventConnection::sendPendingFlushEventsLocked() { 1271 ASensorEvent flushCompleteEvent; 1272 memset(&flushCompleteEvent, 0, sizeof(flushCompleteEvent)); 1273 flushCompleteEvent.type = SENSOR_TYPE_META_DATA; 1274 // Loop through all the sensors for this connection and check if there are any pending 1275 // flush complete events to be sent. 1276 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1277 FlushInfo& flushInfo = mSensorInfo.editValueAt(i); 1278 while (flushInfo.mPendingFlushEventsToSend > 0) { 1279 const int sensor_handle = mSensorInfo.keyAt(i); 1280 flushCompleteEvent.meta_data.sensor = sensor_handle; 1281 if (mService->getSensorFromHandle(sensor_handle).isWakeUpSensor()) { 1282 flushCompleteEvent.flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1283 } 1284 ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1); 1285 if (size < 0) { 1286 return; 1287 } 1288 ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ", 1289 flushCompleteEvent.meta_data.sensor); 1290 flushInfo.mPendingFlushEventsToSend--; 1291 } 1292 } 1293} 1294 1295void SensorService::SensorEventConnection::writeToSocketFromCacheLocked() { 1296 // At a time write at most half the size of the receiver buffer in SensorEventQueue OR 1297 // half the size of the socket buffer allocated in BitTube whichever is smaller. 1298 const int maxWriteSize = helpers::min(SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT/2, 1299 int(mService->mSocketBufferSize/(sizeof(sensors_event_t)*2))); 1300 // Send pending flush complete events (if any) 1301 sendPendingFlushEventsLocked(); 1302 for (int numEventsSent = 0; numEventsSent < mCacheSize;) { 1303 const int numEventsToWrite = helpers::min(mCacheSize - numEventsSent, maxWriteSize); 1304 int index_wake_up_event = 1305 findWakeUpSensorEventLocked(mEventCache + numEventsSent, numEventsToWrite); 1306 if (index_wake_up_event >= 0) { 1307 mEventCache[index_wake_up_event + numEventsSent].flags |= 1308 WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1309 ++mWakeLockRefCount; 1310#if DEBUG_CONNECTIONS 1311 ++mTotalAcksNeeded; 1312#endif 1313 } 1314 1315 ssize_t size = SensorEventQueue::write(mChannel, 1316 reinterpret_cast<ASensorEvent const*>(mEventCache + numEventsSent), 1317 numEventsToWrite); 1318 if (size < 0) { 1319 if (index_wake_up_event >= 0) { 1320 // If there was a wake_up sensor_event, reset the flag. 1321 mEventCache[index_wake_up_event + numEventsSent].flags &= 1322 ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1323 if (mWakeLockRefCount > 0) { 1324 --mWakeLockRefCount; 1325 } 1326#if DEBUG_CONNECTIONS 1327 --mTotalAcksNeeded; 1328#endif 1329 } 1330 memmove(mEventCache, &mEventCache[numEventsSent], 1331 (mCacheSize - numEventsSent) * sizeof(sensors_event_t)); 1332 ALOGD_IF(DEBUG_CONNECTIONS, "wrote %d events from cache size==%d ", 1333 numEventsSent, mCacheSize); 1334 mCacheSize -= numEventsSent; 1335 return; 1336 } 1337 numEventsSent += numEventsToWrite; 1338#if DEBUG_CONNECTIONS 1339 mEventsSentFromCache += numEventsToWrite; 1340#endif 1341 } 1342 ALOGD_IF(DEBUG_CONNECTIONS, "wrote all events from cache size=%d ", mCacheSize); 1343 // All events from the cache have been sent. Reset cache size to zero. 1344 mCacheSize = 0; 1345 // Poll only for ALOOPER_EVENT_INPUT(read) on the file descriptor. 1346 mService->getLooper()->addFd(mChannel->getSendFd(), 0, ALOOPER_EVENT_INPUT, this, NULL); 1347} 1348 1349void SensorService::SensorEventConnection::countFlushCompleteEventsLocked( 1350 sensors_event_t const* scratch, const int numEventsDropped) { 1351 ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped); 1352 // Count flushComplete events in the events that are about to the dropped. These will be sent 1353 // separately before the next batch of events. 1354 for (int j = 0; j < numEventsDropped; ++j) { 1355 if (scratch[j].type == SENSOR_TYPE_META_DATA) { 1356 FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor); 1357 flushInfo.mPendingFlushEventsToSend++; 1358 ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d", 1359 flushInfo.mPendingFlushEventsToSend); 1360 } 1361 } 1362 return; 1363} 1364 1365int SensorService::SensorEventConnection::findWakeUpSensorEventLocked( 1366 sensors_event_t const* scratch, const int count) { 1367 for (int i = 0; i < count; ++i) { 1368 if (mService->isWakeUpSensorEvent(scratch[i])) { 1369 return i; 1370 } 1371 } 1372 return -1; 1373} 1374 1375sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const 1376{ 1377 return mChannel; 1378} 1379 1380status_t SensorService::SensorEventConnection::enableDisable( 1381 int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, 1382 int reservedFlags) 1383{ 1384 status_t err; 1385 if (enabled) { 1386 err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs, 1387 reservedFlags); 1388 1389 } else { 1390 err = mService->disable(this, handle); 1391 } 1392 return err; 1393} 1394 1395status_t SensorService::SensorEventConnection::setEventRate( 1396 int handle, nsecs_t samplingPeriodNs) 1397{ 1398 return mService->setEventRate(this, handle, samplingPeriodNs); 1399} 1400 1401status_t SensorService::SensorEventConnection::flush() { 1402 return mService->flushSensor(this); 1403} 1404 1405int SensorService::SensorEventConnection::handleEvent(int fd, int events, void* data) { 1406 if (events & ALOOPER_EVENT_HANGUP || events & ALOOPER_EVENT_ERROR) { 1407 return 0; 1408 } 1409 1410 if (events & ALOOPER_EVENT_INPUT) { 1411 char buf; 1412 ssize_t ret = ::recv(fd, &buf, sizeof(buf), MSG_DONTWAIT); 1413 1414 { 1415 Mutex::Autolock _l(mConnectionLock); 1416 if (mWakeLockRefCount > 0) { 1417 --mWakeLockRefCount; 1418 } 1419#if DEBUG_CONNECTIONS 1420 ++mTotalAcksReceived; 1421#endif 1422 } 1423 // Check if wakelock can be released by sensorservice. mConnectionLock needs to be released 1424 // here as checkWakeLockState() will need it. 1425 if (mWakeLockRefCount == 0) { 1426 mService->checkWakeLockState(); 1427 } 1428 // continue getting callbacks. 1429 return 1; 1430 } 1431 1432 if (events & ALOOPER_EVENT_OUTPUT) { 1433 // send sensor data that is stored in mEventCache. 1434 Mutex::Autolock _l(mConnectionLock); 1435 writeToSocketFromCacheLocked(); 1436 } 1437 return 1; 1438} 1439 1440int SensorService::SensorEventConnection::computeMaxCacheSizeLocked() const { 1441 int fifoWakeUpSensors = 0; 1442 int fifoNonWakeUpSensors = 0; 1443 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1444 const Sensor& sensor = mService->getSensorFromHandle(mSensorInfo.keyAt(i)); 1445 if (sensor.getFifoReservedEventCount() == sensor.getFifoMaxEventCount()) { 1446 // Each sensor has a reserved fifo. Sum up the fifo sizes for all wake up sensors and 1447 // non wake_up sensors. 1448 if (sensor.isWakeUpSensor()) { 1449 fifoWakeUpSensors += sensor.getFifoReservedEventCount(); 1450 } else { 1451 fifoNonWakeUpSensors += sensor.getFifoReservedEventCount(); 1452 } 1453 } else { 1454 // Shared fifo. Compute the max of the fifo sizes for wake_up and non_wake up sensors. 1455 if (sensor.isWakeUpSensor()) { 1456 fifoWakeUpSensors = fifoWakeUpSensors > sensor.getFifoMaxEventCount() ? 1457 fifoWakeUpSensors : sensor.getFifoMaxEventCount(); 1458 1459 } else { 1460 fifoNonWakeUpSensors = fifoNonWakeUpSensors > sensor.getFifoMaxEventCount() ? 1461 fifoNonWakeUpSensors : sensor.getFifoMaxEventCount(); 1462 1463 } 1464 } 1465 } 1466 if (fifoWakeUpSensors + fifoNonWakeUpSensors == 0) { 1467 // It is extremely unlikely that there is a write failure in non batch mode. Return a cache 1468 // size that is equal to that of the batch mode. 1469 // ALOGW("Write failure in non-batch mode"); 1470 return MAX_SOCKET_BUFFER_SIZE_BATCHED/sizeof(sensors_event_t); 1471 } 1472 return fifoWakeUpSensors + fifoNonWakeUpSensors; 1473} 1474 1475// --------------------------------------------------------------------------- 1476}; // namespace android 1477 1478