SensorService.cpp revision 8c3e55f4149deda3ec7c7a67fda81216d5f9af25
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 916 // flush complete event before sending events on this connection. Ignore 917 // one-shot sensors which don't support flush(). Ignore on-change sensors 918 // to maintain the on-change logic (any on-change events except the initial 919 // one should be trigger by a change in value). Also if this sensor isn't 920 // already active, don't call flush(). 921 if (err == NO_ERROR && 922 sensor->getSensor().getReportingMode() != AREPORTING_MODE_ONE_SHOT && 923 sensor->getSensor().getReportingMode() != AREPORTING_MODE_ON_CHANGE && 924 rec->getNumConnections() > 1) { 925 connection->setFirstFlushPending(handle, true); 926 status_t err_flush = sensor->flush(connection.get(), handle); 927 // Flush may return error if the underlying h/w sensor uses an older HAL. 928 if (err_flush == NO_ERROR) { 929 rec->addPendingFlushConnection(connection.get()); 930 } else { 931 connection->setFirstFlushPending(handle, false); 932 } 933 } 934 935 if (err == NO_ERROR) { 936 ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle); 937 err = sensor->activate(connection.get(), true); 938 } 939 940 if (err == NO_ERROR) { 941 connection->updateLooperRegistration(mLooper); 942 SensorRegistrationInfo ®_info = 943 mLastNSensorRegistrations.editItemAt(mNextSensorRegIndex); 944 reg_info.mSensorHandle = handle; 945 reg_info.mSamplingRateUs = samplingPeriodNs/1000; 946 reg_info.mMaxReportLatencyUs = maxBatchReportLatencyNs/1000; 947 reg_info.mActivated = true; 948 reg_info.mPackageName = connection->getPackageName(); 949 time_t rawtime = time(NULL); 950 struct tm * timeinfo = localtime(&rawtime); 951 reg_info.mHour = timeinfo->tm_hour; 952 reg_info.mMin = timeinfo->tm_min; 953 reg_info.mSec = timeinfo->tm_sec; 954 mNextSensorRegIndex = (mNextSensorRegIndex + 1) % SENSOR_REGISTRATIONS_BUF_SIZE; 955 } 956 957 if (err != NO_ERROR) { 958 // batch/activate has failed, reset our state. 959 cleanupWithoutDisableLocked(connection, handle); 960 } 961 return err; 962} 963 964status_t SensorService::disable(const sp<SensorEventConnection>& connection, 965 int handle) 966{ 967 if (mInitCheck != NO_ERROR) 968 return mInitCheck; 969 970 Mutex::Autolock _l(mLock); 971 status_t err = cleanupWithoutDisableLocked(connection, handle); 972 if (err == NO_ERROR) { 973 SensorInterface* sensor = mSensorMap.valueFor(handle); 974 err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE); 975 976 } 977 if (err == NO_ERROR) { 978 SensorRegistrationInfo ®_info = 979 mLastNSensorRegistrations.editItemAt(mNextSensorRegIndex); 980 reg_info.mActivated = false; 981 reg_info.mPackageName= connection->getPackageName(); 982 reg_info.mSensorHandle = handle; 983 time_t rawtime = time(NULL); 984 struct tm * timeinfo = localtime(&rawtime); 985 reg_info.mHour = timeinfo->tm_hour; 986 reg_info.mMin = timeinfo->tm_min; 987 reg_info.mSec = timeinfo->tm_sec; 988 mNextSensorRegIndex = (mNextSensorRegIndex + 1) % SENSOR_REGISTRATIONS_BUF_SIZE; 989 } 990 return err; 991} 992 993status_t SensorService::cleanupWithoutDisable( 994 const sp<SensorEventConnection>& connection, int handle) { 995 Mutex::Autolock _l(mLock); 996 return cleanupWithoutDisableLocked(connection, handle); 997} 998 999status_t SensorService::cleanupWithoutDisableLocked( 1000 const sp<SensorEventConnection>& connection, int handle) { 1001 SensorRecord* rec = mActiveSensors.valueFor(handle); 1002 if (rec) { 1003 // see if this connection becomes inactive 1004 if (connection->removeSensor(handle)) { 1005 BatteryService::disableSensor(connection->getUid(), handle); 1006 } 1007 if (connection->hasAnySensor() == false) { 1008 connection->updateLooperRegistration(mLooper); 1009 mActiveConnections.remove(connection); 1010 } 1011 // see if this sensor becomes inactive 1012 if (rec->removeConnection(connection)) { 1013 mActiveSensors.removeItem(handle); 1014 mActiveVirtualSensors.removeItem(handle); 1015 delete rec; 1016 } 1017 return NO_ERROR; 1018 } 1019 return BAD_VALUE; 1020} 1021 1022status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection, 1023 int handle, nsecs_t ns, const String16& opPackageName) 1024{ 1025 if (mInitCheck != NO_ERROR) 1026 return mInitCheck; 1027 1028 SensorInterface* sensor = mSensorMap.valueFor(handle); 1029 if (!sensor) 1030 return BAD_VALUE; 1031 1032 if (!canAccessSensor(sensor->getSensor(), "Tried configuring", opPackageName)) { 1033 return BAD_VALUE; 1034 } 1035 1036 if (ns < 0) 1037 return BAD_VALUE; 1038 1039 nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 1040 if (ns < minDelayNs) { 1041 ns = minDelayNs; 1042 } 1043 1044 return sensor->setDelay(connection.get(), handle, ns); 1045} 1046 1047status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection, 1048 const String16& opPackageName) { 1049 if (mInitCheck != NO_ERROR) return mInitCheck; 1050 SensorDevice& dev(SensorDevice::getInstance()); 1051 const int halVersion = dev.getHalDeviceVersion(); 1052 status_t err(NO_ERROR); 1053 Mutex::Autolock _l(mLock); 1054 // Loop through all sensors for this connection and call flush on each of them. 1055 for (size_t i = 0; i < connection->mSensorInfo.size(); ++i) { 1056 const int handle = connection->mSensorInfo.keyAt(i); 1057 SensorInterface* sensor = mSensorMap.valueFor(handle); 1058 if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 1059 ALOGE("flush called on a one-shot sensor"); 1060 err = INVALID_OPERATION; 1061 continue; 1062 } 1063 if (halVersion <= SENSORS_DEVICE_API_VERSION_1_0 || isVirtualSensor(handle)) { 1064 // For older devices just increment pending flush count which will send a trivial 1065 // flush complete event. 1066 connection->incrementPendingFlushCount(handle); 1067 } else { 1068 if (!canAccessSensor(sensor->getSensor(), "Tried flushing", opPackageName)) { 1069 err = INVALID_OPERATION; 1070 continue; 1071 } 1072 status_t err_flush = sensor->flush(connection.get(), handle); 1073 if (err_flush == NO_ERROR) { 1074 SensorRecord* rec = mActiveSensors.valueFor(handle); 1075 if (rec != NULL) rec->addPendingFlushConnection(connection); 1076 } 1077 err = (err_flush != NO_ERROR) ? err_flush : err; 1078 } 1079 } 1080 return err; 1081} 1082 1083bool SensorService::canAccessSensor(const Sensor& sensor, const char* operation, 1084 const String16& opPackageName) { 1085 const String8& requiredPermission = sensor.getRequiredPermission(); 1086 1087 if (requiredPermission.length() <= 0) { 1088 return true; 1089 } 1090 1091 bool hasPermission = false; 1092 1093 // Runtime permissions can't use the cache as they may change. 1094 if (sensor.isRequiredPermissionRuntime()) { 1095 hasPermission = checkPermission(String16(requiredPermission), 1096 IPCThreadState::self()->getCallingPid(), IPCThreadState::self()->getCallingUid()); 1097 } else { 1098 hasPermission = PermissionCache::checkCallingPermission(String16(requiredPermission)); 1099 } 1100 1101 if (!hasPermission) { 1102 ALOGE("%s a sensor (%s) without holding its required permission: %s", 1103 operation, sensor.getName().string(), sensor.getRequiredPermission().string()); 1104 return false; 1105 } 1106 1107 const int32_t opCode = sensor.getRequiredAppOp(); 1108 if (opCode >= 0) { 1109 AppOpsManager appOps; 1110 if (appOps.noteOp(opCode, IPCThreadState::self()->getCallingUid(), opPackageName) 1111 != AppOpsManager::MODE_ALLOWED) { 1112 ALOGE("%s a sensor (%s) without enabled required app op: %D", 1113 operation, sensor.getName().string(), opCode); 1114 return false; 1115 } 1116 } 1117 1118 return true; 1119} 1120 1121void SensorService::checkWakeLockState() { 1122 Mutex::Autolock _l(mLock); 1123 checkWakeLockStateLocked(); 1124} 1125 1126void SensorService::checkWakeLockStateLocked() { 1127 if (!mWakeLockAcquired) { 1128 return; 1129 } 1130 bool releaseLock = true; 1131 for (size_t i=0 ; i<mActiveConnections.size() ; i++) { 1132 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 1133 if (connection != 0) { 1134 if (connection->needsWakeLock()) { 1135 releaseLock = false; 1136 break; 1137 } 1138 } 1139 } 1140 if (releaseLock) { 1141 setWakeLockAcquiredLocked(false); 1142 } 1143} 1144 1145void SensorService::sendEventsFromCache(const sp<SensorEventConnection>& connection) { 1146 Mutex::Autolock _l(mLock); 1147 connection->writeToSocketFromCache(); 1148 if (connection->needsWakeLock()) { 1149 setWakeLockAcquiredLocked(true); 1150 } 1151} 1152 1153void SensorService::populateActiveConnections( 1154 SortedVector< sp<SensorEventConnection> >* activeConnections) { 1155 Mutex::Autolock _l(mLock); 1156 for (size_t i=0 ; i < mActiveConnections.size(); ++i) { 1157 sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 1158 if (connection != 0) { 1159 activeConnections->add(connection); 1160 } 1161 } 1162} 1163 1164bool SensorService::isWhiteListedPackage(const String8& packageName) { 1165 return (packageName.contains(mWhiteListedPackage.string())); 1166} 1167 1168int SensorService::getNumEventsForSensorType(int sensor_event_type) { 1169 switch (sensor_event_type) { 1170 case SENSOR_TYPE_ROTATION_VECTOR: 1171 case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 1172 return 5; 1173 1174 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 1175 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 1176 return 6; 1177 1178 case SENSOR_TYPE_GAME_ROTATION_VECTOR: 1179 return 4; 1180 1181 case SENSOR_TYPE_SIGNIFICANT_MOTION: 1182 case SENSOR_TYPE_STEP_DETECTOR: 1183 case SENSOR_TYPE_STEP_COUNTER: 1184 return 1; 1185 1186 default: 1187 return 3; 1188 } 1189} 1190 1191// --------------------------------------------------------------------------- 1192SensorService::SensorRecord::SensorRecord( 1193 const sp<SensorEventConnection>& connection) 1194{ 1195 mConnections.add(connection); 1196} 1197 1198bool SensorService::SensorRecord::addConnection( 1199 const sp<SensorEventConnection>& connection) 1200{ 1201 if (mConnections.indexOf(connection) < 0) { 1202 mConnections.add(connection); 1203 return true; 1204 } 1205 return false; 1206} 1207 1208bool SensorService::SensorRecord::removeConnection( 1209 const wp<SensorEventConnection>& connection) 1210{ 1211 ssize_t index = mConnections.indexOf(connection); 1212 if (index >= 0) { 1213 mConnections.removeItemsAt(index, 1); 1214 } 1215 // Remove this connections from the queue of flush() calls made on this sensor. 1216 for (Vector< wp<SensorEventConnection> >::iterator it = 1217 mPendingFlushConnections.begin(); it != mPendingFlushConnections.end();) { 1218 1219 if (it->unsafe_get() == connection.unsafe_get()) { 1220 it = mPendingFlushConnections.erase(it); 1221 } else { 1222 ++it; 1223 } 1224 } 1225 return mConnections.size() ? false : true; 1226} 1227 1228void SensorService::SensorRecord::addPendingFlushConnection( 1229 const sp<SensorEventConnection>& connection) { 1230 mPendingFlushConnections.add(connection); 1231} 1232 1233void SensorService::SensorRecord::removeFirstPendingFlushConnection() { 1234 if (mPendingFlushConnections.size() > 0) { 1235 mPendingFlushConnections.removeAt(0); 1236 } 1237} 1238 1239SensorService::SensorEventConnection * 1240SensorService::SensorRecord::getFirstPendingFlushConnection() { 1241 if (mPendingFlushConnections.size() > 0) { 1242 return mPendingFlushConnections[0].unsafe_get(); 1243 } 1244 return NULL; 1245} 1246 1247void SensorService::SensorRecord::clearAllPendingFlushConnections() { 1248 mPendingFlushConnections.clear(); 1249} 1250 1251 1252// --------------------------------------------------------------------------- 1253SensorService::TrimmedSensorEvent::TrimmedSensorEvent(int sensorType) { 1254 mTimestamp = -1; 1255 const int numData = SensorService::getNumEventsForSensorType(sensorType); 1256 if (sensorType == SENSOR_TYPE_STEP_COUNTER) { 1257 mStepCounter = 0; 1258 } else { 1259 mData = new float[numData]; 1260 for (int i = 0; i < numData; ++i) { 1261 mData[i] = -1.0; 1262 } 1263 } 1264 mHour = mMin = mSec = INT32_MIN; 1265} 1266 1267bool SensorService::TrimmedSensorEvent::isSentinel(const TrimmedSensorEvent& event) { 1268 return (event.mHour == INT32_MIN && event.mMin == INT32_MIN && event.mSec == INT32_MIN); 1269} 1270// -------------------------------------------------------------------------- 1271SensorService::CircularBuffer::CircularBuffer(int sensor_event_type) { 1272 mNextInd = 0; 1273 mBufSize = CIRCULAR_BUF_SIZE; 1274 if (sensor_event_type == SENSOR_TYPE_STEP_COUNTER || 1275 sensor_event_type == SENSOR_TYPE_SIGNIFICANT_MOTION || 1276 sensor_event_type == SENSOR_TYPE_ACCELEROMETER) { 1277 mBufSize = CIRCULAR_BUF_SIZE * 5; 1278 } 1279 mTrimmedSensorEventArr = new TrimmedSensorEvent *[mBufSize]; 1280 mSensorType = sensor_event_type; 1281 for (int i = 0; i < mBufSize; ++i) { 1282 mTrimmedSensorEventArr[i] = new TrimmedSensorEvent(mSensorType); 1283 } 1284} 1285 1286void SensorService::CircularBuffer::addEvent(const sensors_event_t& sensor_event) { 1287 TrimmedSensorEvent *curr_event = mTrimmedSensorEventArr[mNextInd]; 1288 curr_event->mTimestamp = sensor_event.timestamp; 1289 if (mSensorType == SENSOR_TYPE_STEP_COUNTER) { 1290 curr_event->mStepCounter = sensor_event.u64.step_counter; 1291 } else { 1292 memcpy(curr_event->mData, sensor_event.data, 1293 sizeof(float) * SensorService::getNumEventsForSensorType(mSensorType)); 1294 } 1295 time_t rawtime = time(NULL); 1296 struct tm * timeinfo = localtime(&rawtime); 1297 curr_event->mHour = timeinfo->tm_hour; 1298 curr_event->mMin = timeinfo->tm_min; 1299 curr_event->mSec = timeinfo->tm_sec; 1300 mNextInd = (mNextInd + 1) % mBufSize; 1301} 1302 1303void SensorService::CircularBuffer::printBuffer(String8& result) const { 1304 const int numData = SensorService::getNumEventsForSensorType(mSensorType); 1305 int i = mNextInd, eventNum = 1; 1306 result.appendFormat("last %d events = < ", mBufSize); 1307 do { 1308 if (TrimmedSensorEvent::isSentinel(*mTrimmedSensorEventArr[i])) { 1309 // Sentinel, ignore. 1310 i = (i + 1) % mBufSize; 1311 continue; 1312 } 1313 result.appendFormat("%d) ", eventNum++); 1314 if (mSensorType == SENSOR_TYPE_STEP_COUNTER) { 1315 result.appendFormat("%llu,", mTrimmedSensorEventArr[i]->mStepCounter); 1316 } else { 1317 for (int j = 0; j < numData; ++j) { 1318 result.appendFormat("%5.1f,", mTrimmedSensorEventArr[i]->mData[j]); 1319 } 1320 } 1321 result.appendFormat("%lld %02d:%02d:%02d ", mTrimmedSensorEventArr[i]->mTimestamp, 1322 mTrimmedSensorEventArr[i]->mHour, mTrimmedSensorEventArr[i]->mMin, 1323 mTrimmedSensorEventArr[i]->mSec); 1324 i = (i + 1) % mBufSize; 1325 } while (i != mNextInd); 1326 result.appendFormat(">\n"); 1327} 1328 1329bool SensorService::CircularBuffer::populateLastEvent(sensors_event_t *event) { 1330 int lastEventInd = (mNextInd - 1 + mBufSize) % mBufSize; 1331 // Check if the buffer is empty. 1332 if (TrimmedSensorEvent::isSentinel(*mTrimmedSensorEventArr[lastEventInd])) { 1333 return false; 1334 } 1335 event->version = sizeof(sensors_event_t); 1336 event->type = mSensorType; 1337 event->timestamp = mTrimmedSensorEventArr[lastEventInd]->mTimestamp; 1338 if (mSensorType == SENSOR_TYPE_STEP_COUNTER) { 1339 event->u64.step_counter = mTrimmedSensorEventArr[lastEventInd]->mStepCounter; 1340 } else { 1341 memcpy(event->data, mTrimmedSensorEventArr[lastEventInd]->mData, 1342 sizeof(float) * SensorService::getNumEventsForSensorType(mSensorType)); 1343 } 1344 return true; 1345} 1346 1347SensorService::CircularBuffer::~CircularBuffer() { 1348 for (int i = 0; i < mBufSize; ++i) { 1349 delete mTrimmedSensorEventArr[i]; 1350 } 1351 delete [] mTrimmedSensorEventArr; 1352} 1353 1354// --------------------------------------------------------------------------- 1355 1356SensorService::SensorEventConnection::SensorEventConnection( 1357 const sp<SensorService>& service, uid_t uid, String8 packageName, bool isDataInjectionMode, 1358 const String16& opPackageName) 1359 : mService(service), mUid(uid), mWakeLockRefCount(0), mHasLooperCallbacks(false), 1360 mDead(false), mDataInjectionMode(isDataInjectionMode), mEventCache(NULL), 1361 mCacheSize(0), mMaxCacheSize(0), mPackageName(packageName), mOpPackageName(opPackageName) { 1362 mChannel = new BitTube(mService->mSocketBufferSize); 1363#if DEBUG_CONNECTIONS 1364 mEventsReceived = mEventsSentFromCache = mEventsSent = 0; 1365 mTotalAcksNeeded = mTotalAcksReceived = 0; 1366#endif 1367} 1368 1369SensorService::SensorEventConnection::~SensorEventConnection() { 1370 ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this); 1371 mService->cleanupConnection(this); 1372 if (mEventCache != NULL) { 1373 delete mEventCache; 1374 } 1375} 1376 1377void SensorService::SensorEventConnection::onFirstRef() { 1378 LooperCallback::onFirstRef(); 1379} 1380 1381bool SensorService::SensorEventConnection::needsWakeLock() { 1382 Mutex::Autolock _l(mConnectionLock); 1383 return !mDead && mWakeLockRefCount > 0; 1384} 1385 1386void SensorService::SensorEventConnection::resetWakeLockRefCount() { 1387 Mutex::Autolock _l(mConnectionLock); 1388 mWakeLockRefCount = 0; 1389} 1390 1391void SensorService::SensorEventConnection::dump(String8& result) { 1392 Mutex::Autolock _l(mConnectionLock); 1393 result.appendFormat("\tOperating Mode: %s\n",mDataInjectionMode ? "DATA_INJECTION" : "NORMAL"); 1394 result.appendFormat("\t %s | WakeLockRefCount %d | uid %d | cache size %d | " 1395 "max cache size %d\n", mPackageName.string(), mWakeLockRefCount, mUid, mCacheSize, 1396 mMaxCacheSize); 1397 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1398 const FlushInfo& flushInfo = mSensorInfo.valueAt(i); 1399 result.appendFormat("\t %s 0x%08x | status: %s | pending flush events %d \n", 1400 mService->getSensorName(mSensorInfo.keyAt(i)).string(), 1401 mSensorInfo.keyAt(i), 1402 flushInfo.mFirstFlushPending ? "First flush pending" : 1403 "active", 1404 flushInfo.mPendingFlushEventsToSend); 1405 } 1406#if DEBUG_CONNECTIONS 1407 result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d |" 1408 " total_acks_needed %d | total_acks_recvd %d\n", 1409 mEventsReceived, 1410 mEventsSent, 1411 mEventsSentFromCache, 1412 mEventsReceived - (mEventsSentFromCache + mEventsSent + mCacheSize), 1413 mTotalAcksNeeded, 1414 mTotalAcksReceived); 1415#endif 1416} 1417 1418bool SensorService::SensorEventConnection::addSensor(int32_t handle) { 1419 Mutex::Autolock _l(mConnectionLock); 1420 if (!canAccessSensor(mService->getSensorFromHandle(handle), 1421 "Tried adding", mOpPackageName)) { 1422 return false; 1423 } 1424 if (mSensorInfo.indexOfKey(handle) < 0) { 1425 mSensorInfo.add(handle, FlushInfo()); 1426 return true; 1427 } 1428 return false; 1429} 1430 1431bool SensorService::SensorEventConnection::removeSensor(int32_t handle) { 1432 Mutex::Autolock _l(mConnectionLock); 1433 if (mSensorInfo.removeItem(handle) >= 0) { 1434 return true; 1435 } 1436 return false; 1437} 1438 1439bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const { 1440 Mutex::Autolock _l(mConnectionLock); 1441 return mSensorInfo.indexOfKey(handle) >= 0; 1442} 1443 1444bool SensorService::SensorEventConnection::hasAnySensor() const { 1445 Mutex::Autolock _l(mConnectionLock); 1446 return mSensorInfo.size() ? true : false; 1447} 1448 1449bool SensorService::SensorEventConnection::hasOneShotSensors() const { 1450 Mutex::Autolock _l(mConnectionLock); 1451 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1452 const int handle = mSensorInfo.keyAt(i); 1453 if (mService->getSensorFromHandle(handle).getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 1454 return true; 1455 } 1456 } 1457 return false; 1458} 1459 1460String8 SensorService::SensorEventConnection::getPackageName() const { 1461 return mPackageName; 1462} 1463 1464void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle, 1465 bool value) { 1466 Mutex::Autolock _l(mConnectionLock); 1467 ssize_t index = mSensorInfo.indexOfKey(handle); 1468 if (index >= 0) { 1469 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1470 flushInfo.mFirstFlushPending = value; 1471 } 1472} 1473 1474void SensorService::SensorEventConnection::updateLooperRegistration(const sp<Looper>& looper) { 1475 Mutex::Autolock _l(mConnectionLock); 1476 updateLooperRegistrationLocked(looper); 1477} 1478 1479void SensorService::SensorEventConnection::updateLooperRegistrationLocked( 1480 const sp<Looper>& looper) { 1481 bool isConnectionActive = (mSensorInfo.size() > 0 && !mDataInjectionMode) || 1482 mDataInjectionMode; 1483 // If all sensors are unregistered OR Looper has encountered an error, we 1484 // can remove the Fd from the Looper if it has been previously added. 1485 if (!isConnectionActive || mDead) { 1486 if (mHasLooperCallbacks) { 1487 ALOGD_IF(DEBUG_CONNECTIONS, "%p removeFd fd=%d", this, mChannel->getSendFd()); 1488 looper->removeFd(mChannel->getSendFd()); 1489 mHasLooperCallbacks = false; 1490 } 1491 return; 1492 } 1493 1494 int looper_flags = 0; 1495 if (mCacheSize > 0) looper_flags |= ALOOPER_EVENT_OUTPUT; 1496 if (mDataInjectionMode) looper_flags |= ALOOPER_EVENT_INPUT; 1497 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1498 const int handle = mSensorInfo.keyAt(i); 1499 if (mService->getSensorFromHandle(handle).isWakeUpSensor()) { 1500 looper_flags |= ALOOPER_EVENT_INPUT; 1501 break; 1502 } 1503 } 1504 // If flags is still set to zero, we don't need to add this fd to the Looper, if 1505 // the fd has already been added, remove it. This is likely to happen when ALL the 1506 // events stored in the cache have been sent to the corresponding app. 1507 if (looper_flags == 0) { 1508 if (mHasLooperCallbacks) { 1509 ALOGD_IF(DEBUG_CONNECTIONS, "removeFd fd=%d", mChannel->getSendFd()); 1510 looper->removeFd(mChannel->getSendFd()); 1511 mHasLooperCallbacks = false; 1512 } 1513 return; 1514 } 1515 // Add the file descriptor to the Looper for receiving acknowledegments if the app has 1516 // registered for wake-up sensors OR for sending events in the cache. 1517 int ret = looper->addFd(mChannel->getSendFd(), 0, looper_flags, this, NULL); 1518 if (ret == 1) { 1519 ALOGD_IF(DEBUG_CONNECTIONS, "%p addFd fd=%d", this, mChannel->getSendFd()); 1520 mHasLooperCallbacks = true; 1521 } else { 1522 ALOGE("Looper::addFd failed ret=%d fd=%d", ret, mChannel->getSendFd()); 1523 } 1524} 1525 1526void SensorService::SensorEventConnection::incrementPendingFlushCount(int32_t handle) { 1527 Mutex::Autolock _l(mConnectionLock); 1528 ssize_t index = mSensorInfo.indexOfKey(handle); 1529 if (index >= 0) { 1530 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1531 flushInfo.mPendingFlushEventsToSend++; 1532 } 1533} 1534 1535status_t SensorService::SensorEventConnection::sendEvents( 1536 sensors_event_t const* buffer, size_t numEvents, 1537 sensors_event_t* scratch, 1538 SensorEventConnection const * const * mapFlushEventsToConnections) { 1539 // filter out events not for this connection 1540 int count = 0; 1541 Mutex::Autolock _l(mConnectionLock); 1542 if (scratch) { 1543 size_t i=0; 1544 while (i<numEvents) { 1545 int32_t sensor_handle = buffer[i].sensor; 1546 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1547 ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ", 1548 buffer[i].meta_data.sensor); 1549 // Setting sensor_handle to the correct sensor to ensure the sensor events per 1550 // connection are filtered correctly. buffer[i].sensor is zero for meta_data 1551 // events. 1552 sensor_handle = buffer[i].meta_data.sensor; 1553 } 1554 ssize_t index = mSensorInfo.indexOfKey(sensor_handle); 1555 // Check if this connection has registered for this sensor. If not continue to the 1556 // next sensor_event. 1557 if (index < 0) { 1558 ++i; 1559 continue; 1560 } 1561 1562 FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 1563 // Check if there is a pending flush_complete event for this sensor on this connection. 1564 if (buffer[i].type == SENSOR_TYPE_META_DATA && flushInfo.mFirstFlushPending == true && 1565 this == mapFlushEventsToConnections[i]) { 1566 flushInfo.mFirstFlushPending = false; 1567 ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ", 1568 buffer[i].meta_data.sensor); 1569 ++i; 1570 continue; 1571 } 1572 1573 // If there is a pending flush complete event for this sensor on this connection, 1574 // ignore the event and proceed to the next. 1575 if (flushInfo.mFirstFlushPending) { 1576 ++i; 1577 continue; 1578 } 1579 1580 do { 1581 // Keep copying events into the scratch buffer as long as they are regular 1582 // sensor_events are from the same sensor_handle OR they are flush_complete_events 1583 // from the same sensor_handle AND the current connection is mapped to the 1584 // corresponding flush_complete_event. 1585 if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1586 if (this == mapFlushEventsToConnections[i]) { 1587 scratch[count++] = buffer[i]; 1588 } 1589 ++i; 1590 } else { 1591 // Regular sensor event, just copy it to the scratch buffer. 1592 scratch[count++] = buffer[i++]; 1593 } 1594 } while ((i<numEvents) && ((buffer[i].sensor == sensor_handle && 1595 buffer[i].type != SENSOR_TYPE_META_DATA) || 1596 (buffer[i].type == SENSOR_TYPE_META_DATA && 1597 buffer[i].meta_data.sensor == sensor_handle))); 1598 } 1599 } else { 1600 scratch = const_cast<sensors_event_t *>(buffer); 1601 count = numEvents; 1602 } 1603 1604 sendPendingFlushEventsLocked(); 1605 // Early return if there are no events for this connection. 1606 if (count == 0) { 1607 return status_t(NO_ERROR); 1608 } 1609 1610#if DEBUG_CONNECTIONS 1611 mEventsReceived += count; 1612#endif 1613 if (mCacheSize != 0) { 1614 // There are some events in the cache which need to be sent first. Copy this buffer to 1615 // the end of cache. 1616 if (mCacheSize + count <= mMaxCacheSize) { 1617 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1618 mCacheSize += count; 1619 } else { 1620 // Check if any new sensors have registered on this connection which may have increased 1621 // the max cache size that is desired. 1622 if (mCacheSize + count < computeMaxCacheSizeLocked()) { 1623 reAllocateCacheLocked(scratch, count); 1624 return status_t(NO_ERROR); 1625 } 1626 // Some events need to be dropped. 1627 int remaningCacheSize = mMaxCacheSize - mCacheSize; 1628 if (remaningCacheSize != 0) { 1629 memcpy(&mEventCache[mCacheSize], scratch, 1630 remaningCacheSize * sizeof(sensors_event_t)); 1631 } 1632 int numEventsDropped = count - remaningCacheSize; 1633 countFlushCompleteEventsLocked(mEventCache, numEventsDropped); 1634 // Drop the first "numEventsDropped" in the cache. 1635 memmove(mEventCache, &mEventCache[numEventsDropped], 1636 (mCacheSize - numEventsDropped) * sizeof(sensors_event_t)); 1637 1638 // Copy the remainingEvents in scratch buffer to the end of cache. 1639 memcpy(&mEventCache[mCacheSize - numEventsDropped], scratch + remaningCacheSize, 1640 numEventsDropped * sizeof(sensors_event_t)); 1641 } 1642 return status_t(NO_ERROR); 1643 } 1644 1645 int index_wake_up_event = findWakeUpSensorEventLocked(scratch, count); 1646 if (index_wake_up_event >= 0) { 1647 scratch[index_wake_up_event].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1648 ++mWakeLockRefCount; 1649#if DEBUG_CONNECTIONS 1650 ++mTotalAcksNeeded; 1651#endif 1652 } 1653 1654 // NOTE: ASensorEvent and sensors_event_t are the same type. 1655 ssize_t size = SensorEventQueue::write(mChannel, 1656 reinterpret_cast<ASensorEvent const*>(scratch), count); 1657 if (size < 0) { 1658 // Write error, copy events to local cache. 1659 if (index_wake_up_event >= 0) { 1660 // If there was a wake_up sensor_event, reset the flag. 1661 scratch[index_wake_up_event].flags &= ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1662 if (mWakeLockRefCount > 0) { 1663 --mWakeLockRefCount; 1664 } 1665#if DEBUG_CONNECTIONS 1666 --mTotalAcksNeeded; 1667#endif 1668 } 1669 if (mEventCache == NULL) { 1670 mMaxCacheSize = computeMaxCacheSizeLocked(); 1671 mEventCache = new sensors_event_t[mMaxCacheSize]; 1672 mCacheSize = 0; 1673 } 1674 memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1675 mCacheSize += count; 1676 1677 // Add this file descriptor to the looper to get a callback when this fd is available for 1678 // writing. 1679 updateLooperRegistrationLocked(mService->getLooper()); 1680 return size; 1681 } 1682 1683#if DEBUG_CONNECTIONS 1684 if (size > 0) { 1685 mEventsSent += count; 1686 } 1687#endif 1688 1689 return size < 0 ? status_t(size) : status_t(NO_ERROR); 1690} 1691 1692void SensorService::SensorEventConnection::reAllocateCacheLocked(sensors_event_t const* scratch, 1693 int count) { 1694 sensors_event_t *eventCache_new; 1695 const int new_cache_size = computeMaxCacheSizeLocked(); 1696 // Allocate new cache, copy over events from the old cache & scratch, free up memory. 1697 eventCache_new = new sensors_event_t[new_cache_size]; 1698 memcpy(eventCache_new, mEventCache, mCacheSize * sizeof(sensors_event_t)); 1699 memcpy(&eventCache_new[mCacheSize], scratch, count * sizeof(sensors_event_t)); 1700 1701 ALOGD_IF(DEBUG_CONNECTIONS, "reAllocateCacheLocked maxCacheSize=%d %d", mMaxCacheSize, 1702 new_cache_size); 1703 1704 delete mEventCache; 1705 mEventCache = eventCache_new; 1706 mCacheSize += count; 1707 mMaxCacheSize = new_cache_size; 1708} 1709 1710void SensorService::SensorEventConnection::sendPendingFlushEventsLocked() { 1711 ASensorEvent flushCompleteEvent; 1712 memset(&flushCompleteEvent, 0, sizeof(flushCompleteEvent)); 1713 flushCompleteEvent.type = SENSOR_TYPE_META_DATA; 1714 // Loop through all the sensors for this connection and check if there are any pending 1715 // flush complete events to be sent. 1716 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1717 FlushInfo& flushInfo = mSensorInfo.editValueAt(i); 1718 while (flushInfo.mPendingFlushEventsToSend > 0) { 1719 const int sensor_handle = mSensorInfo.keyAt(i); 1720 flushCompleteEvent.meta_data.sensor = sensor_handle; 1721 bool wakeUpSensor = mService->getSensorFromHandle(sensor_handle).isWakeUpSensor(); 1722 if (wakeUpSensor) { 1723 ++mWakeLockRefCount; 1724 flushCompleteEvent.flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1725 } 1726 ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1); 1727 if (size < 0) { 1728 if (wakeUpSensor) --mWakeLockRefCount; 1729 return; 1730 } 1731 ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ", 1732 flushCompleteEvent.meta_data.sensor); 1733 flushInfo.mPendingFlushEventsToSend--; 1734 } 1735 } 1736} 1737 1738void SensorService::SensorEventConnection::writeToSocketFromCache() { 1739 // At a time write at most half the size of the receiver buffer in SensorEventQueue OR 1740 // half the size of the socket buffer allocated in BitTube whichever is smaller. 1741 const int maxWriteSize = helpers::min(SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT/2, 1742 int(mService->mSocketBufferSize/(sizeof(sensors_event_t)*2))); 1743 Mutex::Autolock _l(mConnectionLock); 1744 // Send pending flush complete events (if any) 1745 sendPendingFlushEventsLocked(); 1746 for (int numEventsSent = 0; numEventsSent < mCacheSize;) { 1747 const int numEventsToWrite = helpers::min(mCacheSize - numEventsSent, maxWriteSize); 1748 int index_wake_up_event = 1749 findWakeUpSensorEventLocked(mEventCache + numEventsSent, numEventsToWrite); 1750 if (index_wake_up_event >= 0) { 1751 mEventCache[index_wake_up_event + numEventsSent].flags |= 1752 WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1753 ++mWakeLockRefCount; 1754#if DEBUG_CONNECTIONS 1755 ++mTotalAcksNeeded; 1756#endif 1757 } 1758 1759 ssize_t size = SensorEventQueue::write(mChannel, 1760 reinterpret_cast<ASensorEvent const*>(mEventCache + numEventsSent), 1761 numEventsToWrite); 1762 if (size < 0) { 1763 if (index_wake_up_event >= 0) { 1764 // If there was a wake_up sensor_event, reset the flag. 1765 mEventCache[index_wake_up_event + numEventsSent].flags &= 1766 ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 1767 if (mWakeLockRefCount > 0) { 1768 --mWakeLockRefCount; 1769 } 1770#if DEBUG_CONNECTIONS 1771 --mTotalAcksNeeded; 1772#endif 1773 } 1774 memmove(mEventCache, &mEventCache[numEventsSent], 1775 (mCacheSize - numEventsSent) * sizeof(sensors_event_t)); 1776 ALOGD_IF(DEBUG_CONNECTIONS, "wrote %d events from cache size==%d ", 1777 numEventsSent, mCacheSize); 1778 mCacheSize -= numEventsSent; 1779 return; 1780 } 1781 numEventsSent += numEventsToWrite; 1782#if DEBUG_CONNECTIONS 1783 mEventsSentFromCache += numEventsToWrite; 1784#endif 1785 } 1786 ALOGD_IF(DEBUG_CONNECTIONS, "wrote all events from cache size=%d ", mCacheSize); 1787 // All events from the cache have been sent. Reset cache size to zero. 1788 mCacheSize = 0; 1789 // There are no more events in the cache. We don't need to poll for write on the fd. 1790 // Update Looper registration. 1791 updateLooperRegistrationLocked(mService->getLooper()); 1792} 1793 1794void SensorService::SensorEventConnection::countFlushCompleteEventsLocked( 1795 sensors_event_t const* scratch, const int numEventsDropped) { 1796 ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped); 1797 // Count flushComplete events in the events that are about to the dropped. These will be sent 1798 // separately before the next batch of events. 1799 for (int j = 0; j < numEventsDropped; ++j) { 1800 if (scratch[j].type == SENSOR_TYPE_META_DATA) { 1801 FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor); 1802 flushInfo.mPendingFlushEventsToSend++; 1803 ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d", 1804 flushInfo.mPendingFlushEventsToSend); 1805 } 1806 } 1807 return; 1808} 1809 1810int SensorService::SensorEventConnection::findWakeUpSensorEventLocked( 1811 sensors_event_t const* scratch, const int count) { 1812 for (int i = 0; i < count; ++i) { 1813 if (mService->isWakeUpSensorEvent(scratch[i])) { 1814 return i; 1815 } 1816 } 1817 return -1; 1818} 1819 1820sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const 1821{ 1822 return mChannel; 1823} 1824 1825status_t SensorService::SensorEventConnection::enableDisable( 1826 int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, 1827 int reservedFlags) 1828{ 1829 status_t err; 1830 if (enabled) { 1831 err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs, 1832 reservedFlags, mOpPackageName); 1833 1834 } else { 1835 err = mService->disable(this, handle); 1836 } 1837 return err; 1838} 1839 1840status_t SensorService::SensorEventConnection::setEventRate( 1841 int handle, nsecs_t samplingPeriodNs) 1842{ 1843 return mService->setEventRate(this, handle, samplingPeriodNs, mOpPackageName); 1844} 1845 1846status_t SensorService::SensorEventConnection::flush() { 1847 return mService->flushSensor(this, mOpPackageName); 1848} 1849 1850int SensorService::SensorEventConnection::handleEvent(int fd, int events, void* /*data*/) { 1851 if (events & ALOOPER_EVENT_HANGUP || events & ALOOPER_EVENT_ERROR) { 1852 { 1853 // If the Looper encounters some error, set the flag mDead, reset mWakeLockRefCount, 1854 // and remove the fd from Looper. Call checkWakeLockState to know if SensorService 1855 // can release the wake-lock. 1856 ALOGD_IF(DEBUG_CONNECTIONS, "%p Looper error %d", this, fd); 1857 Mutex::Autolock _l(mConnectionLock); 1858 mDead = true; 1859 mWakeLockRefCount = 0; 1860 updateLooperRegistrationLocked(mService->getLooper()); 1861 } 1862 mService->checkWakeLockState(); 1863 if (mDataInjectionMode) { 1864 // If the Looper has encountered some error in data injection mode, reset SensorService 1865 // back to normal mode. 1866 mService->resetToNormalMode(); 1867 mDataInjectionMode = false; 1868 } 1869 return 1; 1870 } 1871 1872 if (events & ALOOPER_EVENT_INPUT) { 1873 unsigned char buf[sizeof(sensors_event_t)]; 1874 ssize_t numBytesRead = ::recv(fd, buf, sizeof(buf), MSG_DONTWAIT); 1875 { 1876 Mutex::Autolock _l(mConnectionLock); 1877 if (numBytesRead == sizeof(sensors_event_t)) { 1878 if (!mDataInjectionMode) { 1879 ALOGE("Data injected in normal mode, dropping event" 1880 "package=%s uid=%d", mPackageName.string(), mUid); 1881 // Unregister call backs. 1882 return 0; 1883 } 1884 SensorDevice& dev(SensorDevice::getInstance()); 1885 sensors_event_t sensor_event; 1886 memset(&sensor_event, 0, sizeof(sensor_event)); 1887 memcpy(&sensor_event, buf, sizeof(sensors_event_t)); 1888 Sensor sensor = mService->getSensorFromHandle(sensor_event.sensor); 1889 sensor_event.type = sensor.getType(); 1890 dev.injectSensorData(&sensor_event); 1891#if DEBUG_CONNECTIONS 1892 ++mEventsReceived; 1893#endif 1894 } else if (numBytesRead == sizeof(uint32_t)) { 1895 uint32_t numAcks = 0; 1896 memcpy(&numAcks, buf, numBytesRead); 1897 // Sanity check to ensure there are no read errors in recv, numAcks is always 1898 // within the range and not zero. If any of the above don't hold reset 1899 // mWakeLockRefCount to zero. 1900 if (numAcks > 0 && numAcks < mWakeLockRefCount) { 1901 mWakeLockRefCount -= numAcks; 1902 } else { 1903 mWakeLockRefCount = 0; 1904 } 1905#if DEBUG_CONNECTIONS 1906 mTotalAcksReceived += numAcks; 1907#endif 1908 } else { 1909 // Read error, reset wakelock refcount. 1910 mWakeLockRefCount = 0; 1911 } 1912 } 1913 // Check if wakelock can be released by sensorservice. mConnectionLock needs to be released 1914 // here as checkWakeLockState() will need it. 1915 if (mWakeLockRefCount == 0) { 1916 mService->checkWakeLockState(); 1917 } 1918 // continue getting callbacks. 1919 return 1; 1920 } 1921 1922 if (events & ALOOPER_EVENT_OUTPUT) { 1923 // send sensor data that is stored in mEventCache for this connection. 1924 mService->sendEventsFromCache(this); 1925 } 1926 return 1; 1927} 1928 1929int SensorService::SensorEventConnection::computeMaxCacheSizeLocked() const { 1930 size_t fifoWakeUpSensors = 0; 1931 size_t fifoNonWakeUpSensors = 0; 1932 for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1933 const Sensor& sensor = mService->getSensorFromHandle(mSensorInfo.keyAt(i)); 1934 if (sensor.getFifoReservedEventCount() == sensor.getFifoMaxEventCount()) { 1935 // Each sensor has a reserved fifo. Sum up the fifo sizes for all wake up sensors and 1936 // non wake_up sensors. 1937 if (sensor.isWakeUpSensor()) { 1938 fifoWakeUpSensors += sensor.getFifoReservedEventCount(); 1939 } else { 1940 fifoNonWakeUpSensors += sensor.getFifoReservedEventCount(); 1941 } 1942 } else { 1943 // Shared fifo. Compute the max of the fifo sizes for wake_up and non_wake up sensors. 1944 if (sensor.isWakeUpSensor()) { 1945 fifoWakeUpSensors = fifoWakeUpSensors > sensor.getFifoMaxEventCount() ? 1946 fifoWakeUpSensors : sensor.getFifoMaxEventCount(); 1947 1948 } else { 1949 fifoNonWakeUpSensors = fifoNonWakeUpSensors > sensor.getFifoMaxEventCount() ? 1950 fifoNonWakeUpSensors : sensor.getFifoMaxEventCount(); 1951 1952 } 1953 } 1954 } 1955 if (fifoWakeUpSensors + fifoNonWakeUpSensors == 0) { 1956 // It is extremely unlikely that there is a write failure in non batch mode. Return a cache 1957 // size that is equal to that of the batch mode. 1958 // ALOGW("Write failure in non-batch mode"); 1959 return MAX_SOCKET_BUFFER_SIZE_BATCHED/sizeof(sensors_event_t); 1960 } 1961 return fifoWakeUpSensors + fifoNonWakeUpSensors; 1962} 1963 1964// --------------------------------------------------------------------------- 1965}; // namespace android 1966 1967