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