SensorService.cpp revision f504789dd3b3073de176fd2fa09dd9fc9de5bc1f
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/AppOpsManager.h> 35#include <binder/BinderService.h> 36#include <binder/IServiceManager.h> 37#include <binder/PermissionCache.h> 38 39#include <gui/ISensorServer.h> 40#include <gui/ISensorEventConnection.h> 41#include <gui/SensorEventQueue.h> 42 43#include <hardware/sensors.h> 44#include <hardware_legacy/power.h> 45 46#include "BatteryService.h" 47#include "CorrectedGyroSensor.h" 48#include "GravitySensor.h" 49#include "LinearAccelerationSensor.h" 50#include "OrientationSensor.h" 51#include "RotationVectorSensor.h" 52#include "SensorFusion.h" 53#include "SensorService.h" 54 55namespace android { 56// --------------------------------------------------------------------------- 57 58/* 59 * Notes: 60 * 61 * - what about a gyro-corrected magnetic-field sensor? 62 * - run mag sensor from time to time to force calibration 63 * - gravity sensor length is wrong (=> drift in linear-acc sensor) 64 * 65 */ 66 67const char* SensorService::WAKE_LOCK_NAME = "SensorService_wakelock"; 68// Permissions. 69static const String16 sDump("android.permission.DUMP"); 70 71SensorService::SensorService() 72 : mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED), 73 mWakeLockAcquired(false) 74{ 75} 76 77void SensorService::onFirstRef() 78{ 79 ALOGD("nuSensorService starting..."); 80 SensorDevice& dev(SensorDevice::getInstance()); 81 82 if (dev.initCheck() == NO_ERROR) { 83 sensor_t const* list; 84 ssize_t count = dev.getSensorList(&list); 85 if (count > 0) { 86 ssize_t orientationIndex = -1; 87 bool hasGyro = false, hasAccel = false, hasMag = false; 88 uint32_t virtualSensorsNeeds = 89 (1<<SENSOR_TYPE_GRAVITY) | 90 (1<<SENSOR_TYPE_LINEAR_ACCELERATION) | 91 (1<<SENSOR_TYPE_ROTATION_VECTOR); 92 93 mLastEventSeen.setCapacity(count); 94 for (ssize_t i=0 ; i<count ; i++) { 95 registerSensor( new HardwareSensor(list[i]) ); 96 switch (list[i].type) { 97 case SENSOR_TYPE_ACCELEROMETER: 98 hasAccel = true; 99 break; 100 case SENSOR_TYPE_MAGNETIC_FIELD: 101 hasMag = true; 102 break; 103 case SENSOR_TYPE_ORIENTATION: 104 orientationIndex = i; 105 break; 106 case SENSOR_TYPE_GYROSCOPE: 107 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 108 hasGyro = true; 109 break; 110 case SENSOR_TYPE_GRAVITY: 111 case SENSOR_TYPE_LINEAR_ACCELERATION: 112 case SENSOR_TYPE_ROTATION_VECTOR: 113 virtualSensorsNeeds &= ~(1<<list[i].type); 114 break; 115 } 116 } 117 118 // it's safe to instantiate the SensorFusion object here 119 // (it wants to be instantiated after h/w sensors have been 120 // registered) 121 const SensorFusion& fusion(SensorFusion::getInstance()); 122 123 // build the sensor list returned to users 124 mUserSensorList = mSensorList; 125 126 if (hasGyro && hasAccel && hasMag) { 127 Sensor aSensor; 128 129 // Add Android virtual sensors if they're not already 130 // available in the HAL 131 132 aSensor = registerVirtualSensor( new RotationVectorSensor() ); 133 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 134 mUserSensorList.add(aSensor); 135 } 136 137 aSensor = registerVirtualSensor( new GravitySensor(list, count) ); 138 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) { 139 mUserSensorList.add(aSensor); 140 } 141 142 aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) ); 143 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) { 144 mUserSensorList.add(aSensor); 145 } 146 147 aSensor = registerVirtualSensor( new OrientationSensor() ); 148 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 149 // if we are doing our own rotation-vector, also add 150 // the orientation sensor and remove the HAL provided one. 151 mUserSensorList.replaceAt(aSensor, orientationIndex); 152 } 153 154 // virtual debugging sensors are not added to mUserSensorList 155 registerVirtualSensor( new CorrectedGyroSensor(list, count) ); 156 registerVirtualSensor( new GyroDriftSensor() ); 157 } 158 159 // debugging sensor list 160 mUserSensorListDebug = mSensorList; 161 162 // Check if the device really supports batching by looking at the FIFO event 163 // counts for each sensor. 164 bool batchingSupported = false; 165 for (size_t i = 0; i < mSensorList.size(); ++i) { 166 if (mSensorList[i].getFifoMaxEventCount() > 0) { 167 batchingSupported = true; 168 break; 169 } 170 } 171 172 if (batchingSupported) { 173 // Increase socket buffer size to a max of 100 KB for batching capabilities. 174 mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED; 175 } else { 176 mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED; 177 } 178 179 // Compare the socketBufferSize value against the system limits and limit 180 // it to maxSystemSocketBufferSize if necessary. 181 FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r"); 182 char line[128]; 183 if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) { 184 line[sizeof(line) - 1] = '\0'; 185 size_t maxSystemSocketBufferSize; 186 sscanf(line, "%zu", &maxSystemSocketBufferSize); 187 if (mSocketBufferSize > maxSystemSocketBufferSize) { 188 mSocketBufferSize = maxSystemSocketBufferSize; 189 } 190 } 191 if (fp) { 192 fclose(fp); 193 } 194 195 mWakeLockAcquired = false; 196 mLooper = new Looper(false); 197 const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 198 mSensorEventBuffer = new sensors_event_t[minBufferSize]; 199 mSensorEventScratch = new sensors_event_t[minBufferSize]; 200 mMapFlushEventsToConnections = new SensorEventConnection const * [minBufferSize]; 201 mCurrentOperatingMode = NORMAL; 202 203 mNextSensorRegIndex = 0; 204 for (int i = 0; i < SENSOR_REGISTRATIONS_BUF_SIZE; ++i) { 205 mLastNSensorRegistrations.push(); 206 } 207 208 mInitCheck = NO_ERROR; 209 mAckReceiver = new SensorEventAckReceiver(this); 210 mAckReceiver->run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY); 211 run("SensorService", PRIORITY_URGENT_DISPLAY); 212 } 213 } 214} 215 216Sensor SensorService::registerSensor(SensorInterface* s) 217{ 218 sensors_event_t event; 219 memset(&event, 0, sizeof(event)); 220 221 const Sensor sensor(s->getSensor()); 222 // add to the sensor list (returned to clients) 223 mSensorList.add(sensor); 224 // add to our handle->SensorInterface mapping 225 mSensorMap.add(sensor.getHandle(), s); 226 // create an entry in the mLastEventSeen array 227 mLastEventSeen.add(sensor.getHandle(), NULL); 228 229 return sensor; 230} 231 232Sensor SensorService::registerVirtualSensor(SensorInterface* s) 233{ 234 Sensor sensor = registerSensor(s); 235 mVirtualSensorList.add( s ); 236 return sensor; 237} 238 239SensorService::~SensorService() 240{ 241 for (size_t i=0 ; i<mSensorMap.size() ; i++) 242 delete mSensorMap.valueAt(i); 243} 244 245status_t SensorService::dump(int fd, const Vector<String16>& args) 246{ 247 String8 result; 248 if (!PermissionCache::checkCallingPermission(sDump)) { 249 result.appendFormat("Permission Denial: " 250 "can't dump SensorService from pid=%d, uid=%d\n", 251 IPCThreadState::self()->getCallingPid(), 252 IPCThreadState::self()->getCallingUid()); 253 } else { 254 if (args.size() > 2) { 255 return INVALID_OPERATION; 256 } 257 Mutex::Autolock _l(mLock); 258 SensorDevice& dev(SensorDevice::getInstance()); 259 if (args.size() == 2 && args[0] == String16("restrict")) { 260 // If already in restricted mode. Ignore. 261 if (mCurrentOperatingMode == RESTRICTED) { 262 return status_t(NO_ERROR); 263 } 264 // If in any mode other than normal, ignore. 265 if (mCurrentOperatingMode != NORMAL) { 266 return INVALID_OPERATION; 267 } 268 mCurrentOperatingMode = RESTRICTED; 269 dev.disableAllSensors(); 270 // Clear all pending flush connections for all active sensors. If one of the active 271 // connections has called flush() and the underlying sensor has been disabled before a 272 // flush complete event is returned, we need to remove the connection from this queue. 273 for (size_t i=0 ; i< mActiveSensors.size(); ++i) { 274 mActiveSensors.valueAt(i)->clearAllPendingFlushConnections(); 275 } 276 mWhiteListedPackage.setTo(String8(args[1])); 277 return status_t(NO_ERROR); 278 } else if (args.size() == 1 && args[0] == String16("enable")) { 279 // If currently in restricted mode, reset back to NORMAL mode else ignore. 280 if (mCurrentOperatingMode == RESTRICTED) { 281 mCurrentOperatingMode = NORMAL; 282 dev.enableAllSensors(); 283 } 284 if (mCurrentOperatingMode == DATA_INJECTION) { 285 resetToNormalModeLocked(); 286 } 287 mWhiteListedPackage.clear(); 288 return status_t(NO_ERROR); 289 } else if (args.size() == 2 && args[0] == String16("data_injection")) { 290 if (mCurrentOperatingMode == NORMAL) { 291 dev.disableAllSensors(); 292 status_t err = dev.setMode(DATA_INJECTION); 293 if (err == NO_ERROR) { 294 mCurrentOperatingMode = DATA_INJECTION; 295 } else { 296 // Re-enable sensors. 297 dev.enableAllSensors(); 298 } 299 mWhiteListedPackage.setTo(String8(args[1])); 300 return NO_ERROR; 301 } else if (mCurrentOperatingMode == DATA_INJECTION) { 302 // Already in DATA_INJECTION mode. Treat this as a no_op. 303 return NO_ERROR; 304 } else { 305 // Transition to data injection mode supported only from NORMAL mode. 306 return INVALID_OPERATION; 307 } 308 } else if (mSensorList.size() == 0) { 309 result.append("No Sensors on the device\n"); 310 } else { 311 // Default dump the sensor list and debugging information. 312 result.append("Sensor List:\n"); 313 for (size_t i=0 ; i<mSensorList.size() ; i++) { 314 const Sensor& s(mSensorList[i]); 315 result.appendFormat( 316 "%-15s| %-10s| version=%d |%-20s| 0x%08x | \"%s\" | type=%d |", 317 s.getName().string(), 318 s.getVendor().string(), 319 s.getVersion(), 320 s.getStringType().string(), 321 s.getHandle(), 322 s.getRequiredPermission().string(), 323 s.getType()); 324 325 const int reportingMode = s.getReportingMode(); 326 if (reportingMode == AREPORTING_MODE_CONTINUOUS) { 327 result.append(" continuous | "); 328 } else if (reportingMode == AREPORTING_MODE_ON_CHANGE) { 329 result.append(" on-change | "); 330 } else if (reportingMode == AREPORTING_MODE_ONE_SHOT) { 331 result.append(" one-shot | "); 332 } else { 333 result.append(" special-trigger | "); 334 } 335 336 if (s.getMaxDelay() > 0) { 337 result.appendFormat("minRate=%.2fHz | ", 1e6f / s.getMaxDelay()); 338 } else { 339 result.appendFormat("maxDelay=%dus |", s.getMaxDelay()); 340 } 341 342 if (s.getMinDelay() > 0) { 343 result.appendFormat("maxRate=%.2fHz | ", 1e6f / s.getMinDelay()); 344 } else { 345 result.appendFormat("minDelay=%dus |", s.getMinDelay()); 346 } 347 348 if (s.getFifoMaxEventCount() > 0) { 349 result.appendFormat("FifoMax=%d events | ", 350 s.getFifoMaxEventCount()); 351 } else { 352 result.append("no batching | "); 353 } 354 355 if (s.isWakeUpSensor()) { 356 result.appendFormat("wakeUp | "); 357 } else { 358 result.appendFormat("non-wakeUp | "); 359 } 360 361 int bufIndex = mLastEventSeen.indexOfKey(s.getHandle()); 362 if (bufIndex >= 0) { 363 const CircularBuffer* buf = mLastEventSeen.valueAt(bufIndex); 364 if (buf != NULL && s.getRequiredPermission().isEmpty()) { 365 buf->printBuffer(result); 366 } else { 367 result.append("last=<> \n"); 368 } 369 } 370 result.append("\n"); 371 } 372 SensorFusion::getInstance().dump(result); 373 SensorDevice::getInstance().dump(result); 374 375 result.append("Active sensors:\n"); 376 for (size_t i=0 ; i<mActiveSensors.size() ; i++) { 377 int handle = mActiveSensors.keyAt(i); 378 result.appendFormat("%s (handle=0x%08x, connections=%zu)\n", 379 getSensorName(handle).string(), 380 handle, 381 mActiveSensors.valueAt(i)->getNumConnections()); 382 } 383 384 result.appendFormat("Socket Buffer size = %d events\n", 385 mSocketBufferSize/sizeof(sensors_event_t)); 386 result.appendFormat("WakeLock Status: %s \n", mWakeLockAcquired ? "acquired" : 387 "not held"); 388 result.appendFormat("Mode :"); 389 switch(mCurrentOperatingMode) { 390 case NORMAL: 391 result.appendFormat(" NORMAL\n"); 392 break; 393 case RESTRICTED: 394 result.appendFormat(" RESTRICTED : %s\n", mWhiteListedPackage.string()); 395 break; 396 case DATA_INJECTION: 397 result.appendFormat(" DATA_INJECTION : %s\n", mWhiteListedPackage.string()); 398 } 399 result.appendFormat("%zd active connections\n", mActiveConnections.size()); 400 401 for (size_t i=0 ; i < mActiveConnections.size() ; i++) { 402 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 403 if (connection != 0) { 404 result.appendFormat("Connection Number: %zu \n", i); 405 connection->dump(result); 406 } 407 } 408 409 result.appendFormat("Previous Registrations:\n"); 410 // Log in the reverse chronological order. 411 int currentIndex = (mNextSensorRegIndex - 1 + SENSOR_REGISTRATIONS_BUF_SIZE) % 412 SENSOR_REGISTRATIONS_BUF_SIZE; 413 const int startIndex = currentIndex; 414 do { 415 const SensorRegistrationInfo& reg_info = mLastNSensorRegistrations[currentIndex]; 416 if (SensorRegistrationInfo::isSentinel(reg_info)) { 417 // Ignore sentinel, proceed to next item. 418 currentIndex = (currentIndex - 1 + SENSOR_REGISTRATIONS_BUF_SIZE) % 419 SENSOR_REGISTRATIONS_BUF_SIZE; 420 continue; 421 } 422 if (reg_info.mActivated) { 423 result.appendFormat("%02d:%02d:%02d activated package=%s handle=0x%08x " 424 "samplingRate=%dus maxReportLatency=%dus\n", 425 reg_info.mHour, reg_info.mMin, reg_info.mSec, 426 reg_info.mPackageName.string(), reg_info.mSensorHandle, 427 reg_info.mSamplingRateUs, reg_info.mMaxReportLatencyUs); 428 } else { 429 result.appendFormat("%02d:%02d:%02d de-activated package=%s handle=0x%08x\n", 430 reg_info.mHour, reg_info.mMin, reg_info.mSec, 431 reg_info.mPackageName.string(), reg_info.mSensorHandle); 432 } 433 currentIndex = (currentIndex - 1 + SENSOR_REGISTRATIONS_BUF_SIZE) % 434 SENSOR_REGISTRATIONS_BUF_SIZE; 435 } while(startIndex != currentIndex); 436 } 437 } 438 write(fd, result.string(), result.size()); 439 return NO_ERROR; 440} 441 442void SensorService::cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection, 443 sensors_event_t const* buffer, const int count) { 444 for (int i=0 ; i<count ; i++) { 445 int handle = buffer[i].sensor; 446 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 447 handle = buffer[i].meta_data.sensor; 448 } 449 if (connection->hasSensor(handle)) { 450 SensorInterface* sensor = mSensorMap.valueFor(handle); 451 // If this buffer has an event from a one_shot sensor and this connection is registered 452 // for this particular one_shot sensor, try cleaning up the connection. 453 if (sensor != NULL && 454 sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 455 sensor->autoDisable(connection.get(), handle); 456 cleanupWithoutDisableLocked(connection, handle); 457 } 458 459 } 460 } 461} 462 463bool SensorService::threadLoop() 464{ 465 ALOGD("nuSensorService thread starting..."); 466 467 // each virtual sensor could generate an event per "real" event, that's why we need 468 // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT. 469 // in practice, this is too aggressive, but guaranteed to be enough. 470 const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 471 const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size()); 472 473 SensorDevice& device(SensorDevice::getInstance()); 474 const size_t vcount = mVirtualSensorList.size(); 475 476 const int halVersion = device.getHalDeviceVersion(); 477 do { 478 ssize_t count = device.poll(mSensorEventBuffer, numEventMax); 479 if (count < 0) { 480 ALOGE("sensor poll failed (%s)", strerror(-count)); 481 break; 482 } 483 484 // Reset sensors_event_t.flags to zero for all events in the buffer. 485 for (int i = 0; i < count; i++) { 486 mSensorEventBuffer[i].flags = 0; 487 } 488 489 // Make a copy of the connection vector as some connections may be removed during the 490 // course of this loop (especially when one-shot sensor events are present in the 491 // sensor_event buffer). Promote all connections to StrongPointers before the lock is 492 // acquired. If the destructor of the sp gets called when the lock is acquired, it may 493 // result in a deadlock as ~SensorEventConnection() needs to acquire mLock again for 494 // cleanup. So copy all the strongPointers to a vector before the lock is acquired. 495 SortedVector< sp<SensorEventConnection> > activeConnections; 496 populateActiveConnections(&activeConnections); 497 Mutex::Autolock _l(mLock); 498 // Poll has returned. Hold a wakelock if one of the events is from a wake up sensor. The 499 // rest of this loop is under a critical section protected by mLock. Acquiring a wakeLock, 500 // sending events to clients (incrementing SensorEventConnection::mWakeLockRefCount) should 501 // not be interleaved with decrementing SensorEventConnection::mWakeLockRefCount and 502 // releasing the wakelock. 503 bool bufferHasWakeUpEvent = false; 504 for (int i = 0; i < count; i++) { 505 if (isWakeUpSensorEvent(mSensorEventBuffer[i])) { 506 bufferHasWakeUpEvent = true; 507 break; 508 } 509 } 510 511 if (bufferHasWakeUpEvent && !mWakeLockAcquired) { 512 setWakeLockAcquiredLocked(true); 513 } 514 recordLastValueLocked(mSensorEventBuffer, count); 515 516 // handle virtual sensors 517 if (count && vcount) { 518 sensors_event_t const * const event = mSensorEventBuffer; 519 const size_t activeVirtualSensorCount = mActiveVirtualSensors.size(); 520 if (activeVirtualSensorCount) { 521 size_t k = 0; 522 SensorFusion& fusion(SensorFusion::getInstance()); 523 if (fusion.isEnabled()) { 524 for (size_t i=0 ; i<size_t(count) ; i++) { 525 fusion.process(event[i]); 526 } 527 } 528 for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) { 529 for (size_t j=0 ; j<activeVirtualSensorCount ; j++) { 530 if (count + k >= minBufferSize) { 531 ALOGE("buffer too small to hold all events: " 532 "count=%zd, k=%zu, size=%zu", 533 count, k, minBufferSize); 534 break; 535 } 536 sensors_event_t out; 537 SensorInterface* si = mActiveVirtualSensors.valueAt(j); 538 if (si->process(&out, event[i])) { 539 mSensorEventBuffer[count + k] = out; 540 k++; 541 } 542 } 543 } 544 if (k) { 545 // record the last synthesized values 546 recordLastValueLocked(&mSensorEventBuffer[count], k); 547 count += k; 548 // sort the buffer by time-stamps 549 sortEventBuffer(mSensorEventBuffer, count); 550 } 551 } 552 } 553 554 // handle backward compatibility for RotationVector sensor 555 if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) { 556 for (int i = 0; i < count; i++) { 557 if (mSensorEventBuffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) { 558 // All the 4 components of the quaternion should be available 559 // No heading accuracy. Set it to -1 560 mSensorEventBuffer[i].data[4] = -1; 561 } 562 } 563 } 564 565 // Map flush_complete_events in the buffer to SensorEventConnections which called 566 // flush on the hardware sensor. mapFlushEventsToConnections[i] will be the 567 // SensorEventConnection mapped to the corresponding flush_complete_event in 568 // mSensorEventBuffer[i] if such a mapping exists (NULL otherwise). 569 for (int i = 0; i < count; ++i) { 570 mMapFlushEventsToConnections[i] = NULL; 571 if (mSensorEventBuffer[i].type == SENSOR_TYPE_META_DATA) { 572 const int sensor_handle = mSensorEventBuffer[i].meta_data.sensor; 573 SensorRecord* rec = mActiveSensors.valueFor(sensor_handle); 574 if (rec != NULL) { 575 mMapFlushEventsToConnections[i] = rec->getFirstPendingFlushConnection(); 576 rec->removeFirstPendingFlushConnection(); 577 } 578 } 579 } 580 581 // Send our events to clients. Check the state of wake lock for each client and release the 582 // lock if none of the clients need it. 583 bool needsWakeLock = false; 584 size_t numConnections = activeConnections.size(); 585 for (size_t i=0 ; i < numConnections; ++i) { 586 if (activeConnections[i] != 0) { 587 activeConnections[i]->sendEvents(mSensorEventBuffer, count, mSensorEventScratch, 588 mMapFlushEventsToConnections); 589 needsWakeLock |= activeConnections[i]->needsWakeLock(); 590 // If the connection has one-shot sensors, it may be cleaned up after first trigger. 591 // Early check for one-shot sensors. 592 if (activeConnections[i]->hasOneShotSensors()) { 593 cleanupAutoDisabledSensorLocked(activeConnections[i], mSensorEventBuffer, 594 count); 595 } 596 } 597 } 598 599 if (mWakeLockAcquired && !needsWakeLock) { 600 setWakeLockAcquiredLocked(false); 601 } 602 } while (!Thread::exitPending()); 603 604 ALOGW("Exiting SensorService::threadLoop => aborting..."); 605 abort(); 606 return false; 607} 608 609sp<Looper> SensorService::getLooper() const { 610 return mLooper; 611} 612 613void SensorService::resetAllWakeLockRefCounts() { 614 SortedVector< sp<SensorEventConnection> > activeConnections; 615 populateActiveConnections(&activeConnections); 616 { 617 Mutex::Autolock _l(mLock); 618 for (size_t i=0 ; i < activeConnections.size(); ++i) { 619 if (activeConnections[i] != 0) { 620 activeConnections[i]->resetWakeLockRefCount(); 621 } 622 } 623 setWakeLockAcquiredLocked(false); 624 } 625} 626 627void SensorService::setWakeLockAcquiredLocked(bool acquire) { 628 if (acquire) { 629 if (!mWakeLockAcquired) { 630 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 631 mWakeLockAcquired = true; 632 } 633 mLooper->wake(); 634 } else { 635 if (mWakeLockAcquired) { 636 release_wake_lock(WAKE_LOCK_NAME); 637 mWakeLockAcquired = false; 638 } 639 } 640} 641 642bool SensorService::isWakeLockAcquired() { 643 Mutex::Autolock _l(mLock); 644 return mWakeLockAcquired; 645} 646 647bool SensorService::SensorEventAckReceiver::threadLoop() { 648 ALOGD("new thread SensorEventAckReceiver"); 649 sp<Looper> looper = mService->getLooper(); 650 do { 651 bool wakeLockAcquired = mService->isWakeLockAcquired(); 652 int timeout = -1; 653 if (wakeLockAcquired) timeout = 5000; 654 int ret = looper->pollOnce(timeout); 655 if (ret == ALOOPER_POLL_TIMEOUT) { 656 mService->resetAllWakeLockRefCounts(); 657 } 658 } while(!Thread::exitPending()); 659 return false; 660} 661 662void SensorService::recordLastValueLocked( 663 const sensors_event_t* buffer, size_t count) { 664 for (size_t i = 0; i < count; i++) { 665 if (buffer[i].type != SENSOR_TYPE_META_DATA) { 666 CircularBuffer* &circular_buf = mLastEventSeen.editValueFor(buffer[i].sensor); 667 if (circular_buf == NULL) { 668 circular_buf = new CircularBuffer(buffer[i].type); 669 } 670 circular_buf->addEvent(buffer[i]); 671 } 672 } 673} 674 675void SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count) 676{ 677 struct compar { 678 static int cmp(void const* lhs, void const* rhs) { 679 sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs); 680 sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs); 681 return l->timestamp - r->timestamp; 682 } 683 }; 684 qsort(buffer, count, sizeof(sensors_event_t), compar::cmp); 685} 686 687String8 SensorService::getSensorName(int handle) const { 688 size_t count = mUserSensorList.size(); 689 for (size_t i=0 ; i<count ; i++) { 690 const Sensor& sensor(mUserSensorList[i]); 691 if (sensor.getHandle() == handle) { 692 return sensor.getName(); 693 } 694 } 695 String8 result("unknown"); 696 return result; 697} 698 699bool SensorService::isVirtualSensor(int handle) const { 700 SensorInterface* sensor = mSensorMap.valueFor(handle); 701 return sensor->isVirtual(); 702} 703 704bool SensorService::isWakeUpSensorEvent(const sensors_event_t& event) const { 705 int handle = event.sensor; 706 if (event.type == SENSOR_TYPE_META_DATA) { 707 handle = event.meta_data.sensor; 708 } 709 SensorInterface* sensor = mSensorMap.valueFor(handle); 710 return sensor != NULL && sensor->getSensor().isWakeUpSensor(); 711} 712 713SensorService::SensorRecord * SensorService::getSensorRecord(int handle) { 714 return mActiveSensors.valueFor(handle); 715} 716 717Vector<Sensor> SensorService::getSensorList(const String16& opPackageName) 718{ 719 char value[PROPERTY_VALUE_MAX]; 720 property_get("debug.sensors", value, "0"); 721 const Vector<Sensor>& initialSensorList = (atoi(value)) ? 722 mUserSensorListDebug : mUserSensorList; 723 Vector<Sensor> accessibleSensorList; 724 for (size_t i = 0; i < initialSensorList.size(); i++) { 725 Sensor sensor = initialSensorList[i]; 726 if (canAccessSensor(sensor, "getSensorList", opPackageName)) { 727 accessibleSensorList.add(sensor); 728 } else { 729 ALOGI("Skipped sensor %s because it requires permission %s and app op %d", 730 sensor.getName().string(), 731 sensor.getRequiredPermission().string(), 732 sensor.getRequiredAppOp()); 733 } 734 } 735 return accessibleSensorList; 736} 737 738sp<ISensorEventConnection> SensorService::createSensorEventConnection(const String8& packageName, 739 int requestedMode, const String16& opPackageName) { 740 // Only 2 modes supported for a SensorEventConnection ... NORMAL and DATA_INJECTION. 741 if (requestedMode != NORMAL && requestedMode != DATA_INJECTION) { 742 return NULL; 743 } 744 745 Mutex::Autolock _l(mLock); 746 // To create a client in DATA_INJECTION mode to inject data, SensorService should already be 747 // operating in DI mode. 748 if (requestedMode == DATA_INJECTION) { 749 if (mCurrentOperatingMode != DATA_INJECTION) return NULL; 750 if (!isWhiteListedPackage(packageName)) return NULL; 751 } 752 753 uid_t uid = IPCThreadState::self()->getCallingUid(); 754 sp<SensorEventConnection> result(new SensorEventConnection(this, uid, packageName, 755 requestedMode == DATA_INJECTION, opPackageName)); 756 if (requestedMode == DATA_INJECTION) { 757 if (mActiveConnections.indexOf(result) < 0) { 758 mActiveConnections.add(result); 759 } 760 // Add the associated file descriptor to the Looper for polling whenever there is data to 761 // be injected. 762 result->updateLooperRegistration(mLooper); 763 } 764 return result; 765} 766 767int SensorService::isDataInjectionEnabled() { 768 Mutex::Autolock _l(mLock); 769 return (mCurrentOperatingMode == DATA_INJECTION); 770} 771 772status_t SensorService::resetToNormalMode() { 773 Mutex::Autolock _l(mLock); 774 return resetToNormalModeLocked(); 775} 776 777status_t SensorService::resetToNormalModeLocked() { 778 SensorDevice& dev(SensorDevice::getInstance()); 779 dev.enableAllSensors(); 780 status_t err = dev.setMode(NORMAL); 781 mCurrentOperatingMode = NORMAL; 782 return err; 783} 784 785void SensorService::cleanupConnection(SensorEventConnection* c) 786{ 787 Mutex::Autolock _l(mLock); 788 const wp<SensorEventConnection> connection(c); 789 size_t size = mActiveSensors.size(); 790 ALOGD_IF(DEBUG_CONNECTIONS, "%zu active sensors", size); 791 for (size_t i=0 ; i<size ; ) { 792 int handle = mActiveSensors.keyAt(i); 793 if (c->hasSensor(handle)) { 794 ALOGD_IF(DEBUG_CONNECTIONS, "%zu: disabling handle=0x%08x", i, handle); 795 SensorInterface* sensor = mSensorMap.valueFor( handle ); 796 ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle); 797 if (sensor) { 798 sensor->activate(c, false); 799 } 800 c->removeSensor(handle); 801 } 802 SensorRecord* rec = mActiveSensors.valueAt(i); 803 ALOGE_IF(!rec, "mActiveSensors[%zu] is null (handle=0x%08x)!", i, handle); 804 ALOGD_IF(DEBUG_CONNECTIONS, 805 "removing connection %p for sensor[%zu].handle=0x%08x", 806 c, i, handle); 807 808 if (rec && rec->removeConnection(connection)) { 809 ALOGD_IF(DEBUG_CONNECTIONS, "... and it was the last connection"); 810 mActiveSensors.removeItemsAt(i, 1); 811 mActiveVirtualSensors.removeItem(handle); 812 delete rec; 813 size--; 814 } else { 815 i++; 816 } 817 } 818 c->updateLooperRegistration(mLooper); 819 mActiveConnections.remove(connection); 820 BatteryService::cleanup(c->getUid()); 821 if (c->needsWakeLock()) { 822 checkWakeLockStateLocked(); 823 } 824} 825 826Sensor SensorService::getSensorFromHandle(int handle) const { 827 return mSensorMap.valueFor(handle)->getSensor(); 828} 829 830status_t SensorService::enable(const sp<SensorEventConnection>& connection, 831 int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags, 832 const String16& opPackageName) 833{ 834 if (mInitCheck != NO_ERROR) 835 return mInitCheck; 836 837 SensorInterface* sensor = mSensorMap.valueFor(handle); 838 if (sensor == NULL) { 839 return BAD_VALUE; 840 } 841 842 if (!canAccessSensor(sensor->getSensor(), "Tried enabling", opPackageName)) { 843 return BAD_VALUE; 844 } 845 846 Mutex::Autolock _l(mLock); 847 if ((mCurrentOperatingMode == RESTRICTED || mCurrentOperatingMode == DATA_INJECTION) 848 && !isWhiteListedPackage(connection->getPackageName())) { 849 return INVALID_OPERATION; 850 } 851 852 SensorRecord* rec = mActiveSensors.valueFor(handle); 853 if (rec == 0) { 854 rec = new SensorRecord(connection); 855 mActiveSensors.add(handle, rec); 856 if (sensor->isVirtual()) { 857 mActiveVirtualSensors.add(handle, sensor); 858 } 859 } else { 860 if (rec->addConnection(connection)) { 861 // this sensor is already activated, but we are adding a connection that uses it. 862 // Immediately send down the last known value of the requested sensor if it's not a 863 // "continuous" sensor. 864 if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ON_CHANGE) { 865 // NOTE: The wake_up flag of this event may get set to 866 // WAKE_UP_SENSOR_EVENT_NEEDS_ACK if this is a wake_up event. 867 CircularBuffer *circular_buf = mLastEventSeen.valueFor(handle); 868 if (circular_buf) { 869 sensors_event_t event; 870 memset(&event, 0, sizeof(event)); 871 // It is unlikely that this buffer is empty as the sensor is already active. 872 // One possible corner case may be two applications activating an on-change 873 // sensor at the same time. 874 if(circular_buf->populateLastEvent(&event)) { 875 event.sensor = handle; 876 if (event.version == sizeof(sensors_event_t)) { 877 if (isWakeUpSensorEvent(event) && !mWakeLockAcquired) { 878 setWakeLockAcquiredLocked(true); 879 } 880 connection->sendEvents(&event, 1, NULL); 881 if (!connection->needsWakeLock() && mWakeLockAcquired) { 882 checkWakeLockStateLocked(); 883 } 884 } 885 } 886 } 887 } 888 } 889 } 890 891 if (connection->addSensor(handle)) { 892 BatteryService::enableSensor(connection->getUid(), handle); 893 // the sensor was added (which means it wasn't already there) 894 // so, see if this connection becomes active 895 if (mActiveConnections.indexOf(connection) < 0) { 896 mActiveConnections.add(connection); 897 } 898 } else { 899 ALOGW("sensor %08x already enabled in connection %p (ignoring)", 900 handle, connection.get()); 901 } 902 903 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 904 if (samplingPeriodNs < minDelayNs) { 905 samplingPeriodNs = minDelayNs; 906 } 907 908 ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d" 909 "rate=%" PRId64 " timeout== %" PRId64"", 910 handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs); 911 912 status_t err = sensor->batch(connection.get(), handle, 0, samplingPeriodNs, 913 maxBatchReportLatencyNs); 914 915 // Call flush() before calling activate() on the sensor. Wait for a first flush complete 916 // event before sending events on this connection. Ignore one-shot sensors which don't 917 // support flush(). Also if this sensor isn't already active, don't call flush(). 918 if (err == NO_ERROR && sensor->getSensor().getReportingMode() != AREPORTING_MODE_ONE_SHOT && 919 rec->getNumConnections() > 1) { 920 connection->setFirstFlushPending(handle, true); 921 status_t err_flush = sensor->flush(connection.get(), handle); 922 // Flush may return error if the underlying h/w sensor uses an older HAL. 923 if (err_flush == NO_ERROR) { 924 rec->addPendingFlushConnection(connection.get()); 925 } else { 926 connection->setFirstFlushPending(handle, false); 927 } 928 } 929 930 if (err == NO_ERROR) { 931 ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle); 932 err = sensor->activate(connection.get(), true); 933 } 934 935 if (err == NO_ERROR) { 936 connection->updateLooperRegistration(mLooper); 937 SensorRegistrationInfo ®_info = 938 mLastNSensorRegistrations.editItemAt(mNextSensorRegIndex); 939 reg_info.mSensorHandle = handle; 940 reg_info.mSamplingRateUs = samplingPeriodNs/1000; 941 reg_info.mMaxReportLatencyUs = maxBatchReportLatencyNs/1000; 942 reg_info.mActivated = true; 943 reg_info.mPackageName = connection->getPackageName(); 944 time_t rawtime = time(NULL); 945 struct tm * timeinfo = localtime(&rawtime); 946 reg_info.mHour = timeinfo->tm_hour; 947 reg_info.mMin = timeinfo->tm_min; 948 reg_info.mSec = timeinfo->tm_sec; 949 mNextSensorRegIndex = (mNextSensorRegIndex + 1) % SENSOR_REGISTRATIONS_BUF_SIZE; 950 } 951 952 if (err != NO_ERROR) { 953 // batch/activate has failed, reset our state. 954 cleanupWithoutDisableLocked(connection, handle); 955 } 956 return err; 957} 958 959status_t SensorService::disable(const sp<SensorEventConnection>& connection, 960 int handle) 961{ 962 if (mInitCheck != NO_ERROR) 963 return mInitCheck; 964 965 Mutex::Autolock _l(mLock); 966 status_t err = cleanupWithoutDisableLocked(connection, handle); 967 if (err == NO_ERROR) { 968 SensorInterface* sensor = mSensorMap.valueFor(handle); 969 err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE); 970 971 } 972 if (err == NO_ERROR) { 973 SensorRegistrationInfo ®_info = 974 mLastNSensorRegistrations.editItemAt(mNextSensorRegIndex); 975 reg_info.mActivated = false; 976 reg_info.mPackageName= connection->getPackageName(); 977 reg_info.mSensorHandle = handle; 978 time_t rawtime = time(NULL); 979 struct tm * timeinfo = localtime(&rawtime); 980 reg_info.mHour = timeinfo->tm_hour; 981 reg_info.mMin = timeinfo->tm_min; 982 reg_info.mSec = timeinfo->tm_sec; 983 mNextSensorRegIndex = (mNextSensorRegIndex + 1) % SENSOR_REGISTRATIONS_BUF_SIZE; 984 } 985 return err; 986} 987 988status_t SensorService::cleanupWithoutDisable( 989 const sp<SensorEventConnection>& connection, int handle) { 990 Mutex::Autolock _l(mLock); 991 return cleanupWithoutDisableLocked(connection, handle); 992} 993 994status_t SensorService::cleanupWithoutDisableLocked( 995 const sp<SensorEventConnection>& connection, int handle) { 996 SensorRecord* rec = mActiveSensors.valueFor(handle); 997 if (rec) { 998 // see if this connection becomes inactive 999 if (connection->removeSensor(handle)) { 1000 BatteryService::disableSensor(connection->getUid(), handle); 1001 } 1002 if (connection->hasAnySensor() == false) { 1003 connection->updateLooperRegistration(mLooper); 1004 mActiveConnections.remove(connection); 1005 } 1006 // see if this sensor becomes inactive 1007 if (rec->removeConnection(connection)) { 1008 mActiveSensors.removeItem(handle); 1009 mActiveVirtualSensors.removeItem(handle); 1010 delete rec; 1011 } 1012 return NO_ERROR; 1013 } 1014 return BAD_VALUE; 1015} 1016 1017status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection, 1018 int handle, nsecs_t ns, const String16& opPackageName) 1019{ 1020 if (mInitCheck != NO_ERROR) 1021 return mInitCheck; 1022 1023 SensorInterface* sensor = mSensorMap.valueFor(handle); 1024 if (!sensor) 1025 return BAD_VALUE; 1026 1027 if (!canAccessSensor(sensor->getSensor(), "Tried configuring", opPackageName)) { 1028 return BAD_VALUE; 1029 } 1030 1031 if (ns < 0) 1032 return BAD_VALUE; 1033 1034 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 1035 if (ns < minDelayNs) { 1036 ns = minDelayNs; 1037 } 1038 1039 return sensor->setDelay(connection.get(), handle, ns); 1040} 1041 1042status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection, 1043 const String16& opPackageName) { 1044 if (mInitCheck != NO_ERROR) return mInitCheck; 1045 SensorDevice& dev(SensorDevice::getInstance()); 1046 const int halVersion = dev.getHalDeviceVersion(); 1047 status_t err(NO_ERROR); 1048 Mutex::Autolock _l(mLock); 1049 // Loop through all sensors for this connection and call flush on each of them. 1050 for (size_t i = 0; i < connection->mSensorInfo.size(); ++i) { 1051 const int handle = connection->mSensorInfo.keyAt(i); 1052 SensorInterface* sensor = mSensorMap.valueFor(handle); 1053 if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 1054 ALOGE("flush called on a one-shot sensor"); 1055 err = INVALID_OPERATION; 1056 continue; 1057 } 1058 if (halVersion <= SENSORS_DEVICE_API_VERSION_1_0 || isVirtualSensor(handle)) { 1059 // For older devices just increment pending flush count which will send a trivial 1060 // flush complete event. 1061 connection->incrementPendingFlushCount(handle); 1062 } else { 1063 if (!canAccessSensor(sensor->getSensor(), "Tried flushing", opPackageName)) { 1064 err = INVALID_OPERATION; 1065 continue; 1066 } 1067 status_t err_flush = sensor->flush(connection.get(), handle); 1068 if (err_flush == NO_ERROR) { 1069 SensorRecord* rec = mActiveSensors.valueFor(handle); 1070 if (rec != NULL) rec->addPendingFlushConnection(connection); 1071 } 1072 err = (err_flush != NO_ERROR) ? err_flush : err; 1073 } 1074 } 1075 return err; 1076} 1077 1078bool SensorService::canAccessSensor(const Sensor& sensor, const char* operation, 1079 const String16& opPackageName) { 1080 const String8& requiredPermission = sensor.getRequiredPermission(); 1081 1082 if (requiredPermission.length() <= 0) { 1083 return true; 1084 } 1085 1086 bool hasPermission = false; 1087 1088 // Runtime permissions can't use the cache as they may change. 1089 if (sensor.isRequiredPermissionRuntime()) { 1090 hasPermission = checkPermission(String16(requiredPermission), 1091 IPCThreadState::self()->getCallingPid(), IPCThreadState::self()->getCallingUid()); 1092 } else { 1093 hasPermission = PermissionCache::checkCallingPermission(String16(requiredPermission)); 1094 } 1095 1096 if (!hasPermission) { 1097 ALOGE("%s a sensor (%s) without holding its required permission: %s", 1098 operation, sensor.getName().string(), sensor.getRequiredPermission().string()); 1099 return false; 1100 } 1101 1102 const int32_t opCode = sensor.getRequiredAppOp(); 1103 if (opCode >= 0) { 1104 AppOpsManager appOps; 1105 if (appOps.noteOp(opCode, IPCThreadState::self()->getCallingUid(), opPackageName) 1106 != AppOpsManager::MODE_ALLOWED) { 1107 ALOGE("%s a sensor (%s) without enabled required app op: %D", 1108 operation, sensor.getName().string(), opCode); 1109 return false; 1110 } 1111 } 1112 1113 return true; 1114} 1115 1116void SensorService::checkWakeLockState() { 1117 Mutex::Autolock _l(mLock); 1118 checkWakeLockStateLocked(); 1119} 1120 1121void SensorService::checkWakeLockStateLocked() { 1122 if (!mWakeLockAcquired) { 1123 return; 1124 } 1125 bool releaseLock = true; 1126 for (size_t i=0 ; i<mActiveConnections.size() ; i++) { 1127 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 1128 if (connection != 0) { 1129 if (connection->needsWakeLock()) { 1130 releaseLock = false; 1131 break; 1132 } 1133 } 1134 } 1135 if (releaseLock) { 1136 setWakeLockAcquiredLocked(false); 1137 } 1138} 1139 1140void SensorService::sendEventsFromCache(const sp<SensorEventConnection>& connection) { 1141 Mutex::Autolock _l(mLock); 1142 connection->writeToSocketFromCache(); 1143 if (connection->needsWakeLock()) { 1144 setWakeLockAcquiredLocked(true); 1145 } 1146} 1147 1148void SensorService::populateActiveConnections( 1149 SortedVector< sp<SensorEventConnection> >* activeConnections) { 1150 Mutex::Autolock _l(mLock); 1151 for (size_t i=0 ; i < mActiveConnections.size(); ++i) { 1152 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 1153 if (connection != 0) { 1154 activeConnections->add(connection); 1155 } 1156 } 1157} 1158 1159bool SensorService::isWhiteListedPackage(const String8& packageName) { 1160 return (packageName.contains(mWhiteListedPackage.string())); 1161} 1162 1163int SensorService::getNumEventsForSensorType(int sensor_event_type) { 1164 switch (sensor_event_type) { 1165 case SENSOR_TYPE_ROTATION_VECTOR: 1166 case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 1167 return 5; 1168 1169 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 1170 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 1171 return 6; 1172 1173 case SENSOR_TYPE_GAME_ROTATION_VECTOR: 1174 return 4; 1175 1176 case SENSOR_TYPE_SIGNIFICANT_MOTION: 1177 case SENSOR_TYPE_STEP_DETECTOR: 1178 case SENSOR_TYPE_STEP_COUNTER: 1179 return 1; 1180 1181 default: 1182 return 3; 1183 } 1184} 1185 1186// --------------------------------------------------------------------------- 1187SensorService::SensorRecord::SensorRecord( 1188 const sp<SensorEventConnection>& connection) 1189{ 1190 mConnections.add(connection); 1191} 1192 1193bool SensorService::SensorRecord::addConnection( 1194 const sp<SensorEventConnection>& connection) 1195{ 1196 if (mConnections.indexOf(connection) < 0) { 1197 mConnections.add(connection); 1198 return true; 1199 } 1200 return false; 1201} 1202 1203bool SensorService::SensorRecord::removeConnection( 1204 const wp<SensorEventConnection>& connection) 1205{ 1206 ssize_t index = mConnections.indexOf(connection); 1207 if (index >= 0) { 1208 mConnections.removeItemsAt(index, 1); 1209 } 1210 // Remove this connections from the queue of flush() calls made on this sensor. 1211 for (Vector< wp<SensorEventConnection> >::iterator it = 1212 mPendingFlushConnections.begin(); it != mPendingFlushConnections.end();) { 1213 1214 if (it->unsafe_get() == connection.unsafe_get()) { 1215 it = mPendingFlushConnections.erase(it); 1216 } else { 1217 ++it; 1218 } 1219 } 1220 return mConnections.size() ? false : true; 1221} 1222 1223void SensorService::SensorRecord::addPendingFlushConnection( 1224 const sp<SensorEventConnection>& connection) { 1225 mPendingFlushConnections.add(connection); 1226} 1227 1228void SensorService::SensorRecord::removeFirstPendingFlushConnection() { 1229 if (mPendingFlushConnections.size() > 0) { 1230 mPendingFlushConnections.removeAt(0); 1231 } 1232} 1233 1234SensorService::SensorEventConnection * 1235SensorService::SensorRecord::getFirstPendingFlushConnection() { 1236 if (mPendingFlushConnections.size() > 0) { 1237 return mPendingFlushConnections[0].unsafe_get(); 1238 } 1239 return NULL; 1240} 1241 1242void SensorService::SensorRecord::clearAllPendingFlushConnections() { 1243 mPendingFlushConnections.clear(); 1244} 1245 1246 1247// --------------------------------------------------------------------------- 1248SensorService::TrimmedSensorEvent::TrimmedSensorEvent(int sensorType) { 1249 mTimestamp = -1; 1250 const int numData = SensorService::getNumEventsForSensorType(sensorType); 1251 if (sensorType == SENSOR_TYPE_STEP_COUNTER) { 1252 mStepCounter = 0; 1253 } else { 1254 mData = new float[numData]; 1255 for (int i = 0; i < numData; ++i) { 1256 mData[i] = -1.0; 1257 } 1258 } 1259 mHour = mMin = mSec = INT32_MIN; 1260} 1261 1262bool SensorService::TrimmedSensorEvent::isSentinel(const TrimmedSensorEvent& event) { 1263 return (event.mHour == INT32_MIN && event.mMin == INT32_MIN && event.mSec == INT32_MIN); 1264} 1265// -------------------------------------------------------------------------- 1266SensorService::CircularBuffer::CircularBuffer(int sensor_event_type) { 1267 mNextInd = 0; 1268 mBufSize = CIRCULAR_BUF_SIZE; 1269 if (sensor_event_type == SENSOR_TYPE_STEP_COUNTER || 1270 sensor_event_type == SENSOR_TYPE_SIGNIFICANT_MOTION || 1271 sensor_event_type == SENSOR_TYPE_ACCELEROMETER) { 1272 mBufSize = CIRCULAR_BUF_SIZE * 5; 1273 } 1274 mTrimmedSensorEventArr = new TrimmedSensorEvent *[mBufSize]; 1275 mSensorType = sensor_event_type; 1276 for (int i = 0; i < mBufSize; ++i) { 1277 mTrimmedSensorEventArr[i] = new TrimmedSensorEvent(mSensorType); 1278 } 1279} 1280 1281void SensorService::CircularBuffer::addEvent(const sensors_event_t& sensor_event) { 1282 TrimmedSensorEvent *curr_event = mTrimmedSensorEventArr[mNextInd]; 1283 curr_event->mTimestamp = sensor_event.timestamp; 1284 if (mSensorType == SENSOR_TYPE_STEP_COUNTER) { 1285 curr_event->mStepCounter = sensor_event.u64.step_counter; 1286 } else { 1287 memcpy(curr_event->mData, sensor_event.data, 1288 sizeof(float) * SensorService::getNumEventsForSensorType(mSensorType)); 1289 } 1290 time_t rawtime = time(NULL); 1291 struct tm * timeinfo = localtime(&rawtime); 1292 curr_event->mHour = timeinfo->tm_hour; 1293 curr_event->mMin = timeinfo->tm_min; 1294 curr_event->mSec = timeinfo->tm_sec; 1295 mNextInd = (mNextInd + 1) % mBufSize; 1296} 1297 1298void SensorService::CircularBuffer::printBuffer(String8& result) const { 1299 const int numData = SensorService::getNumEventsForSensorType(mSensorType); 1300 int i = mNextInd, eventNum = 1; 1301 result.appendFormat("last %d events = < ", mBufSize); 1302 do { 1303 if (TrimmedSensorEvent::isSentinel(*mTrimmedSensorEventArr[i])) { 1304 // Sentinel, ignore. 1305 i = (i + 1) % mBufSize; 1306 continue; 1307 } 1308 result.appendFormat("%d) ", eventNum++); 1309 if (mSensorType == SENSOR_TYPE_STEP_COUNTER) { 1310 result.appendFormat("%llu,", mTrimmedSensorEventArr[i]->mStepCounter); 1311 } else { 1312 for (int j = 0; j < numData; ++j) { 1313 result.appendFormat("%5.1f,", mTrimmedSensorEventArr[i]->mData[j]); 1314 } 1315 } 1316 result.appendFormat("%lld %02d:%02d:%02d ", mTrimmedSensorEventArr[i]->mTimestamp, 1317 mTrimmedSensorEventArr[i]->mHour, mTrimmedSensorEventArr[i]->mMin, 1318 mTrimmedSensorEventArr[i]->mSec); 1319 i = (i + 1) % mBufSize; 1320 } while (i != mNextInd); 1321 result.appendFormat(">\n"); 1322} 1323 1324bool SensorService::CircularBuffer::populateLastEvent(sensors_event_t *event) { 1325 int lastEventInd = (mNextInd - 1 + mBufSize) % mBufSize; 1326 // Check if the buffer is empty. 1327 if (TrimmedSensorEvent::isSentinel(*mTrimmedSensorEventArr[lastEventInd])) { 1328 return false; 1329 } 1330 event->version = sizeof(sensors_event_t); 1331 event->type = mSensorType; 1332 event->timestamp = mTrimmedSensorEventArr[lastEventInd]->mTimestamp; 1333 if (mSensorType == SENSOR_TYPE_STEP_COUNTER) { 1334 event->u64.step_counter = mTrimmedSensorEventArr[lastEventInd]->mStepCounter; 1335 } else { 1336 memcpy(event->data, mTrimmedSensorEventArr[lastEventInd]->mData, 1337 sizeof(float) * SensorService::getNumEventsForSensorType(mSensorType)); 1338 } 1339 return true; 1340} 1341 1342SensorService::CircularBuffer::~CircularBuffer() { 1343 for (int i = 0; i < mBufSize; ++i) { 1344 delete mTrimmedSensorEventArr[i]; 1345 } 1346 delete [] mTrimmedSensorEventArr; 1347} 1348 1349// --------------------------------------------------------------------------- 1350 1351SensorService::SensorEventConnection::SensorEventConnection( 1352 const sp<SensorService>& service, uid_t uid, String8 packageName, bool isDataInjectionMode, 1353 const String16& opPackageName) 1354 : mService(service), mUid(uid), mWakeLockRefCount(0), mHasLooperCallbacks(false), 1355 mDead(false), mDataInjectionMode(isDataInjectionMode), mEventCache(NULL), 1356 mCacheSize(0), mMaxCacheSize(0), mPackageName(packageName), mOpPackageName(opPackageName) { 1357 mChannel = new BitTube(mService->mSocketBufferSize); 1358#if DEBUG_CONNECTIONS 1359 mEventsReceived = mEventsSentFromCache = mEventsSent = 0; 1360 mTotalAcksNeeded = mTotalAcksReceived = 0; 1361#endif 1362} 1363 1364SensorService::SensorEventConnection::~SensorEventConnection() { 1365 ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this); 1366 mService->cleanupConnection(this); 1367 if (mEventCache != NULL) { 1368 delete mEventCache; 1369 } 1370} 1371 1372void SensorService::SensorEventConnection::onFirstRef() { 1373 LooperCallback::onFirstRef(); 1374} 1375 1376bool SensorService::SensorEventConnection::needsWakeLock() { 1377 Mutex::Autolock _l(mConnectionLock); 1378 return !mDead && mWakeLockRefCount > 0; 1379} 1380 1381void SensorService::SensorEventConnection::resetWakeLockRefCount() { 1382 Mutex::Autolock _l(mConnectionLock); 1383 mWakeLockRefCount = 0; 1384} 1385 1386void SensorService::SensorEventConnection::dump(String8& result) { 1387 Mutex::Autolock _l(mConnectionLock); 1388 result.appendFormat("\tOperating Mode: %s\n",mDataInjectionMode ? "DATA_INJECTION" : "NORMAL"); 1389 result.appendFormat("\t %s | WakeLockRefCount %d | uid %d | cache size %d | " 1390 "max cache size %d\n", mPackageName.string(), mWakeLockRefCount, mUid, mCacheSize, 1391 mMaxCacheSize); 1392 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1393 const FlushInfo& flushInfo = mSensorInfo.valueAt(i); 1394 result.appendFormat("\t %s 0x%08x | status: %s | pending flush events %d \n", 1395 mService->getSensorName(mSensorInfo.keyAt(i)).string(), 1396 mSensorInfo.keyAt(i), 1397 flushInfo.mFirstFlushPending ? "First flush pending" : 1398 "active", 1399 flushInfo.mPendingFlushEventsToSend); 1400 } 1401#if DEBUG_CONNECTIONS 1402 result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d |" 1403 " total_acks_needed %d | total_acks_recvd %d\n", 1404 mEventsReceived, 1405 mEventsSent, 1406 mEventsSentFromCache, 1407 mEventsReceived - (mEventsSentFromCache + mEventsSent + mCacheSize), 1408 mTotalAcksNeeded, 1409 mTotalAcksReceived); 1410#endif 1411} 1412 1413bool SensorService::SensorEventConnection::addSensor(int32_t handle) { 1414 Mutex::Autolock _l(mConnectionLock); 1415 if (!canAccessSensor(mService->getSensorFromHandle(handle), 1416 "Tried adding", mOpPackageName)) { 1417 return false; 1418 } 1419 if (mSensorInfo.indexOfKey(handle) < 0) { 1420 mSensorInfo.add(handle, FlushInfo()); 1421 return true; 1422 } 1423 return false; 1424} 1425 1426bool SensorService::SensorEventConnection::removeSensor(int32_t handle) { 1427 Mutex::Autolock _l(mConnectionLock); 1428 if (mSensorInfo.removeItem(handle) >= 0) { 1429 return true; 1430 } 1431 return false; 1432} 1433 1434bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const { 1435 Mutex::Autolock _l(mConnectionLock); 1436 return mSensorInfo.indexOfKey(handle) >= 0; 1437} 1438 1439bool SensorService::SensorEventConnection::hasAnySensor() const { 1440 Mutex::Autolock _l(mConnectionLock); 1441 return mSensorInfo.size() ? true : false; 1442} 1443 1444bool SensorService::SensorEventConnection::hasOneShotSensors() const { 1445 Mutex::Autolock _l(mConnectionLock); 1446 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1447 const int handle = mSensorInfo.keyAt(i); 1448 if (mService->getSensorFromHandle(handle).getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 1449 return true; 1450 } 1451 } 1452 return false; 1453} 1454 1455String8 SensorService::SensorEventConnection::getPackageName() const { 1456 return mPackageName; 1457} 1458 1459void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle, 1460 bool value) { 1461 Mutex::Autolock _l(mConnectionLock); 1462 ssize_t index = mSensorInfo.indexOfKey(handle); 1463 if (index >= 0) { 1464 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1465 flushInfo.mFirstFlushPending = value; 1466 } 1467} 1468 1469void SensorService::SensorEventConnection::updateLooperRegistration(const sp<Looper>& looper) { 1470 Mutex::Autolock _l(mConnectionLock); 1471 updateLooperRegistrationLocked(looper); 1472} 1473 1474void SensorService::SensorEventConnection::updateLooperRegistrationLocked( 1475 const sp<Looper>& looper) { 1476 bool isConnectionActive = (mSensorInfo.size() > 0 && !mDataInjectionMode) || 1477 mDataInjectionMode; 1478 // If all sensors are unregistered OR Looper has encountered an error, we 1479 // can remove the Fd from the Looper if it has been previously added. 1480 if (!isConnectionActive || mDead) { 1481 if (mHasLooperCallbacks) { 1482 ALOGD_IF(DEBUG_CONNECTIONS, "%p removeFd fd=%d", this, mChannel->getSendFd()); 1483 looper->removeFd(mChannel->getSendFd()); 1484 mHasLooperCallbacks = false; 1485 } 1486 return; 1487 } 1488 1489 int looper_flags = 0; 1490 if (mCacheSize > 0) looper_flags |= ALOOPER_EVENT_OUTPUT; 1491 if (mDataInjectionMode) looper_flags |= ALOOPER_EVENT_INPUT; 1492 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1493 const int handle = mSensorInfo.keyAt(i); 1494 if (mService->getSensorFromHandle(handle).isWakeUpSensor()) { 1495 looper_flags |= ALOOPER_EVENT_INPUT; 1496 break; 1497 } 1498 } 1499 // If flags is still set to zero, we don't need to add this fd to the Looper, if 1500 // the fd has already been added, remove it. This is likely to happen when ALL the 1501 // events stored in the cache have been sent to the corresponding app. 1502 if (looper_flags == 0) { 1503 if (mHasLooperCallbacks) { 1504 ALOGD_IF(DEBUG_CONNECTIONS, "removeFd fd=%d", mChannel->getSendFd()); 1505 looper->removeFd(mChannel->getSendFd()); 1506 mHasLooperCallbacks = false; 1507 } 1508 return; 1509 } 1510 // Add the file descriptor to the Looper for receiving acknowledegments if the app has 1511 // registered for wake-up sensors OR for sending events in the cache. 1512 int ret = looper->addFd(mChannel->getSendFd(), 0, looper_flags, this, NULL); 1513 if (ret == 1) { 1514 ALOGD_IF(DEBUG_CONNECTIONS, "%p addFd fd=%d", this, mChannel->getSendFd()); 1515 mHasLooperCallbacks = true; 1516 } else { 1517 ALOGE("Looper::addFd failed ret=%d fd=%d", ret, mChannel->getSendFd()); 1518 } 1519} 1520 1521void SensorService::SensorEventConnection::incrementPendingFlushCount(int32_t handle) { 1522 Mutex::Autolock _l(mConnectionLock); 1523 ssize_t index = mSensorInfo.indexOfKey(handle); 1524 if (index >= 0) { 1525 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1526 flushInfo.mPendingFlushEventsToSend++; 1527 } 1528} 1529 1530status_t SensorService::SensorEventConnection::sendEvents( 1531 sensors_event_t const* buffer, size_t numEvents, 1532 sensors_event_t* scratch, 1533 SensorEventConnection const * const * mapFlushEventsToConnections) { 1534 // filter out events not for this connection 1535 int count = 0; 1536 Mutex::Autolock _l(mConnectionLock); 1537 if (scratch) { 1538 size_t i=0; 1539 while (i<numEvents) { 1540 int32_t sensor_handle = buffer[i].sensor; 1541 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1542 ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ", 1543 buffer[i].meta_data.sensor); 1544 // Setting sensor_handle to the correct sensor to ensure the sensor events per 1545 // connection are filtered correctly. buffer[i].sensor is zero for meta_data 1546 // events. 1547 sensor_handle = buffer[i].meta_data.sensor; 1548 } 1549 ssize_t index = mSensorInfo.indexOfKey(sensor_handle); 1550 // Check if this connection has registered for this sensor. If not continue to the 1551 // next sensor_event. 1552 if (index < 0) { 1553 ++i; 1554 continue; 1555 } 1556 1557 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1558 // Check if there is a pending flush_complete event for this sensor on this connection. 1559 if (buffer[i].type == SENSOR_TYPE_META_DATA && flushInfo.mFirstFlushPending == true && 1560 this == mapFlushEventsToConnections[i]) { 1561 flushInfo.mFirstFlushPending = false; 1562 ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ", 1563 buffer[i].meta_data.sensor); 1564 ++i; 1565 continue; 1566 } 1567 1568 // If there is a pending flush complete event for this sensor on this connection, 1569 // ignore the event and proceed to the next. 1570 if (flushInfo.mFirstFlushPending) { 1571 ++i; 1572 continue; 1573 } 1574 1575 do { 1576 // Keep copying events into the scratch buffer as long as they are regular 1577 // sensor_events are from the same sensor_handle OR they are flush_complete_events 1578 // from the same sensor_handle AND the current connection is mapped to the 1579 // corresponding flush_complete_event. 1580 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1581 if (this == mapFlushEventsToConnections[i]) { 1582 scratch[count++] = buffer[i]; 1583 } 1584 ++i; 1585 } else { 1586 // Regular sensor event, just copy it to the scratch buffer. 1587 scratch[count++] = buffer[i++]; 1588 } 1589 } while ((i<numEvents) && ((buffer[i].sensor == sensor_handle && 1590 buffer[i].type != SENSOR_TYPE_META_DATA) || 1591 (buffer[i].type == SENSOR_TYPE_META_DATA && 1592 buffer[i].meta_data.sensor == sensor_handle))); 1593 } 1594 } else { 1595 scratch = const_cast<sensors_event_t *>(buffer); 1596 count = numEvents; 1597 } 1598 1599 sendPendingFlushEventsLocked(); 1600 // Early return if there are no events for this connection. 1601 if (count == 0) { 1602 return status_t(NO_ERROR); 1603 } 1604 1605#if DEBUG_CONNECTIONS 1606 mEventsReceived += count; 1607#endif 1608 if (mCacheSize != 0) { 1609 // There are some events in the cache which need to be sent first. Copy this buffer to 1610 // the end of cache. 1611 if (mCacheSize + count <= mMaxCacheSize) { 1612 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1613 mCacheSize += count; 1614 } else { 1615 // Check if any new sensors have registered on this connection which may have increased 1616 // the max cache size that is desired. 1617 if (mCacheSize + count < computeMaxCacheSizeLocked()) { 1618 reAllocateCacheLocked(scratch, count); 1619 return status_t(NO_ERROR); 1620 } 1621 // Some events need to be dropped. 1622 int remaningCacheSize = mMaxCacheSize - mCacheSize; 1623 if (remaningCacheSize != 0) { 1624 memcpy(&mEventCache[mCacheSize], scratch, 1625 remaningCacheSize * sizeof(sensors_event_t)); 1626 } 1627 int numEventsDropped = count - remaningCacheSize; 1628 countFlushCompleteEventsLocked(mEventCache, numEventsDropped); 1629 // Drop the first "numEventsDropped" in the cache. 1630 memmove(mEventCache, &mEventCache[numEventsDropped], 1631 (mCacheSize - numEventsDropped) * sizeof(sensors_event_t)); 1632 1633 // Copy the remainingEvents in scratch buffer to the end of cache. 1634 memcpy(&mEventCache[mCacheSize - numEventsDropped], scratch + remaningCacheSize, 1635 numEventsDropped * sizeof(sensors_event_t)); 1636 } 1637 return status_t(NO_ERROR); 1638 } 1639 1640 int index_wake_up_event = findWakeUpSensorEventLocked(scratch, count); 1641 if (index_wake_up_event >= 0) { 1642 scratch[index_wake_up_event].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1643 ++mWakeLockRefCount; 1644#if DEBUG_CONNECTIONS 1645 ++mTotalAcksNeeded; 1646#endif 1647 } 1648 1649 // NOTE: ASensorEvent and sensors_event_t are the same type. 1650 ssize_t size = SensorEventQueue::write(mChannel, 1651 reinterpret_cast<ASensorEvent const*>(scratch), count); 1652 if (size < 0) { 1653 // Write error, copy events to local cache. 1654 if (index_wake_up_event >= 0) { 1655 // If there was a wake_up sensor_event, reset the flag. 1656 scratch[index_wake_up_event].flags &= ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1657 if (mWakeLockRefCount > 0) { 1658 --mWakeLockRefCount; 1659 } 1660#if DEBUG_CONNECTIONS 1661 --mTotalAcksNeeded; 1662#endif 1663 } 1664 if (mEventCache == NULL) { 1665 mMaxCacheSize = computeMaxCacheSizeLocked(); 1666 mEventCache = new sensors_event_t[mMaxCacheSize]; 1667 mCacheSize = 0; 1668 } 1669 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1670 mCacheSize += count; 1671 1672 // Add this file descriptor to the looper to get a callback when this fd is available for 1673 // writing. 1674 updateLooperRegistrationLocked(mService->getLooper()); 1675 return size; 1676 } 1677 1678#if DEBUG_CONNECTIONS 1679 if (size > 0) { 1680 mEventsSent += count; 1681 } 1682#endif 1683 1684 return size < 0 ? status_t(size) : status_t(NO_ERROR); 1685} 1686 1687void SensorService::SensorEventConnection::reAllocateCacheLocked(sensors_event_t const* scratch, 1688 int count) { 1689 sensors_event_t *eventCache_new; 1690 const int new_cache_size = computeMaxCacheSizeLocked(); 1691 // Allocate new cache, copy over events from the old cache & scratch, free up memory. 1692 eventCache_new = new sensors_event_t[new_cache_size]; 1693 memcpy(eventCache_new, mEventCache, mCacheSize * sizeof(sensors_event_t)); 1694 memcpy(&eventCache_new[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1695 1696 ALOGD_IF(DEBUG_CONNECTIONS, "reAllocateCacheLocked maxCacheSize=%d %d", mMaxCacheSize, 1697 new_cache_size); 1698 1699 delete mEventCache; 1700 mEventCache = eventCache_new; 1701 mCacheSize += count; 1702 mMaxCacheSize = new_cache_size; 1703} 1704 1705void SensorService::SensorEventConnection::sendPendingFlushEventsLocked() { 1706 ASensorEvent flushCompleteEvent; 1707 memset(&flushCompleteEvent, 0, sizeof(flushCompleteEvent)); 1708 flushCompleteEvent.type = SENSOR_TYPE_META_DATA; 1709 // Loop through all the sensors for this connection and check if there are any pending 1710 // flush complete events to be sent. 1711 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1712 FlushInfo& flushInfo = mSensorInfo.editValueAt(i); 1713 while (flushInfo.mPendingFlushEventsToSend > 0) { 1714 const int sensor_handle = mSensorInfo.keyAt(i); 1715 flushCompleteEvent.meta_data.sensor = sensor_handle; 1716 bool wakeUpSensor = mService->getSensorFromHandle(sensor_handle).isWakeUpSensor(); 1717 if (wakeUpSensor) { 1718 ++mWakeLockRefCount; 1719 flushCompleteEvent.flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1720 } 1721 ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1); 1722 if (size < 0) { 1723 if (wakeUpSensor) --mWakeLockRefCount; 1724 return; 1725 } 1726 ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ", 1727 flushCompleteEvent.meta_data.sensor); 1728 flushInfo.mPendingFlushEventsToSend--; 1729 } 1730 } 1731} 1732 1733void SensorService::SensorEventConnection::writeToSocketFromCache() { 1734 // At a time write at most half the size of the receiver buffer in SensorEventQueue OR 1735 // half the size of the socket buffer allocated in BitTube whichever is smaller. 1736 const int maxWriteSize = helpers::min(SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT/2, 1737 int(mService->mSocketBufferSize/(sizeof(sensors_event_t)*2))); 1738 Mutex::Autolock _l(mConnectionLock); 1739 // Send pending flush complete events (if any) 1740 sendPendingFlushEventsLocked(); 1741 for (int numEventsSent = 0; numEventsSent < mCacheSize;) { 1742 const int numEventsToWrite = helpers::min(mCacheSize - numEventsSent, maxWriteSize); 1743 int index_wake_up_event = 1744 findWakeUpSensorEventLocked(mEventCache + numEventsSent, numEventsToWrite); 1745 if (index_wake_up_event >= 0) { 1746 mEventCache[index_wake_up_event + numEventsSent].flags |= 1747 WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1748 ++mWakeLockRefCount; 1749#if DEBUG_CONNECTIONS 1750 ++mTotalAcksNeeded; 1751#endif 1752 } 1753 1754 ssize_t size = SensorEventQueue::write(mChannel, 1755 reinterpret_cast<ASensorEvent const*>(mEventCache + numEventsSent), 1756 numEventsToWrite); 1757 if (size < 0) { 1758 if (index_wake_up_event >= 0) { 1759 // If there was a wake_up sensor_event, reset the flag. 1760 mEventCache[index_wake_up_event + numEventsSent].flags &= 1761 ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1762 if (mWakeLockRefCount > 0) { 1763 --mWakeLockRefCount; 1764 } 1765#if DEBUG_CONNECTIONS 1766 --mTotalAcksNeeded; 1767#endif 1768 } 1769 memmove(mEventCache, &mEventCache[numEventsSent], 1770 (mCacheSize - numEventsSent) * sizeof(sensors_event_t)); 1771 ALOGD_IF(DEBUG_CONNECTIONS, "wrote %d events from cache size==%d ", 1772 numEventsSent, mCacheSize); 1773 mCacheSize -= numEventsSent; 1774 return; 1775 } 1776 numEventsSent += numEventsToWrite; 1777#if DEBUG_CONNECTIONS 1778 mEventsSentFromCache += numEventsToWrite; 1779#endif 1780 } 1781 ALOGD_IF(DEBUG_CONNECTIONS, "wrote all events from cache size=%d ", mCacheSize); 1782 // All events from the cache have been sent. Reset cache size to zero. 1783 mCacheSize = 0; 1784 // There are no more events in the cache. We don't need to poll for write on the fd. 1785 // Update Looper registration. 1786 updateLooperRegistrationLocked(mService->getLooper()); 1787} 1788 1789void SensorService::SensorEventConnection::countFlushCompleteEventsLocked( 1790 sensors_event_t const* scratch, const int numEventsDropped) { 1791 ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped); 1792 // Count flushComplete events in the events that are about to the dropped. These will be sent 1793 // separately before the next batch of events. 1794 for (int j = 0; j < numEventsDropped; ++j) { 1795 if (scratch[j].type == SENSOR_TYPE_META_DATA) { 1796 FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor); 1797 flushInfo.mPendingFlushEventsToSend++; 1798 ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d", 1799 flushInfo.mPendingFlushEventsToSend); 1800 } 1801 } 1802 return; 1803} 1804 1805int SensorService::SensorEventConnection::findWakeUpSensorEventLocked( 1806 sensors_event_t const* scratch, const int count) { 1807 for (int i = 0; i < count; ++i) { 1808 if (mService->isWakeUpSensorEvent(scratch[i])) { 1809 return i; 1810 } 1811 } 1812 return -1; 1813} 1814 1815sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const 1816{ 1817 return mChannel; 1818} 1819 1820status_t SensorService::SensorEventConnection::enableDisable( 1821 int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, 1822 int reservedFlags) 1823{ 1824 status_t err; 1825 if (enabled) { 1826 err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs, 1827 reservedFlags, mOpPackageName); 1828 1829 } else { 1830 err = mService->disable(this, handle); 1831 } 1832 return err; 1833} 1834 1835status_t SensorService::SensorEventConnection::setEventRate( 1836 int handle, nsecs_t samplingPeriodNs) 1837{ 1838 return mService->setEventRate(this, handle, samplingPeriodNs, mOpPackageName); 1839} 1840 1841status_t SensorService::SensorEventConnection::flush() { 1842 return mService->flushSensor(this, mOpPackageName); 1843} 1844 1845int SensorService::SensorEventConnection::handleEvent(int fd, int events, void* /*data*/) { 1846 if (events & ALOOPER_EVENT_HANGUP || events & ALOOPER_EVENT_ERROR) { 1847 { 1848 // If the Looper encounters some error, set the flag mDead, reset mWakeLockRefCount, 1849 // and remove the fd from Looper. Call checkWakeLockState to know if SensorService 1850 // can release the wake-lock. 1851 ALOGD_IF(DEBUG_CONNECTIONS, "%p Looper error %d", this, fd); 1852 Mutex::Autolock _l(mConnectionLock); 1853 mDead = true; 1854 mWakeLockRefCount = 0; 1855 updateLooperRegistrationLocked(mService->getLooper()); 1856 } 1857 mService->checkWakeLockState(); 1858 if (mDataInjectionMode) { 1859 // If the Looper has encountered some error in data injection mode, reset SensorService 1860 // back to normal mode. 1861 mService->resetToNormalMode(); 1862 mDataInjectionMode = false; 1863 } 1864 return 1; 1865 } 1866 1867 if (events & ALOOPER_EVENT_INPUT) { 1868 unsigned char buf[sizeof(sensors_event_t)]; 1869 ssize_t numBytesRead = ::recv(fd, buf, sizeof(buf), MSG_DONTWAIT); 1870 { 1871 Mutex::Autolock _l(mConnectionLock); 1872 if (numBytesRead == sizeof(sensors_event_t)) { 1873 if (!mDataInjectionMode) { 1874 ALOGE("Data injected in normal mode, dropping event" 1875 "package=%s uid=%d", mPackageName.string(), mUid); 1876 // Unregister call backs. 1877 return 0; 1878 } 1879 SensorDevice& dev(SensorDevice::getInstance()); 1880 sensors_event_t sensor_event; 1881 memset(&sensor_event, 0, sizeof(sensor_event)); 1882 memcpy(&sensor_event, buf, sizeof(sensors_event_t)); 1883 Sensor sensor = mService->getSensorFromHandle(sensor_event.sensor); 1884 sensor_event.type = sensor.getType(); 1885 dev.injectSensorData(&sensor_event); 1886#if DEBUG_CONNECTIONS 1887 ++mEventsReceived; 1888#endif 1889 } else if (numBytesRead == sizeof(uint32_t)) { 1890 uint32_t numAcks = 0; 1891 memcpy(&numAcks, buf, numBytesRead); 1892 // Sanity check to ensure there are no read errors in recv, numAcks is always 1893 // within the range and not zero. If any of the above don't hold reset 1894 // mWakeLockRefCount to zero. 1895 if (numAcks > 0 && numAcks < mWakeLockRefCount) { 1896 mWakeLockRefCount -= numAcks; 1897 } else { 1898 mWakeLockRefCount = 0; 1899 } 1900#if DEBUG_CONNECTIONS 1901 mTotalAcksReceived += numAcks; 1902#endif 1903 } else { 1904 // Read error, reset wakelock refcount. 1905 mWakeLockRefCount = 0; 1906 } 1907 } 1908 // Check if wakelock can be released by sensorservice. mConnectionLock needs to be released 1909 // here as checkWakeLockState() will need it. 1910 if (mWakeLockRefCount == 0) { 1911 mService->checkWakeLockState(); 1912 } 1913 // continue getting callbacks. 1914 return 1; 1915 } 1916 1917 if (events & ALOOPER_EVENT_OUTPUT) { 1918 // send sensor data that is stored in mEventCache for this connection. 1919 mService->sendEventsFromCache(this); 1920 } 1921 return 1; 1922} 1923 1924int SensorService::SensorEventConnection::computeMaxCacheSizeLocked() const { 1925 size_t fifoWakeUpSensors = 0; 1926 size_t fifoNonWakeUpSensors = 0; 1927 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1928 const Sensor& sensor = mService->getSensorFromHandle(mSensorInfo.keyAt(i)); 1929 if (sensor.getFifoReservedEventCount() == sensor.getFifoMaxEventCount()) { 1930 // Each sensor has a reserved fifo. Sum up the fifo sizes for all wake up sensors and 1931 // non wake_up sensors. 1932 if (sensor.isWakeUpSensor()) { 1933 fifoWakeUpSensors += sensor.getFifoReservedEventCount(); 1934 } else { 1935 fifoNonWakeUpSensors += sensor.getFifoReservedEventCount(); 1936 } 1937 } else { 1938 // Shared fifo. Compute the max of the fifo sizes for wake_up and non_wake up sensors. 1939 if (sensor.isWakeUpSensor()) { 1940 fifoWakeUpSensors = fifoWakeUpSensors > sensor.getFifoMaxEventCount() ? 1941 fifoWakeUpSensors : sensor.getFifoMaxEventCount(); 1942 1943 } else { 1944 fifoNonWakeUpSensors = fifoNonWakeUpSensors > sensor.getFifoMaxEventCount() ? 1945 fifoNonWakeUpSensors : sensor.getFifoMaxEventCount(); 1946 1947 } 1948 } 1949 } 1950 if (fifoWakeUpSensors + fifoNonWakeUpSensors == 0) { 1951 // It is extremely unlikely that there is a write failure in non batch mode. Return a cache 1952 // size that is equal to that of the batch mode. 1953 // ALOGW("Write failure in non-batch mode"); 1954 return MAX_SOCKET_BUFFER_SIZE_BATCHED/sizeof(sensors_event_t); 1955 } 1956 return fifoWakeUpSensors + fifoNonWakeUpSensors; 1957} 1958 1959// --------------------------------------------------------------------------- 1960}; // namespace android 1961 1962