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