1fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian/* 2fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * Copyright (C) 2010 The Android Open Source Project 3fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * 4fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * Licensed under the Apache License, Version 2.0 (the "License"); 5fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * you may not use this file except in compliance with the License. 6fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * You may obtain a copy of the License at 7fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * 8fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * http://www.apache.org/licenses/LICENSE-2.0 9fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * 10fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * Unless required by applicable law or agreed to in writing, software 11fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * distributed under the License is distributed on an "AS IS" BASIS, 12fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * See the License for the specific language governing permissions and 14fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian * limitations under the License. 15fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian */ 16fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1792dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn#include <inttypes.h> 18f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian#include <math.h> 1992dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn#include <stdint.h> 20fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <sys/types.h> 2156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#include <sys/socket.h> 22fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 233301542828febc768e1df42892cfac4992c35474Mathias Agopian#include <cutils/properties.h> 243301542828febc768e1df42892cfac4992c35474Mathias Agopian 25fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <utils/SortedVector.h> 26fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <utils/KeyedVector.h> 27fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <utils/threads.h> 28fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <utils/Atomic.h> 29fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <utils/Errors.h> 30fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <utils/RefBase.h> 31451beee076cac09f817abae78a990dea108a9482Mathias Agopian#include <utils/Singleton.h> 32c4a930d1d5a432a1f302763ac55460d6e83fe7e0Mathias Agopian#include <utils/String16.h> 33fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 34fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <binder/BinderService.h> 35451beee076cac09f817abae78a990dea108a9482Mathias Agopian#include <binder/IServiceManager.h> 361cb13461a8cf62e3ba634e5965332f2d284f6d42Mathias Agopian#include <binder/PermissionCache.h> 37fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 38fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <gui/ISensorServer.h> 39fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <gui/ISensorEventConnection.h> 40907103bf186cfdd2ed9eb3b6c36de53ade7b16f6Mathias Agopian#include <gui/SensorEventQueue.h> 41fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 42fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian#include <hardware/sensors.h> 434342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh#include <hardware_legacy/power.h> 44fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 45787ac1b388f144f5e6dd38f8b807866a5256dafcMathias Agopian#include "BatteryService.h" 46984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian#include "CorrectedGyroSensor.h" 47f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian#include "GravitySensor.h" 48f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian#include "LinearAccelerationSensor.h" 49984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian#include "OrientationSensor.h" 50f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian#include "RotationVectorSensor.h" 51984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian#include "SensorFusion.h" 52984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian#include "SensorService.h" 53fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 54fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopiannamespace android { 55fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian// --------------------------------------------------------------------------- 56fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 573301542828febc768e1df42892cfac4992c35474Mathias Agopian/* 583301542828febc768e1df42892cfac4992c35474Mathias Agopian * Notes: 593301542828febc768e1df42892cfac4992c35474Mathias Agopian * 603301542828febc768e1df42892cfac4992c35474Mathias Agopian * - what about a gyro-corrected magnetic-field sensor? 613301542828febc768e1df42892cfac4992c35474Mathias Agopian * - run mag sensor from time to time to force calibration 623301542828febc768e1df42892cfac4992c35474Mathias Agopian * - gravity sensor length is wrong (=> drift in linear-acc sensor) 633301542828febc768e1df42892cfac4992c35474Mathias Agopian * 643301542828febc768e1df42892cfac4992c35474Mathias Agopian */ 653301542828febc768e1df42892cfac4992c35474Mathias Agopian 664342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganeshconst char* SensorService::WAKE_LOCK_NAME = "SensorService"; 674342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 68fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias AgopianSensorService::SensorService() 698a96955c8e14db40b16164236830fc9506a00872Aravind Akella : mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED), 708a96955c8e14db40b16164236830fc9506a00872Aravind Akella mWakeLockAcquired(false) 71fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 72fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 73fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 74fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianvoid SensorService::onFirstRef() 75fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 76a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD("nuSensorService starting..."); 7750df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian 78f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian SensorDevice& dev(SensorDevice::getInstance()); 79fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 80f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (dev.initCheck() == NO_ERROR) { 81f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensor_t const* list; 827b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian ssize_t count = dev.getSensorList(&list); 837b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian if (count > 0) { 847b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian ssize_t orientationIndex = -1; 857b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian bool hasGyro = false; 867b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian uint32_t virtualSensorsNeeds = 877b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian (1<<SENSOR_TYPE_GRAVITY) | 887b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian (1<<SENSOR_TYPE_LINEAR_ACCELERATION) | 897b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian (1<<SENSOR_TYPE_ROTATION_VECTOR); 907b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian 917b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian mLastEventSeen.setCapacity(count); 927b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian for (ssize_t i=0 ; i<count ; i++) { 937b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian registerSensor( new HardwareSensor(list[i]) ); 947b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian switch (list[i].type) { 957b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_ORIENTATION: 967b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian orientationIndex = i; 977b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian break; 987b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_GYROSCOPE: 990319306670b0344da99efa606b6f172dde575a39Mathias Agopian case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 1007b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian hasGyro = true; 1017b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian break; 1027b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_GRAVITY: 1037b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_LINEAR_ACCELERATION: 1047b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_ROTATION_VECTOR: 1057b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian virtualSensorsNeeds &= ~(1<<list[i].type); 1067b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian break; 1077b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian } 10850df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian } 109fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1107b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian // it's safe to instantiate the SensorFusion object here 1117b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian // (it wants to be instantiated after h/w sensors have been 1127b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian // registered) 1137b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian const SensorFusion& fusion(SensorFusion::getInstance()); 1147b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian 1150319306670b0344da99efa606b6f172dde575a39Mathias Agopian // build the sensor list returned to users 1160319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList = mSensorList; 1170319306670b0344da99efa606b6f172dde575a39Mathias Agopian 1187b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian if (hasGyro) { 1190319306670b0344da99efa606b6f172dde575a39Mathias Agopian Sensor aSensor; 1207b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian 1210319306670b0344da99efa606b6f172dde575a39Mathias Agopian // Add Android virtual sensors if they're not already 1220319306670b0344da99efa606b6f172dde575a39Mathias Agopian // available in the HAL 1237b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian 1240319306670b0344da99efa606b6f172dde575a39Mathias Agopian aSensor = registerVirtualSensor( new RotationVectorSensor() ); 1250319306670b0344da99efa606b6f172dde575a39Mathias Agopian if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 1260319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList.add(aSensor); 1270319306670b0344da99efa606b6f172dde575a39Mathias Agopian } 128f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 1290319306670b0344da99efa606b6f172dde575a39Mathias Agopian aSensor = registerVirtualSensor( new GravitySensor(list, count) ); 1300319306670b0344da99efa606b6f172dde575a39Mathias Agopian if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) { 1310319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList.add(aSensor); 1320319306670b0344da99efa606b6f172dde575a39Mathias Agopian } 13333264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian 1340319306670b0344da99efa606b6f172dde575a39Mathias Agopian aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) ); 1350319306670b0344da99efa606b6f172dde575a39Mathias Agopian if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) { 1360319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList.add(aSensor); 1370319306670b0344da99efa606b6f172dde575a39Mathias Agopian } 13833264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian 1390319306670b0344da99efa606b6f172dde575a39Mathias Agopian aSensor = registerVirtualSensor( new OrientationSensor() ); 1400319306670b0344da99efa606b6f172dde575a39Mathias Agopian if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 1410319306670b0344da99efa606b6f172dde575a39Mathias Agopian // if we are doing our own rotation-vector, also add 1420319306670b0344da99efa606b6f172dde575a39Mathias Agopian // the orientation sensor and remove the HAL provided one. 1430319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList.replaceAt(aSensor, orientationIndex); 1447b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian } 1450319306670b0344da99efa606b6f172dde575a39Mathias Agopian 1460319306670b0344da99efa606b6f172dde575a39Mathias Agopian // virtual debugging sensors are not added to mUserSensorList 1470319306670b0344da99efa606b6f172dde575a39Mathias Agopian registerVirtualSensor( new CorrectedGyroSensor(list, count) ); 1480319306670b0344da99efa606b6f172dde575a39Mathias Agopian registerVirtualSensor( new GyroDriftSensor() ); 149010e42230135815907e76e5d7e5f30edf9e1799dMathias Agopian } 150010e42230135815907e76e5d7e5f30edf9e1799dMathias Agopian 15133264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian // debugging sensor list 1520319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorListDebug = mSensorList; 15333264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian 1545466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // Check if the device really supports batching by looking at the FIFO event 1555466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // counts for each sensor. 1565466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella bool batchingSupported = false; 1575466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella for (int i = 0; i < mSensorList.size(); ++i) { 1585466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella if (mSensorList[i].getFifoMaxEventCount() > 0) { 1595466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella batchingSupported = true; 1605466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella break; 1615466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella } 1625466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella } 1635466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella 1645466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella if (batchingSupported) { 1655466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // Increase socket buffer size to a max of 100 KB for batching capabilities. 1665466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED; 1675466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella } else { 1685466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED; 1695466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella } 1705466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella 1715466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // Compare the socketBufferSize value against the system limits and limit 1725466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // it to maxSystemSocketBufferSize if necessary. 1734c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r"); 1744c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella char line[128]; 1754c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) { 1764c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella line[sizeof(line) - 1] = '\0'; 1775466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella size_t maxSystemSocketBufferSize; 1785466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella sscanf(line, "%zu", &maxSystemSocketBufferSize); 1795466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella if (mSocketBufferSize > maxSystemSocketBufferSize) { 1805466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella mSocketBufferSize = maxSystemSocketBufferSize; 1814c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 1824c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 1834c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (fp) { 1844c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella fclose(fp); 1854c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 1864c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 1879a844cf78f09953145200b4074d47589257a408cAravind Akella mWakeLockAcquired = false; 18856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mLooper = new Looper(false); 1898493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 1908493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella mSensorEventBuffer = new sensors_event_t[minBufferSize]; 1918493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella mSensorEventScratch = new sensors_event_t[minBufferSize]; 1928493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella mMapFlushEventsToConnections = new SensorEventConnection const * [minBufferSize]; 1937830ef3dd0ff3749d974c2dd85a8fa59dc47aecaAravind Akella 194b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella mAckReceiver = new SensorEventAckReceiver(this); 195b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella mAckReceiver->run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY); 1967b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian mInitCheck = NO_ERROR; 1977830ef3dd0ff3749d974c2dd85a8fa59dc47aecaAravind Akella run("SensorService", PRIORITY_URGENT_DISPLAY); 1987b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian } 199fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 200fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 201fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 2020319306670b0344da99efa606b6f172dde575a39Mathias AgopianSensor SensorService::registerSensor(SensorInterface* s) 203f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian{ 204f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensors_event_t event; 205f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian memset(&event, 0, sizeof(event)); 206f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 207f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian const Sensor sensor(s->getSensor()); 208f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // add to the sensor list (returned to clients) 209f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mSensorList.add(sensor); 210f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // add to our handle->SensorInterface mapping 211f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mSensorMap.add(sensor.getHandle(), s); 212f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // create an entry in the mLastEventSeen array 213f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mLastEventSeen.add(sensor.getHandle(), event); 2140319306670b0344da99efa606b6f172dde575a39Mathias Agopian 2150319306670b0344da99efa606b6f172dde575a39Mathias Agopian return sensor; 216f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian} 217f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 2180319306670b0344da99efa606b6f172dde575a39Mathias AgopianSensor SensorService::registerVirtualSensor(SensorInterface* s) 219f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian{ 2200319306670b0344da99efa606b6f172dde575a39Mathias Agopian Sensor sensor = registerSensor(s); 221f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mVirtualSensorList.add( s ); 2220319306670b0344da99efa606b6f172dde575a39Mathias Agopian return sensor; 223f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian} 224f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 225fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias AgopianSensorService::~SensorService() 226fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 227f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian for (size_t i=0 ; i<mSensorMap.size() ; i++) 228f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian delete mSensorMap.valueAt(i); 229fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 230fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 2311cb13461a8cf62e3ba634e5965332f2d284f6d42Mathias Agopianstatic const String16 sDump("android.permission.DUMP"); 2321cb13461a8cf62e3ba634e5965332f2d284f6d42Mathias Agopian 23392dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzynstatus_t SensorService::dump(int fd, const Vector<String16>& /*args*/) 234fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 235fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian String8 result; 2361cb13461a8cf62e3ba634e5965332f2d284f6d42Mathias Agopian if (!PermissionCache::checkCallingPermission(sDump)) { 237ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat("Permission Denial: " 238700180487ffec09d9df1657b018a7caadac24b75Aravind Akella "can't dump SensorService from pid=%d, uid=%d\n", 239fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian IPCThreadState::self()->getCallingPid(), 240fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian IPCThreadState::self()->getCallingUid()); 241fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } else { 242fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian Mutex::Autolock _l(mLock); 243ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.append("Sensor List:\n"); 2443560fb24b668675627934356f210d84d19bf4e56Mathias Agopian for (size_t i=0 ; i<mSensorList.size() ; i++) { 2453560fb24b668675627934356f210d84d19bf4e56Mathias Agopian const Sensor& s(mSensorList[i]); 2463560fb24b668675627934356f210d84d19bf4e56Mathias Agopian const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle())); 247ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 2480b6acb2231baed861488f2d181621272d0658d25Aravind Akella "%-15s| %-10s| version=%d |%-20s| 0x%08x | \"%s\" | type=%d |", 2493560fb24b668675627934356f210d84d19bf4e56Mathias Agopian s.getName().string(), 2503560fb24b668675627934356f210d84d19bf4e56Mathias Agopian s.getVendor().string(), 2510b6acb2231baed861488f2d181621272d0658d25Aravind Akella s.getVersion(), 252700180487ffec09d9df1657b018a7caadac24b75Aravind Akella s.getStringType().string(), 253700180487ffec09d9df1657b018a7caadac24b75Aravind Akella s.getHandle(), 2546c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella s.getRequiredPermission().string(), 2556c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella s.getType()); 256ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian 2570e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella const int reportingMode = s.getReportingMode(); 2580e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella if (reportingMode == AREPORTING_MODE_CONTINUOUS) { 2596c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.append(" continuous | "); 2600e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella } else if (reportingMode == AREPORTING_MODE_ON_CHANGE) { 2616c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.append(" on-change | "); 2620e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella } else if (reportingMode == AREPORTING_MODE_ONE_SHOT) { 2636c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.append(" one-shot | "); 2640e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella } else { 2656c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.append(" special-trigger | "); 2666c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 2676c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 2686c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (s.getMaxDelay() > 0) { 2696c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.appendFormat("minRate=%.2fHz | ", 1e6f / s.getMaxDelay()); 2706c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } else { 2716c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.appendFormat("maxDelay=%dus |", s.getMaxDelay()); 2720e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella } 2730e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella 274ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian if (s.getMinDelay() > 0) { 2756c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.appendFormat("maxRate=%.2fHz | ", 1e6f / s.getMinDelay()); 276ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian } else { 2776c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.appendFormat("minDelay=%dus |", s.getMinDelay()); 278ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian } 2790e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella 280724d91d778e71c8186399f4955de14b54812b3edAravind Akella if (s.getFifoMaxEventCount() > 0) { 281700180487ffec09d9df1657b018a7caadac24b75Aravind Akella result.appendFormat("FifoMax=%d events | ", 282700180487ffec09d9df1657b018a7caadac24b75Aravind Akella s.getFifoMaxEventCount()); 283724d91d778e71c8186399f4955de14b54812b3edAravind Akella } else { 2846c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.append("no batching | "); 2856c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 2866c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 2876c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (s.isWakeUpSensor()) { 2886c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.appendFormat("wakeUp | "); 2896c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } else { 2906c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.appendFormat("non-wakeUp | "); 291724d91d778e71c8186399f4955de14b54812b3edAravind Akella } 292ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian 293ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian switch (s.getType()) { 294ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_ROTATION_VECTOR: 295ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 296ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 2976c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 2986c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.timestamp); 299ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 300ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 301ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 302ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 3036c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 3046c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.data[5], 3056c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella e.timestamp); 306ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 307ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_GAME_ROTATION_VECTOR: 308ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 3096c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella "last=<%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 3106c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella e.data[0], e.data[1], e.data[2], e.data[3], e.timestamp); 311ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 312ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_SIGNIFICANT_MOTION: 313ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_STEP_DETECTOR: 3146c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.appendFormat( "last=<%f %" PRId64 ">\n", e.data[0], e.timestamp); 315ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 316ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_STEP_COUNTER: 3176c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.appendFormat( "last=<%" PRIu64 ", %" PRId64 ">\n", e.u64.step_counter, 3186c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella e.timestamp); 319ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 320ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian default: 321ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian // default to 3 values 322ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 3236c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella "last=<%5.1f,%5.1f,%5.1f, %" PRId64 ">\n", 3246c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella e.data[0], e.data[1], e.data[2], e.timestamp); 325ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 326ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian } 3276c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella result.append("\n"); 3283560fb24b668675627934356f210d84d19bf4e56Mathias Agopian } 329ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian SensorFusion::getInstance().dump(result); 330ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian SensorDevice::getInstance().dump(result); 331ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian 332ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.append("Active sensors:\n"); 333fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian for (size_t i=0 ; i<mActiveSensors.size() ; i++) { 3345d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian int handle = mActiveSensors.keyAt(i); 33592dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn result.appendFormat("%s (handle=0x%08x, connections=%zu)\n", 3365d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian getSensorName(handle).string(), 3375d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian handle, 338fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mActiveSensors.valueAt(i)->getNumConnections()); 339fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 3404c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 3415466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella result.appendFormat("Socket Buffer size = %d events\n", 3426c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mSocketBufferSize/sizeof(sensors_event_t)); 3439a844cf78f09953145200b4074d47589257a408cAravind Akella result.appendFormat("WakeLock Status: %s \n", mWakeLockAcquired ? "acquired" : "not held"); 34492dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn result.appendFormat("%zd active connections\n", mActiveConnections.size()); 3454c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 3464c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella for (size_t i=0 ; i < mActiveConnections.size() ; i++) { 3474c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 3484c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (connection != 0) { 34992dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn result.appendFormat("Connection Number: %zu \n", i); 3504c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella connection->dump(result); 3514c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 3524c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 353fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 354fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian write(fd, result.string(), result.size()); 355fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return NO_ERROR; 356fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 357fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 3589a844cf78f09953145200b4074d47589257a408cAravind Akellavoid SensorService::cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection, 3594342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh sensors_event_t const* buffer, const int count) { 3604342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh for (int i=0 ; i<count ; i++) { 3614342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh int handle = buffer[i].sensor; 3628493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (buffer[i].type == SENSOR_TYPE_META_DATA) { 3638493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella handle = buffer[i].meta_data.sensor; 3648493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella } 3650e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella if (connection->hasSensor(handle)) { 3660e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella SensorInterface* sensor = mSensorMap.valueFor(handle); 3670e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella // If this buffer has an event from a one_shot sensor and this connection is registered 3680e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella // for this particular one_shot sensor, try cleaning up the connection. 3690e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella if (sensor != NULL && 3700e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 3710e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella sensor->autoDisable(connection.get(), handle); 3729a844cf78f09953145200b4074d47589257a408cAravind Akella cleanupWithoutDisableLocked(connection, handle); 3734342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 3744342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 3754342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 3764342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh} 3774342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 378fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianbool SensorService::threadLoop() 379fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 380a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD("nuSensorService thread starting..."); 381fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 38290ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian // each virtual sensor could generate an event per "real" event, that's why we need 38390ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT. 38490ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian // in practice, this is too aggressive, but guaranteed to be enough. 38590ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 38690ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size()); 38790ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian 388f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian SensorDevice& device(SensorDevice::getInstance()); 389f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian const size_t vcount = mVirtualSensorList.size(); 390fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 3914342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh const int halVersion = device.getHalDeviceVersion(); 392fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian do { 3938493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella ssize_t count = device.poll(mSensorEventBuffer, numEventMax); 3948493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (count < 0) { 395f5a1230d322c14c42331d0a1536b50c87742973bSteve Block ALOGE("sensor poll failed (%s)", strerror(-count)); 396fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian break; 397fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 39856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 39956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Reset sensors_event_t.flags to zero for all events in the buffer. 40056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella for (int i = 0; i < count; i++) { 4018493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella mSensorEventBuffer[i].flags = 0; 40256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 403e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella 404e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella // Make a copy of the connection vector as some connections may be removed during the 405e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella // course of this loop (especially when one-shot sensor events are present in the 406e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella // sensor_event buffer). Promote all connections to StrongPointers before the lock is 407e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella // acquired. If the destructor of the sp gets called when the lock is acquired, it may 408e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella // result in a deadlock as ~SensorEventConnection() needs to acquire mLock again for 409e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella // cleanup. So copy all the strongPointers to a vector before the lock is acquired. 410e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella SortedVector< sp<SensorEventConnection> > activeConnections; 411b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella populateActiveConnections(&activeConnections); 4129a844cf78f09953145200b4074d47589257a408cAravind Akella Mutex::Autolock _l(mLock); 4139a844cf78f09953145200b4074d47589257a408cAravind Akella // Poll has returned. Hold a wakelock if one of the events is from a wake up sensor. The 4149a844cf78f09953145200b4074d47589257a408cAravind Akella // rest of this loop is under a critical section protected by mLock. Acquiring a wakeLock, 4159a844cf78f09953145200b4074d47589257a408cAravind Akella // sending events to clients (incrementing SensorEventConnection::mWakeLockRefCount) should 4169a844cf78f09953145200b4074d47589257a408cAravind Akella // not be interleaved with decrementing SensorEventConnection::mWakeLockRefCount and 4179a844cf78f09953145200b4074d47589257a408cAravind Akella // releasing the wakelock. 4189a844cf78f09953145200b4074d47589257a408cAravind Akella bool bufferHasWakeUpEvent = false; 4194342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh for (int i = 0; i < count; i++) { 4208493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (isWakeUpSensorEvent(mSensorEventBuffer[i])) { 4219a844cf78f09953145200b4074d47589257a408cAravind Akella bufferHasWakeUpEvent = true; 4229a844cf78f09953145200b4074d47589257a408cAravind Akella break; 4234342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 4244342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 4254342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 4269a844cf78f09953145200b4074d47589257a408cAravind Akella if (bufferHasWakeUpEvent && !mWakeLockAcquired) { 427b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella setWakeLockAcquiredLocked(true); 4289a844cf78f09953145200b4074d47589257a408cAravind Akella } 4298493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella recordLastValueLocked(mSensorEventBuffer, count); 43094e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian 431f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // handle virtual sensors 432f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (count && vcount) { 4338493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella sensors_event_t const * const event = mSensorEventBuffer; 4349a844cf78f09953145200b4074d47589257a408cAravind Akella const size_t activeVirtualSensorCount = mActiveVirtualSensors.size(); 435f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (activeVirtualSensorCount) { 436f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian size_t k = 0; 437984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian SensorFusion& fusion(SensorFusion::getInstance()); 438984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian if (fusion.isEnabled()) { 439984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian for (size_t i=0 ; i<size_t(count) ; i++) { 440984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian fusion.process(event[i]); 441984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian } 442984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian } 443d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) { 444f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian for (size_t j=0 ; j<activeVirtualSensorCount ; j++) { 445d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian if (count + k >= minBufferSize) { 446d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian ALOGE("buffer too small to hold all events: " 447db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn "count=%zd, k=%zu, size=%zu", 448d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian count, k, minBufferSize); 449d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian break; 450d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian } 451f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensors_event_t out; 4529a844cf78f09953145200b4074d47589257a408cAravind Akella SensorInterface* si = mActiveVirtualSensors.valueAt(j); 453d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian if (si->process(&out, event[i])) { 4548493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella mSensorEventBuffer[count + k] = out; 455f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian k++; 456f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 457f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 458f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 459f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (k) { 460f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // record the last synthesized values 4618493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella recordLastValueLocked(&mSensorEventBuffer[count], k); 462f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian count += k; 463f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // sort the buffer by time-stamps 4648493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella sortEventBuffer(mSensorEventBuffer, count); 465f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 466f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 467f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 468f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 4694342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // handle backward compatibility for RotationVector sensor 4704342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) { 4714342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh for (int i = 0; i < count; i++) { 4728493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (mSensorEventBuffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) { 4734342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // All the 4 components of the quaternion should be available 4744342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // No heading accuracy. Set it to -1 4758493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella mSensorEventBuffer[i].data[4] = -1; 4768493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella } 4778493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella } 4788493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella } 4798493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella 4808493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // Map flush_complete_events in the buffer to SensorEventConnections which called 4818493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // flush on the hardware sensor. mapFlushEventsToConnections[i] will be the 4828493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // SensorEventConnection mapped to the corresponding flush_complete_event in 4838493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // mSensorEventBuffer[i] if such a mapping exists (NULL otherwise). 4848493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella for (int i = 0; i < count; ++i) { 4858493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella mMapFlushEventsToConnections[i] = NULL; 4868493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (mSensorEventBuffer[i].type == SENSOR_TYPE_META_DATA) { 4878493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella const int sensor_handle = mSensorEventBuffer[i].meta_data.sensor; 4888493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella SensorRecord* rec = mActiveSensors.valueFor(sensor_handle); 4898493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (rec != NULL) { 4908493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella mMapFlushEventsToConnections[i] = rec->getFirstPendingFlushConnection(); 4918493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella rec->removeFirstPendingFlushConnection(); 4924342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 4934342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 4944342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 4954342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 4969a844cf78f09953145200b4074d47589257a408cAravind Akella // Send our events to clients. Check the state of wake lock for each client and release the 4979a844cf78f09953145200b4074d47589257a408cAravind Akella // lock if none of the clients need it. 4989a844cf78f09953145200b4074d47589257a408cAravind Akella bool needsWakeLock = false; 4998493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella size_t numConnections = activeConnections.size(); 5008493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella for (size_t i=0 ; i < numConnections; ++i) { 501e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella if (activeConnections[i] != 0) { 502e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella activeConnections[i]->sendEvents(mSensorEventBuffer, count, mSensorEventScratch, 5038493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella mMapFlushEventsToConnections); 504e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella needsWakeLock |= activeConnections[i]->needsWakeLock(); 5058493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // If the connection has one-shot sensors, it may be cleaned up after first trigger. 5068493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // Early check for one-shot sensors. 507e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella if (activeConnections[i]->hasOneShotSensors()) { 508e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella cleanupAutoDisabledSensorLocked(activeConnections[i], mSensorEventBuffer, 509e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella count); 5108493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella } 511fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 512fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 5134342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 5149a844cf78f09953145200b4074d47589257a408cAravind Akella if (mWakeLockAcquired && !needsWakeLock) { 515b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella setWakeLockAcquiredLocked(false); 5169a844cf78f09953145200b4074d47589257a408cAravind Akella } 5178493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella } while (!Thread::exitPending()); 518fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 5193c20fbed7f3a916ced10f2ed5a272271b7d81edeSteve Block ALOGW("Exiting SensorService::threadLoop => aborting..."); 5201a62301fc58cd2af18239b0415813461bf5fc41bMathias Agopian abort(); 521fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return false; 522fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 523fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 52456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellasp<Looper> SensorService::getLooper() const { 52556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return mLooper; 52656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella} 52756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 528b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akellavoid SensorService::resetAllWakeLockRefCounts() { 529b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella SortedVector< sp<SensorEventConnection> > activeConnections; 530b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella populateActiveConnections(&activeConnections); 531b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella { 532b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella Mutex::Autolock _l(mLock); 533b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella for (size_t i=0 ; i < activeConnections.size(); ++i) { 534b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (activeConnections[i] != 0) { 535b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella activeConnections[i]->resetWakeLockRefCount(); 536b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 537b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 538b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella setWakeLockAcquiredLocked(false); 539b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 540b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella} 541b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella 542b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akellavoid SensorService::setWakeLockAcquiredLocked(bool acquire) { 543b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (acquire) { 544b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (!mWakeLockAcquired) { 545b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 546b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella mWakeLockAcquired = true; 547b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 548b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella mLooper->wake(); 549b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } else { 550b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (mWakeLockAcquired) { 551b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella release_wake_lock(WAKE_LOCK_NAME); 552b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella mWakeLockAcquired = false; 553b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 554b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 555b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella} 556b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella 557b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella 558b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akellabool SensorService::isWakeLockAcquired() { 559b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella Mutex::Autolock _l(mLock); 560b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella return mWakeLockAcquired; 561b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella} 562b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella 56356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellabool SensorService::SensorEventAckReceiver::threadLoop() { 56456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOGD("new thread SensorEventAckReceiver"); 565b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella sp<Looper> looper = mService->getLooper(); 56656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella do { 567b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella bool wakeLockAcquired = mService->isWakeLockAcquired(); 568b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella int timeout = -1; 569b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (wakeLockAcquired) timeout = 5000; 570b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella int ret = looper->pollOnce(timeout); 571b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (ret == ALOOPER_POLL_TIMEOUT) { 572b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella mService->resetAllWakeLockRefCounts(); 573b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 57456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } while(!Thread::exitPending()); 57556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return false; 57656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella} 57756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 5789a844cf78f09953145200b4074d47589257a408cAravind Akellavoid SensorService::recordLastValueLocked( 5794b84704b97300eff3ebfab85652e64d54149d205Aravind Akella const sensors_event_t* buffer, size_t count) { 5804b84704b97300eff3ebfab85652e64d54149d205Aravind Akella const sensors_event_t* last = NULL; 5814b84704b97300eff3ebfab85652e64d54149d205Aravind Akella for (size_t i = 0; i < count; i++) { 5824b84704b97300eff3ebfab85652e64d54149d205Aravind Akella const sensors_event_t* event = &buffer[i]; 5834b84704b97300eff3ebfab85652e64d54149d205Aravind Akella if (event->type != SENSOR_TYPE_META_DATA) { 5844b84704b97300eff3ebfab85652e64d54149d205Aravind Akella if (last && event->sensor != last->sensor) { 5854b84704b97300eff3ebfab85652e64d54149d205Aravind Akella mLastEventSeen.editValueFor(last->sensor) = *last; 5864b84704b97300eff3ebfab85652e64d54149d205Aravind Akella } 5874b84704b97300eff3ebfab85652e64d54149d205Aravind Akella last = event; 58894e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian } 58994e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian } 5904b84704b97300eff3ebfab85652e64d54149d205Aravind Akella if (last) { 5914b84704b97300eff3ebfab85652e64d54149d205Aravind Akella mLastEventSeen.editValueFor(last->sensor) = *last; 5924b84704b97300eff3ebfab85652e64d54149d205Aravind Akella } 59394e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian} 59494e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian 595f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopianvoid SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count) 596f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian{ 597f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian struct compar { 598f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian static int cmp(void const* lhs, void const* rhs) { 599f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs); 600f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs); 601a5c106a4f0afcf061728a1cb7c8c3b908728575dMathias Agopian return l->timestamp - r->timestamp; 602f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 603f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian }; 604f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian qsort(buffer, count, sizeof(sensors_event_t), compar::cmp); 605f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian} 606f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 6075d2707214dfb97bd8dfcc6620be36841d3c82420Mathias AgopianString8 SensorService::getSensorName(int handle) const { 608010e42230135815907e76e5d7e5f30edf9e1799dMathias Agopian size_t count = mUserSensorList.size(); 6095d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian for (size_t i=0 ; i<count ; i++) { 610010e42230135815907e76e5d7e5f30edf9e1799dMathias Agopian const Sensor& sensor(mUserSensorList[i]); 6115d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian if (sensor.getHandle() == handle) { 6125d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian return sensor.getName(); 6135d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian } 6145d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian } 6155d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian String8 result("unknown"); 6165d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian return result; 6175d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian} 6185d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian 619b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akellabool SensorService::isVirtualSensor(int handle) const { 620b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akella SensorInterface* sensor = mSensorMap.valueFor(handle); 621b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akella return sensor->isVirtual(); 622b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akella} 623b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akella 6249a844cf78f09953145200b4074d47589257a408cAravind Akellabool SensorService::isWakeUpSensorEvent(const sensors_event_t& event) const { 6257869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan int handle = event.sensor; 6267869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan if (event.type == SENSOR_TYPE_META_DATA) { 6277869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan handle = event.meta_data.sensor; 6287869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan } 6297869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan SensorInterface* sensor = mSensorMap.valueFor(handle); 6307869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan return sensor != NULL && sensor->getSensor().isWakeUpSensor(); 6319a844cf78f09953145200b4074d47589257a408cAravind Akella} 6329a844cf78f09953145200b4074d47589257a408cAravind Akella 6336c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 6346c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind AkellaSensorService::SensorRecord * SensorService::getSensorRecord(int handle) { 6356c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella return mActiveSensors.valueFor(handle); 6366c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella} 6376c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 638fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias AgopianVector<Sensor> SensorService::getSensorList() 639fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 64033264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian char value[PROPERTY_VALUE_MAX]; 64133264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian property_get("debug.sensors", value, "0"); 642700180487ffec09d9df1657b018a7caadac24b75Aravind Akella const Vector<Sensor>& initialSensorList = (atoi(value)) ? 643700180487ffec09d9df1657b018a7caadac24b75Aravind Akella mUserSensorListDebug : mUserSensorList; 644700180487ffec09d9df1657b018a7caadac24b75Aravind Akella Vector<Sensor> accessibleSensorList; 645700180487ffec09d9df1657b018a7caadac24b75Aravind Akella for (size_t i = 0; i < initialSensorList.size(); i++) { 646700180487ffec09d9df1657b018a7caadac24b75Aravind Akella Sensor sensor = initialSensorList[i]; 647700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (canAccessSensor(sensor)) { 648700180487ffec09d9df1657b018a7caadac24b75Aravind Akella accessibleSensorList.add(sensor); 649700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } else { 650700180487ffec09d9df1657b018a7caadac24b75Aravind Akella String8 infoMessage; 651700180487ffec09d9df1657b018a7caadac24b75Aravind Akella infoMessage.appendFormat( 652700180487ffec09d9df1657b018a7caadac24b75Aravind Akella "Skipped sensor %s because it requires permission %s", 653700180487ffec09d9df1657b018a7caadac24b75Aravind Akella sensor.getName().string(), 654700180487ffec09d9df1657b018a7caadac24b75Aravind Akella sensor.getRequiredPermission().string()); 655700180487ffec09d9df1657b018a7caadac24b75Aravind Akella ALOGI(infoMessage.string()); 656700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 65733264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian } 658700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return accessibleSensorList; 659fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 660fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 661fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopiansp<ISensorEventConnection> SensorService::createSensorEventConnection() 662fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 6635307d17fe33fc26eeeacd6339a9fbfe96cf56873Mathias Agopian uid_t uid = IPCThreadState::self()->getCallingUid(); 6645307d17fe33fc26eeeacd6339a9fbfe96cf56873Mathias Agopian sp<SensorEventConnection> result(new SensorEventConnection(this, uid)); 665fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return result; 666fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 667fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 668db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopianvoid SensorService::cleanupConnection(SensorEventConnection* c) 669fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 670fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian Mutex::Autolock _l(mLock); 671db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian const wp<SensorEventConnection> connection(c); 6727c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian size_t size = mActiveSensors.size(); 673db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn ALOGD_IF(DEBUG_CONNECTIONS, "%zu active sensors", size); 6747c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian for (size_t i=0 ; i<size ; ) { 675db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian int handle = mActiveSensors.keyAt(i); 676db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian if (c->hasSensor(handle)) { 677db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn ALOGD_IF(DEBUG_CONNECTIONS, "%zu: disabling handle=0x%08x", i, handle); 678f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian SensorInterface* sensor = mSensorMap.valueFor( handle ); 679f5a1230d322c14c42331d0a1536b50c87742973bSteve Block ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle); 680f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (sensor) { 681db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian sensor->activate(c, false); 682f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 6838a96955c8e14db40b16164236830fc9506a00872Aravind Akella c->removeSensor(handle); 684db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian } 685db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian SensorRecord* rec = mActiveSensors.valueAt(i); 686db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn ALOGE_IF(!rec, "mActiveSensors[%zu] is null (handle=0x%08x)!", i, handle); 687a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD_IF(DEBUG_CONNECTIONS, 688db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn "removing connection %p for sensor[%zu].handle=0x%08x", 689a1b7db95b6ccf5be9d8dfaac1b8f45494813edc0Mathias Agopian c, i, handle); 690a1b7db95b6ccf5be9d8dfaac1b8f45494813edc0Mathias Agopian 691db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian if (rec && rec->removeConnection(connection)) { 692a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD_IF(DEBUG_CONNECTIONS, "... and it was the last connection"); 6937c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian mActiveSensors.removeItemsAt(i, 1); 694f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mActiveVirtualSensors.removeItem(handle); 6957c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian delete rec; 6967c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian size--; 6977c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian } else { 6987c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian i++; 699fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 700fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 7018a96955c8e14db40b16164236830fc9506a00872Aravind Akella c->updateLooperRegistration(mLooper); 7027c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian mActiveConnections.remove(connection); 703787ac1b388f144f5e6dd38f8b807866a5256dafcMathias Agopian BatteryService::cleanup(c->getUid()); 7049a844cf78f09953145200b4074d47589257a408cAravind Akella if (c->needsWakeLock()) { 7059a844cf78f09953145200b4074d47589257a408cAravind Akella checkWakeLockStateLocked(); 7069a844cf78f09953145200b4074d47589257a408cAravind Akella } 707fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 708fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 709700180487ffec09d9df1657b018a7caadac24b75Aravind AkellaSensor SensorService::getSensorFromHandle(int handle) const { 710700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return mSensorMap.valueFor(handle)->getSensor(); 711700180487ffec09d9df1657b018a7caadac24b75Aravind Akella} 712700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 713fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::enable(const sp<SensorEventConnection>& connection, 714724d91d778e71c8186399f4955de14b54812b3edAravind Akella int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags) 715fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 71650df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian if (mInitCheck != NO_ERROR) 71750df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian return mInitCheck; 71850df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian 719f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian SensorInterface* sensor = mSensorMap.valueFor(handle); 720ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian if (sensor == NULL) { 721ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian return BAD_VALUE; 722ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian } 723700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 724700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (!verifyCanAccessSensor(sensor->getSensor(), "Tried enabling")) { 725700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return BAD_VALUE; 726700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 727700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 728ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian Mutex::Autolock _l(mLock); 7294342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh SensorRecord* rec = mActiveSensors.valueFor(handle); 7304342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (rec == 0) { 7314342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh rec = new SensorRecord(connection); 7324342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh mActiveSensors.add(handle, rec); 7334342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (sensor->isVirtual()) { 7344342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh mActiveVirtualSensors.add(handle, sensor); 7353560fb24b668675627934356f210d84d19bf4e56Mathias Agopian } 7364342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } else { 7374342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (rec->addConnection(connection)) { 7389a844cf78f09953145200b4074d47589257a408cAravind Akella // this sensor is already activated, but we are adding a connection that uses it. 7399a844cf78f09953145200b4074d47589257a408cAravind Akella // Immediately send down the last known value of the requested sensor if it's not a 7404342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // "continuous" sensor. 7410e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ON_CHANGE) { 7429a844cf78f09953145200b4074d47589257a408cAravind Akella // NOTE: The wake_up flag of this event may get set to 7439a844cf78f09953145200b4074d47589257a408cAravind Akella // WAKE_UP_SENSOR_EVENT_NEEDS_ACK if this is a wake_up event. 7444342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh sensors_event_t& event(mLastEventSeen.editValueFor(handle)); 7454342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (event.version == sizeof(sensors_event_t)) { 7469a844cf78f09953145200b4074d47589257a408cAravind Akella if (isWakeUpSensorEvent(event) && !mWakeLockAcquired) { 747b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella setWakeLockAcquiredLocked(true); 7489a844cf78f09953145200b4074d47589257a408cAravind Akella } 7499a844cf78f09953145200b4074d47589257a408cAravind Akella connection->sendEvents(&event, 1, NULL); 7509a844cf78f09953145200b4074d47589257a408cAravind Akella if (!connection->needsWakeLock() && mWakeLockAcquired) { 7519a844cf78f09953145200b4074d47589257a408cAravind Akella checkWakeLockStateLocked(); 7529a844cf78f09953145200b4074d47589257a408cAravind Akella } 753f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 7547c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian } 755fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 756fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 7574342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 7584342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (connection->addSensor(handle)) { 7594342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh BatteryService::enableSensor(connection->getUid(), handle); 7604342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // the sensor was added (which means it wasn't already there) 7614342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // so, see if this connection becomes active 7624342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (mActiveConnections.indexOf(connection) < 0) { 7634342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh mActiveConnections.add(connection); 7644342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 7654342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } else { 7664342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh ALOGW("sensor %08x already enabled in connection %p (ignoring)", 7674342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh handle, connection.get()); 7684342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 7694342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 770724d91d778e71c8186399f4955de14b54812b3edAravind Akella nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 771724d91d778e71c8186399f4955de14b54812b3edAravind Akella if (samplingPeriodNs < minDelayNs) { 772724d91d778e71c8186399f4955de14b54812b3edAravind Akella samplingPeriodNs = minDelayNs; 773724d91d778e71c8186399f4955de14b54812b3edAravind Akella } 774724d91d778e71c8186399f4955de14b54812b3edAravind Akella 7756c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d" 7766c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella "rate=%" PRId64 " timeout== %" PRId64"", 777724d91d778e71c8186399f4955de14b54812b3edAravind Akella handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs); 778724d91d778e71c8186399f4955de14b54812b3edAravind Akella 779724d91d778e71c8186399f4955de14b54812b3edAravind Akella status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs, 780724d91d778e71c8186399f4955de14b54812b3edAravind Akella maxBatchReportLatencyNs); 7816c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 7825466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // Call flush() before calling activate() on the sensor. Wait for a first flush complete 7835466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // event before sending events on this connection. Ignore one-shot sensors which don't 7845466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // support flush(). Also if this sensor isn't already active, don't call flush(). 7855466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella if (err == NO_ERROR && sensor->getSensor().getReportingMode() != AREPORTING_MODE_ONE_SHOT && 7865466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella rec->getNumConnections() > 1) { 7875466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella connection->setFirstFlushPending(handle, true); 7884c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella status_t err_flush = sensor->flush(connection.get(), handle); 7895466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // Flush may return error if the underlying h/w sensor uses an older HAL. 7906c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (err_flush == NO_ERROR) { 7916c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella rec->addPendingFlushConnection(connection.get()); 7925466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella } else { 7935466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella connection->setFirstFlushPending(handle, false); 7944c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 7954c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 796724d91d778e71c8186399f4955de14b54812b3edAravind Akella 797724d91d778e71c8186399f4955de14b54812b3edAravind Akella if (err == NO_ERROR) { 798724d91d778e71c8186399f4955de14b54812b3edAravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle); 799724d91d778e71c8186399f4955de14b54812b3edAravind Akella err = sensor->activate(connection.get(), true); 800724d91d778e71c8186399f4955de14b54812b3edAravind Akella } 801724d91d778e71c8186399f4955de14b54812b3edAravind Akella 8028a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (err == NO_ERROR) { 8038a96955c8e14db40b16164236830fc9506a00872Aravind Akella connection->updateLooperRegistration(mLooper); 80456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 80556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 8064342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (err != NO_ERROR) { 807724d91d778e71c8186399f4955de14b54812b3edAravind Akella // batch/activate has failed, reset our state. 808ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian cleanupWithoutDisableLocked(connection, handle); 8094342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 810fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return err; 811fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 812fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 813fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::disable(const sp<SensorEventConnection>& connection, 814fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian int handle) 815fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 81650df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian if (mInitCheck != NO_ERROR) 81750df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian return mInitCheck; 81850df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian 819ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian Mutex::Autolock _l(mLock); 820ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian status_t err = cleanupWithoutDisableLocked(connection, handle); 8214342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (err == NO_ERROR) { 8224342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh SensorInterface* sensor = mSensorMap.valueFor(handle); 8234342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE); 8244342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 8254342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh return err; 8264342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh} 8274342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 828ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopianstatus_t SensorService::cleanupWithoutDisable( 829ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian const sp<SensorEventConnection>& connection, int handle) { 830fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian Mutex::Autolock _l(mLock); 831ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian return cleanupWithoutDisableLocked(connection, handle); 832ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian} 833ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian 834ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopianstatus_t SensorService::cleanupWithoutDisableLocked( 835ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian const sp<SensorEventConnection>& connection, int handle) { 836fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian SensorRecord* rec = mActiveSensors.valueFor(handle); 837fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (rec) { 838fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian // see if this connection becomes inactive 839787ac1b388f144f5e6dd38f8b807866a5256dafcMathias Agopian if (connection->removeSensor(handle)) { 840787ac1b388f144f5e6dd38f8b807866a5256dafcMathias Agopian BatteryService::disableSensor(connection->getUid(), handle); 841787ac1b388f144f5e6dd38f8b807866a5256dafcMathias Agopian } 842fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (connection->hasAnySensor() == false) { 8438a96955c8e14db40b16164236830fc9506a00872Aravind Akella connection->updateLooperRegistration(mLooper); 844fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mActiveConnections.remove(connection); 845fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 846fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian // see if this sensor becomes inactive 847fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (rec->removeConnection(connection)) { 848fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mActiveSensors.removeItem(handle); 849f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mActiveVirtualSensors.removeItem(handle); 850fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian delete rec; 851fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 8524342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh return NO_ERROR; 8537c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian } 8544342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh return BAD_VALUE; 855fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 856fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 8577c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopianstatus_t SensorService::setEventRate(const sp<SensorEventConnection>& connection, 858fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian int handle, nsecs_t ns) 859fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 86050df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian if (mInitCheck != NO_ERROR) 86150df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian return mInitCheck; 86250df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian 863ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian SensorInterface* sensor = mSensorMap.valueFor(handle); 864ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian if (!sensor) 865ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian return BAD_VALUE; 866ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian 867700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) { 868700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return BAD_VALUE; 869700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 870700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 8711cd700015318727d6d42236ab6274f1949fb08baMathias Agopian if (ns < 0) 8721cd700015318727d6d42236ab6274f1949fb08baMathias Agopian return BAD_VALUE; 8731cd700015318727d6d42236ab6274f1949fb08baMathias Agopian 87462569ecf526c7c01cb68ea461c6bbd3cb26057d2Mathias Agopian nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 87562569ecf526c7c01cb68ea461c6bbd3cb26057d2Mathias Agopian if (ns < minDelayNs) { 87662569ecf526c7c01cb68ea461c6bbd3cb26057d2Mathias Agopian ns = minDelayNs; 877ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian } 878ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian 879f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian return sensor->setDelay(connection.get(), handle, ns); 880fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 881fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 8829e3adfcebf28c5c76085108dffe98c74df56857dAravind Akellastatus_t SensorService::flushSensor(const sp<SensorEventConnection>& connection) { 883700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (mInitCheck != NO_ERROR) return mInitCheck; 8849e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella SensorDevice& dev(SensorDevice::getInstance()); 8859e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella const int halVersion = dev.getHalDeviceVersion(); 8869e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella status_t err(NO_ERROR); 8879e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella Mutex::Autolock _l(mLock); 8889e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella // Loop through all sensors for this connection and call flush on each of them. 8899e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella for (size_t i = 0; i < connection->mSensorInfo.size(); ++i) { 8909e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella const int handle = connection->mSensorInfo.keyAt(i); 8919e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella SensorInterface* sensor = mSensorMap.valueFor(handle); 8929e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 8939e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella ALOGE("flush called on a one-shot sensor"); 8949e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella err = INVALID_OPERATION; 8959e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella continue; 8969e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella } 8978493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (halVersion <= SENSORS_DEVICE_API_VERSION_1_0 || isVirtualSensor(handle)) { 8989e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella // For older devices just increment pending flush count which will send a trivial 8999e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella // flush complete event. 9008a96955c8e14db40b16164236830fc9506a00872Aravind Akella connection->incrementPendingFlushCount(handle); 9019e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella } else { 9029e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella status_t err_flush = sensor->flush(connection.get(), handle); 9039e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella if (err_flush == NO_ERROR) { 9049e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella SensorRecord* rec = mActiveSensors.valueFor(handle); 9059e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella if (rec != NULL) rec->addPendingFlushConnection(connection); 9069e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella } 9079e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella err = (err_flush != NO_ERROR) ? err_flush : err; 9089e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella } 9096c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 9109e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella return err; 911700180487ffec09d9df1657b018a7caadac24b75Aravind Akella} 912700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 913700180487ffec09d9df1657b018a7caadac24b75Aravind Akellabool SensorService::canAccessSensor(const Sensor& sensor) { 91456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return (sensor.getRequiredPermission().isEmpty()) || 91556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella PermissionCache::checkCallingPermission(String16(sensor.getRequiredPermission())); 916724d91d778e71c8186399f4955de14b54812b3edAravind Akella} 917700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 918700180487ffec09d9df1657b018a7caadac24b75Aravind Akellabool SensorService::verifyCanAccessSensor(const Sensor& sensor, const char* operation) { 919700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (canAccessSensor(sensor)) { 920700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return true; 921700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } else { 922700180487ffec09d9df1657b018a7caadac24b75Aravind Akella String8 errorMessage; 923700180487ffec09d9df1657b018a7caadac24b75Aravind Akella errorMessage.appendFormat( 924700180487ffec09d9df1657b018a7caadac24b75Aravind Akella "%s a sensor (%s) without holding its required permission: %s", 925700180487ffec09d9df1657b018a7caadac24b75Aravind Akella operation, 926700180487ffec09d9df1657b018a7caadac24b75Aravind Akella sensor.getName().string(), 927700180487ffec09d9df1657b018a7caadac24b75Aravind Akella sensor.getRequiredPermission().string()); 928700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return false; 929700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 930700180487ffec09d9df1657b018a7caadac24b75Aravind Akella} 931700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 9329a844cf78f09953145200b4074d47589257a408cAravind Akellavoid SensorService::checkWakeLockState() { 9339a844cf78f09953145200b4074d47589257a408cAravind Akella Mutex::Autolock _l(mLock); 9349a844cf78f09953145200b4074d47589257a408cAravind Akella checkWakeLockStateLocked(); 9359a844cf78f09953145200b4074d47589257a408cAravind Akella} 9369a844cf78f09953145200b4074d47589257a408cAravind Akella 9379a844cf78f09953145200b4074d47589257a408cAravind Akellavoid SensorService::checkWakeLockStateLocked() { 9389a844cf78f09953145200b4074d47589257a408cAravind Akella if (!mWakeLockAcquired) { 9399a844cf78f09953145200b4074d47589257a408cAravind Akella return; 9409a844cf78f09953145200b4074d47589257a408cAravind Akella } 9419a844cf78f09953145200b4074d47589257a408cAravind Akella bool releaseLock = true; 9429a844cf78f09953145200b4074d47589257a408cAravind Akella for (size_t i=0 ; i<mActiveConnections.size() ; i++) { 9439a844cf78f09953145200b4074d47589257a408cAravind Akella sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 9449a844cf78f09953145200b4074d47589257a408cAravind Akella if (connection != 0) { 9459a844cf78f09953145200b4074d47589257a408cAravind Akella if (connection->needsWakeLock()) { 9469a844cf78f09953145200b4074d47589257a408cAravind Akella releaseLock = false; 9479a844cf78f09953145200b4074d47589257a408cAravind Akella break; 9489a844cf78f09953145200b4074d47589257a408cAravind Akella } 9499a844cf78f09953145200b4074d47589257a408cAravind Akella } 9509a844cf78f09953145200b4074d47589257a408cAravind Akella } 9519a844cf78f09953145200b4074d47589257a408cAravind Akella if (releaseLock) { 952b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella setWakeLockAcquiredLocked(false); 953b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 954b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella} 955b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella 956b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akellavoid SensorService::sendEventsFromCache(const sp<SensorEventConnection>& connection) { 957b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella Mutex::Autolock _l(mLock); 958b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella connection->writeToSocketFromCache(); 959b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (connection->needsWakeLock()) { 960b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella setWakeLockAcquiredLocked(true); 961b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 962b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella} 963b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella 964b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akellavoid SensorService::populateActiveConnections( 965b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella SortedVector< sp<SensorEventConnection> >* activeConnections) { 966b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella Mutex::Autolock _l(mLock); 967b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella for (size_t i=0 ; i < mActiveConnections.size(); ++i) { 968b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 969b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (connection != 0) { 970b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella activeConnections->add(connection); 971b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella } 9729a844cf78f09953145200b4074d47589257a408cAravind Akella } 9739a844cf78f09953145200b4074d47589257a408cAravind Akella} 9746c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 975fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian// --------------------------------------------------------------------------- 976fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias AgopianSensorService::SensorRecord::SensorRecord( 977fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian const sp<SensorEventConnection>& connection) 978fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 979fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mConnections.add(connection); 980fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 981fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 9827c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopianbool SensorService::SensorRecord::addConnection( 983fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian const sp<SensorEventConnection>& connection) 984fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 985fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (mConnections.indexOf(connection) < 0) { 986fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mConnections.add(connection); 9877c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return true; 988fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 9897c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return false; 990fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 991fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 992fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianbool SensorService::SensorRecord::removeConnection( 993fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian const wp<SensorEventConnection>& connection) 994fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 995fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian ssize_t index = mConnections.indexOf(connection); 996fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (index >= 0) { 997fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mConnections.removeItemsAt(index, 1); 998fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 9996c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // Remove this connections from the queue of flush() calls made on this sensor. 10006c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella for (Vector< wp<SensorEventConnection> >::iterator it = 10016c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mPendingFlushConnections.begin(); it != mPendingFlushConnections.end();) { 10028a96955c8e14db40b16164236830fc9506a00872Aravind Akella 10036c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (it->unsafe_get() == connection.unsafe_get()) { 10046c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella it = mPendingFlushConnections.erase(it); 10056c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } else { 10066c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ++it; 10076c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 10086c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 1009fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return mConnections.size() ? false : true; 1010fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1011fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 10126c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akellavoid SensorService::SensorRecord::addPendingFlushConnection( 10136c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella const sp<SensorEventConnection>& connection) { 10146c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mPendingFlushConnections.add(connection); 10156c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella} 10166c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 10176c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akellavoid SensorService::SensorRecord::removeFirstPendingFlushConnection() { 10186c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (mPendingFlushConnections.size() > 0) { 10196c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mPendingFlushConnections.removeAt(0); 10206c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 10216c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella} 10226c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 10236c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind AkellaSensorService::SensorEventConnection * 10246c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind AkellaSensorService::SensorRecord::getFirstPendingFlushConnection() { 10256c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (mPendingFlushConnections.size() > 0) { 10266c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella return mPendingFlushConnections[0].unsafe_get(); 10276c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 10286c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella return NULL; 10296c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella} 10306c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 1031fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian// --------------------------------------------------------------------------- 1032fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1033fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias AgopianSensorService::SensorEventConnection::SensorEventConnection( 10345307d17fe33fc26eeeacd6339a9fbfe96cf56873Mathias Agopian const sp<SensorService>& service, uid_t uid) 10358a96955c8e14db40b16164236830fc9506a00872Aravind Akella : mService(service), mUid(uid), mWakeLockRefCount(0), mHasLooperCallbacks(false), 10368a96955c8e14db40b16164236830fc9506a00872Aravind Akella mDead(false), mEventCache(NULL), mCacheSize(0), mMaxCacheSize(0) { 10375466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella mChannel = new BitTube(mService->mSocketBufferSize); 103856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 103956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsReceived = mEventsSentFromCache = mEventsSent = 0; 1040e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella mTotalAcksNeeded = mTotalAcksReceived = 0; 104156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 1042fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1043fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 104456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind AkellaSensorService::SensorEventConnection::~SensorEventConnection() { 1045a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this); 1046e148bc29c27ae7a346fa686fdda6425ba202d97aAravind Akella mService->cleanupConnection(this); 104756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mEventCache != NULL) { 104856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella delete mEventCache; 104956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 1050fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1051fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 105256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellavoid SensorService::SensorEventConnection::onFirstRef() { 105356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella LooperCallback::onFirstRef(); 1054fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1055fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 10569a844cf78f09953145200b4074d47589257a408cAravind Akellabool SensorService::SensorEventConnection::needsWakeLock() { 10579a844cf78f09953145200b4074d47589257a408cAravind Akella Mutex::Autolock _l(mConnectionLock); 10588a96955c8e14db40b16164236830fc9506a00872Aravind Akella return !mDead && mWakeLockRefCount > 0; 10599a844cf78f09953145200b4074d47589257a408cAravind Akella} 10609a844cf78f09953145200b4074d47589257a408cAravind Akella 1061b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akellavoid SensorService::SensorEventConnection::resetWakeLockRefCount() { 1062b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella Mutex::Autolock _l(mConnectionLock); 1063b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella mWakeLockRefCount = 0; 1064b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella} 1065b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella 10664c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akellavoid SensorService::SensorEventConnection::dump(String8& result) { 10674c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella Mutex::Autolock _l(mConnectionLock); 10680ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella result.appendFormat("\t WakeLockRefCount %d | uid %d | cache size %d | max cache size %d\n", 10690ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella mWakeLockRefCount, mUid, mCacheSize, mMaxCacheSize); 10704c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella for (size_t i = 0; i < mSensorInfo.size(); ++i) { 10714c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella const FlushInfo& flushInfo = mSensorInfo.valueAt(i); 10720ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella result.appendFormat("\t %s 0x%08x | status: %s | pending flush events %d \n", 10734c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella mService->getSensorName(mSensorInfo.keyAt(i)).string(), 10746c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mSensorInfo.keyAt(i), 10754c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushInfo.mFirstFlushPending ? "First flush pending" : 10764c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella "active", 10770ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella flushInfo.mPendingFlushEventsToSend); 10780ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella } 107956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 10800ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d |" 10810ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella " total_acks_needed %d | total_acks_recvd %d\n", 10820ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella mEventsReceived, 10830ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella mEventsSent, 10840ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella mEventsSentFromCache, 10850ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella mEventsReceived - (mEventsSentFromCache + mEventsSent + mCacheSize), 10860ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella mTotalAcksNeeded, 10870ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella mTotalAcksReceived); 108856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 10894c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella} 10904c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 10917c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopianbool SensorService::SensorEventConnection::addSensor(int32_t handle) { 109271d7a5c289c6ef6b5fc86dd4784a075ca6470e38Mathias Agopian Mutex::Autolock _l(mConnectionLock); 1093700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) { 1094700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return false; 1095700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 10964c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (mSensorInfo.indexOfKey(handle) < 0) { 10974c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella mSensorInfo.add(handle, FlushInfo()); 10987c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return true; 1099fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 11007c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return false; 1101fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1102fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 11037c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopianbool SensorService::SensorEventConnection::removeSensor(int32_t handle) { 110471d7a5c289c6ef6b5fc86dd4784a075ca6470e38Mathias Agopian Mutex::Autolock _l(mConnectionLock); 11054c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (mSensorInfo.removeItem(handle) >= 0) { 11067c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return true; 11077c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian } 11087c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return false; 1109fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1110fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1111fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianbool SensorService::SensorEventConnection::hasSensor(int32_t handle) const { 111271d7a5c289c6ef6b5fc86dd4784a075ca6470e38Mathias Agopian Mutex::Autolock _l(mConnectionLock); 11134c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella return mSensorInfo.indexOfKey(handle) >= 0; 1114fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1115fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1116fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianbool SensorService::SensorEventConnection::hasAnySensor() const { 111771d7a5c289c6ef6b5fc86dd4784a075ca6470e38Mathias Agopian Mutex::Autolock _l(mConnectionLock); 11187c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return mSensorInfo.size() ? true : false; 11197c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian} 11207c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian 11218493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akellabool SensorService::SensorEventConnection::hasOneShotSensors() const { 11228493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella Mutex::Autolock _l(mConnectionLock); 11238493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella for (size_t i = 0; i < mSensorInfo.size(); ++i) { 11248493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella const int handle = mSensorInfo.keyAt(i); 11258493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (mService->getSensorFromHandle(handle).getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 11268493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella return true; 11278493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella } 11288493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella } 11298493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella return false; 11308493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella} 11318493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella 11324c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akellavoid SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle, 11334c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella bool value) { 11344c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella Mutex::Autolock _l(mConnectionLock); 11354c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ssize_t index = mSensorInfo.indexOfKey(handle); 11364c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (index >= 0) { 11374c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 11384c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushInfo.mFirstFlushPending = value; 11394c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 11404c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella} 11414c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 11428a96955c8e14db40b16164236830fc9506a00872Aravind Akellavoid SensorService::SensorEventConnection::updateLooperRegistration(const sp<Looper>& looper) { 11438a96955c8e14db40b16164236830fc9506a00872Aravind Akella Mutex::Autolock _l(mConnectionLock); 11448a96955c8e14db40b16164236830fc9506a00872Aravind Akella updateLooperRegistrationLocked(looper); 11458a96955c8e14db40b16164236830fc9506a00872Aravind Akella} 11468a96955c8e14db40b16164236830fc9506a00872Aravind Akella 11478a96955c8e14db40b16164236830fc9506a00872Aravind Akellavoid SensorService::SensorEventConnection::updateLooperRegistrationLocked( 11488a96955c8e14db40b16164236830fc9506a00872Aravind Akella const sp<Looper>& looper) { 11498a96955c8e14db40b16164236830fc9506a00872Aravind Akella bool isConnectionActive = mSensorInfo.size() > 0; 11508a96955c8e14db40b16164236830fc9506a00872Aravind Akella // If all sensors are unregistered OR Looper has encountered an error, we 11518a96955c8e14db40b16164236830fc9506a00872Aravind Akella // can remove the Fd from the Looper if it has been previously added. 11528a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (!isConnectionActive || mDead) { 11538a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (mHasLooperCallbacks) { 11548a96955c8e14db40b16164236830fc9506a00872Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "%p removeFd fd=%d", this, mChannel->getSendFd()); 11558a96955c8e14db40b16164236830fc9506a00872Aravind Akella looper->removeFd(mChannel->getSendFd()); 11568a96955c8e14db40b16164236830fc9506a00872Aravind Akella mHasLooperCallbacks = false; 11578a96955c8e14db40b16164236830fc9506a00872Aravind Akella } 11588a96955c8e14db40b16164236830fc9506a00872Aravind Akella return; 11598a96955c8e14db40b16164236830fc9506a00872Aravind Akella } 11608a96955c8e14db40b16164236830fc9506a00872Aravind Akella 11618a96955c8e14db40b16164236830fc9506a00872Aravind Akella int looper_flags = 0; 11628a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (mCacheSize > 0) looper_flags |= ALOOPER_EVENT_OUTPUT; 11638a96955c8e14db40b16164236830fc9506a00872Aravind Akella for (size_t i = 0; i < mSensorInfo.size(); ++i) { 11648a96955c8e14db40b16164236830fc9506a00872Aravind Akella const int handle = mSensorInfo.keyAt(i); 11658a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (mService->getSensorFromHandle(handle).isWakeUpSensor()) { 11668a96955c8e14db40b16164236830fc9506a00872Aravind Akella looper_flags |= ALOOPER_EVENT_INPUT; 11678a96955c8e14db40b16164236830fc9506a00872Aravind Akella break; 11688a96955c8e14db40b16164236830fc9506a00872Aravind Akella } 11698a96955c8e14db40b16164236830fc9506a00872Aravind Akella } 11708a96955c8e14db40b16164236830fc9506a00872Aravind Akella // If flags is still set to zero, we don't need to add this fd to the Looper, if 11718a96955c8e14db40b16164236830fc9506a00872Aravind Akella // the fd has already been added, remove it. This is likely to happen when ALL the 11728a96955c8e14db40b16164236830fc9506a00872Aravind Akella // events stored in the cache have been sent to the corresponding app. 11738a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (looper_flags == 0) { 11748a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (mHasLooperCallbacks) { 11758a96955c8e14db40b16164236830fc9506a00872Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "removeFd fd=%d", mChannel->getSendFd()); 11768a96955c8e14db40b16164236830fc9506a00872Aravind Akella looper->removeFd(mChannel->getSendFd()); 11778a96955c8e14db40b16164236830fc9506a00872Aravind Akella mHasLooperCallbacks = false; 11788a96955c8e14db40b16164236830fc9506a00872Aravind Akella } 11798a96955c8e14db40b16164236830fc9506a00872Aravind Akella return; 11808a96955c8e14db40b16164236830fc9506a00872Aravind Akella } 11818a96955c8e14db40b16164236830fc9506a00872Aravind Akella // Add the file descriptor to the Looper for receiving acknowledegments if the app has 11828a96955c8e14db40b16164236830fc9506a00872Aravind Akella // registered for wake-up sensors OR for sending events in the cache. 11838a96955c8e14db40b16164236830fc9506a00872Aravind Akella int ret = looper->addFd(mChannel->getSendFd(), 0, looper_flags, this, NULL); 11848a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (ret == 1) { 11858a96955c8e14db40b16164236830fc9506a00872Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "%p addFd fd=%d", this, mChannel->getSendFd()); 11868a96955c8e14db40b16164236830fc9506a00872Aravind Akella mHasLooperCallbacks = true; 11878a96955c8e14db40b16164236830fc9506a00872Aravind Akella } else { 11888a96955c8e14db40b16164236830fc9506a00872Aravind Akella ALOGE("Looper::addFd failed ret=%d fd=%d", ret, mChannel->getSendFd()); 11898a96955c8e14db40b16164236830fc9506a00872Aravind Akella } 11908a96955c8e14db40b16164236830fc9506a00872Aravind Akella} 11918a96955c8e14db40b16164236830fc9506a00872Aravind Akella 11928a96955c8e14db40b16164236830fc9506a00872Aravind Akellavoid SensorService::SensorEventConnection::incrementPendingFlushCount(int32_t handle) { 11938a96955c8e14db40b16164236830fc9506a00872Aravind Akella Mutex::Autolock _l(mConnectionLock); 11948a96955c8e14db40b16164236830fc9506a00872Aravind Akella ssize_t index = mSensorInfo.indexOfKey(handle); 11958a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (index >= 0) { 11968a96955c8e14db40b16164236830fc9506a00872Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 11978a96955c8e14db40b16164236830fc9506a00872Aravind Akella flushInfo.mPendingFlushEventsToSend++; 11988a96955c8e14db40b16164236830fc9506a00872Aravind Akella } 11998a96955c8e14db40b16164236830fc9506a00872Aravind Akella} 12008a96955c8e14db40b16164236830fc9506a00872Aravind Akella 1201fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::SensorEventConnection::sendEvents( 12020ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella sensors_event_t const* buffer, size_t numEvents, 12038493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella sensors_event_t* scratch, 12048493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella SensorEventConnection const * const * mapFlushEventsToConnections) { 1205cf51001dbf28e9885fcacd4048902f1c75768fe9Mathias Agopian // filter out events not for this connection 12063560fb24b668675627934356f210d84d19bf4e56Mathias Agopian size_t count = 0; 12079a844cf78f09953145200b4074d47589257a408cAravind Akella Mutex::Autolock _l(mConnectionLock); 12083560fb24b668675627934356f210d84d19bf4e56Mathias Agopian if (scratch) { 12093560fb24b668675627934356f210d84d19bf4e56Mathias Agopian size_t i=0; 12103560fb24b668675627934356f210d84d19bf4e56Mathias Agopian while (i<numEvents) { 12116c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella int32_t sensor_handle = buffer[i].sensor; 1212724d91d778e71c8186399f4955de14b54812b3edAravind Akella if (buffer[i].type == SENSOR_TYPE_META_DATA) { 1213724d91d778e71c8186399f4955de14b54812b3edAravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ", 12149e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella buffer[i].meta_data.sensor); 12158a96955c8e14db40b16164236830fc9506a00872Aravind Akella // Setting sensor_handle to the correct sensor to ensure the sensor events per 12168a96955c8e14db40b16164236830fc9506a00872Aravind Akella // connection are filtered correctly. buffer[i].sensor is zero for meta_data 12178a96955c8e14db40b16164236830fc9506a00872Aravind Akella // events. 12186c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella sensor_handle = buffer[i].meta_data.sensor; 1219724d91d778e71c8186399f4955de14b54812b3edAravind Akella } 12206c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ssize_t index = mSensorInfo.indexOfKey(sensor_handle); 122156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Check if this connection has registered for this sensor. If not continue to the 122256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // next sensor_event. 122356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (index < 0) { 122456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ++i; 122556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella continue; 12264c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 122756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 122856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 12296c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // Check if there is a pending flush_complete event for this sensor on this connection. 12308493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (buffer[i].type == SENSOR_TYPE_META_DATA && flushInfo.mFirstFlushPending == true && 12318493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella this == mapFlushEventsToConnections[i]) { 12328493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella flushInfo.mFirstFlushPending = false; 12338493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ", 12348493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella buffer[i].meta_data.sensor); 12358493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella ++i; 12368493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella continue; 123756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 123856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 123956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // If there is a pending flush complete event for this sensor on this connection, 124056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // ignore the event and proceed to the next. 124156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (flushInfo.mFirstFlushPending) { 124256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ++i; 124356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella continue; 12443560fb24b668675627934356f210d84d19bf4e56Mathias Agopian } 124556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 124656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella do { 12478493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // Keep copying events into the scratch buffer as long as they are regular 12488493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // sensor_events are from the same sensor_handle OR they are flush_complete_events 12498493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // from the same sensor_handle AND the current connection is mapped to the 12508493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella // corresponding flush_complete_event. 125156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (buffer[i].type == SENSOR_TYPE_META_DATA) { 12528493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella if (this == mapFlushEventsToConnections[i]) { 125356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella scratch[count++] = buffer[i]; 125456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 125556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ++i; 125656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 125756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Regular sensor event, just copy it to the scratch buffer. 125856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella scratch[count++] = buffer[i++]; 125956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 12608493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella } while ((i<numEvents) && ((buffer[i].sensor == sensor_handle && 12618493b79e1cff92450076ca7450c4bf4e434a6816Aravind Akella buffer[i].type != SENSOR_TYPE_META_DATA) || 126256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella (buffer[i].type == SENSOR_TYPE_META_DATA && 12636c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella buffer[i].meta_data.sensor == sensor_handle))); 1264cf51001dbf28e9885fcacd4048902f1c75768fe9Mathias Agopian } 12653560fb24b668675627934356f210d84d19bf4e56Mathias Agopian } else { 12663560fb24b668675627934356f210d84d19bf4e56Mathias Agopian scratch = const_cast<sensors_event_t *>(buffer); 12673560fb24b668675627934356f210d84d19bf4e56Mathias Agopian count = numEvents; 1268cf51001dbf28e9885fcacd4048902f1c75768fe9Mathias Agopian } 1269fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 12706c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella sendPendingFlushEventsLocked(); 127156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Early return if there are no events for this connection. 127256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (count == 0) { 127356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return status_t(NO_ERROR); 127456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 127556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 127656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 127756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsReceived += count; 127856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 127956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mCacheSize != 0) { 128056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // There are some events in the cache which need to be sent first. Copy this buffer to 128156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // the end of cache. 128256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mCacheSize + count <= mMaxCacheSize) { 128356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 128456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize += count; 128556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 12866c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // Check if any new sensors have registered on this connection which may have increased 12876c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // the max cache size that is desired. 12886c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (mCacheSize + count < computeMaxCacheSizeLocked()) { 12896c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella reAllocateCacheLocked(scratch, count); 12906c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella return status_t(NO_ERROR); 12916c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 129256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Some events need to be dropped. 129356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int remaningCacheSize = mMaxCacheSize - mCacheSize; 129456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (remaningCacheSize != 0) { 129556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memcpy(&mEventCache[mCacheSize], scratch, 129656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella remaningCacheSize * sizeof(sensors_event_t)); 129756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 129856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int numEventsDropped = count - remaningCacheSize; 129956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella countFlushCompleteEventsLocked(mEventCache, numEventsDropped); 130056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Drop the first "numEventsDropped" in the cache. 130156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memmove(mEventCache, &mEventCache[numEventsDropped], 130256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella (mCacheSize - numEventsDropped) * sizeof(sensors_event_t)); 130356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 130456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Copy the remainingEvents in scratch buffer to the end of cache. 130556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memcpy(&mEventCache[mCacheSize - numEventsDropped], scratch + remaningCacheSize, 130656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella numEventsDropped * sizeof(sensors_event_t)); 130756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 130856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return status_t(NO_ERROR); 130956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 131056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 13116c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella int index_wake_up_event = findWakeUpSensorEventLocked(scratch, count); 13126c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (index_wake_up_event >= 0) { 13136c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella scratch[index_wake_up_event].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 13146c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ++mWakeLockRefCount; 1315e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#if DEBUG_CONNECTIONS 1316e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella ++mTotalAcksNeeded; 1317e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#endif 13186c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 131956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 132056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // NOTE: ASensorEvent and sensors_event_t are the same type. 132156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ssize_t size = SensorEventQueue::write(mChannel, 132256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella reinterpret_cast<ASensorEvent const*>(scratch), count); 132356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (size < 0) { 132456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Write error, copy events to local cache. 13256c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (index_wake_up_event >= 0) { 13266c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // If there was a wake_up sensor_event, reset the flag. 13276c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella scratch[index_wake_up_event].flags &= ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 13280ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella if (mWakeLockRefCount > 0) { 13290ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella --mWakeLockRefCount; 13300ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella } 1331e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#if DEBUG_CONNECTIONS 1332e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella --mTotalAcksNeeded; 1333e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#endif 13346c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 133556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mEventCache == NULL) { 133656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mMaxCacheSize = computeMaxCacheSizeLocked(); 133756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventCache = new sensors_event_t[mMaxCacheSize]; 133856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize = 0; 133956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 134056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 134156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize += count; 134256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 134356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Add this file descriptor to the looper to get a callback when this fd is available for 134456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // writing. 13458a96955c8e14db40b16164236830fc9506a00872Aravind Akella updateLooperRegistrationLocked(mService->getLooper()); 134656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return size; 134756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 134856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 134956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 135056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (size > 0) { 135156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsSent += count; 135256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 135356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 135456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 135556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return size < 0 ? status_t(size) : status_t(NO_ERROR); 135656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella} 135756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 13586c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akellavoid SensorService::SensorEventConnection::reAllocateCacheLocked(sensors_event_t const* scratch, 13596c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella int count) { 13606c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella sensors_event_t *eventCache_new; 13616c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella const int new_cache_size = computeMaxCacheSizeLocked(); 13626c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // Allocate new cache, copy over events from the old cache & scratch, free up memory. 13636c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella eventCache_new = new sensors_event_t[new_cache_size]; 13646c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella memcpy(eventCache_new, mEventCache, mCacheSize * sizeof(sensors_event_t)); 13656c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella memcpy(&eventCache_new[mCacheSize], scratch, count * sizeof(sensors_event_t)); 13666c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 13676c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "reAllocateCacheLocked maxCacheSize=%d %d", mMaxCacheSize, 13686c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella new_cache_size); 13696c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 13706c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella delete mEventCache; 13716c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mEventCache = eventCache_new; 13726c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mCacheSize += count; 13736c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mMaxCacheSize = new_cache_size; 13746c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella} 13756c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 13766c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akellavoid SensorService::SensorEventConnection::sendPendingFlushEventsLocked() { 13776c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ASensorEvent flushCompleteEvent; 13780ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella memset(&flushCompleteEvent, 0, sizeof(flushCompleteEvent)); 13796c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella flushCompleteEvent.type = SENSOR_TYPE_META_DATA; 13806c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // Loop through all the sensors for this connection and check if there are any pending 13816c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // flush complete events to be sent. 13826c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella for (size_t i = 0; i < mSensorInfo.size(); ++i) { 13836c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueAt(i); 13846c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella while (flushInfo.mPendingFlushEventsToSend > 0) { 13850ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella const int sensor_handle = mSensorInfo.keyAt(i); 13860ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella flushCompleteEvent.meta_data.sensor = sensor_handle; 1387b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella bool wakeUpSensor = mService->getSensorFromHandle(sensor_handle).isWakeUpSensor(); 1388b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (wakeUpSensor) { 1389b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella ++mWakeLockRefCount; 13900ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella flushCompleteEvent.flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 13910ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella } 13926c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1); 13936c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (size < 0) { 1394b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella if (wakeUpSensor) --mWakeLockRefCount; 13956c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella return; 13964c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 13976c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ", 13986c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella flushCompleteEvent.meta_data.sensor); 13996c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella flushInfo.mPendingFlushEventsToSend--; 14004c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 14014c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 14026c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella} 14036c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella 1404b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akellavoid SensorService::SensorEventConnection::writeToSocketFromCache() { 14055466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // At a time write at most half the size of the receiver buffer in SensorEventQueue OR 14065466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // half the size of the socket buffer allocated in BitTube whichever is smaller. 14075466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella const int maxWriteSize = helpers::min(SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT/2, 14085466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella int(mService->mSocketBufferSize/(sizeof(sensors_event_t)*2))); 1409b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella Mutex::Autolock _l(mConnectionLock); 14105466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella // Send pending flush complete events (if any) 14116c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella sendPendingFlushEventsLocked(); 141256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella for (int numEventsSent = 0; numEventsSent < mCacheSize;) { 14135466c3d20d03d4ae4b0fd0e0a93175091e3b0bb2Aravind Akella const int numEventsToWrite = helpers::min(mCacheSize - numEventsSent, maxWriteSize); 14146c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella int index_wake_up_event = 14156c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella findWakeUpSensorEventLocked(mEventCache + numEventsSent, numEventsToWrite); 14166c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (index_wake_up_event >= 0) { 14176c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mEventCache[index_wake_up_event + numEventsSent].flags |= 14186c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 14196c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ++mWakeLockRefCount; 1420e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#if DEBUG_CONNECTIONS 1421e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella ++mTotalAcksNeeded; 1422e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#endif 14236c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 142456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 142556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ssize_t size = SensorEventQueue::write(mChannel, 142656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella reinterpret_cast<ASensorEvent const*>(mEventCache + numEventsSent), 14276c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella numEventsToWrite); 142856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (size < 0) { 14296c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella if (index_wake_up_event >= 0) { 14306c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // If there was a wake_up sensor_event, reset the flag. 14316c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mEventCache[index_wake_up_event + numEventsSent].flags &= 14326c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 14330ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella if (mWakeLockRefCount > 0) { 14340ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella --mWakeLockRefCount; 14350ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella } 1436e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#if DEBUG_CONNECTIONS 1437e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella --mTotalAcksNeeded; 1438e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#endif 14396c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella } 144056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memmove(mEventCache, &mEventCache[numEventsSent], 144156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella (mCacheSize - numEventsSent) * sizeof(sensors_event_t)); 144256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "wrote %d events from cache size==%d ", 14436c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella numEventsSent, mCacheSize); 144456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize -= numEventsSent; 144556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return; 144656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 14476c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella numEventsSent += numEventsToWrite; 144856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 14496c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella mEventsSentFromCache += numEventsToWrite; 145056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 1451fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 145256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "wrote all events from cache size=%d ", mCacheSize); 145356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // All events from the cache have been sent. Reset cache size to zero. 145456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize = 0; 14558a96955c8e14db40b16164236830fc9506a00872Aravind Akella // There are no more events in the cache. We don't need to poll for write on the fd. 14568a96955c8e14db40b16164236830fc9506a00872Aravind Akella // Update Looper registration. 14578a96955c8e14db40b16164236830fc9506a00872Aravind Akella updateLooperRegistrationLocked(mService->getLooper()); 1458fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1459fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1460c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akellavoid SensorService::SensorEventConnection::countFlushCompleteEventsLocked( 14610ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella sensors_event_t const* scratch, const int numEventsDropped) { 14624c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped); 14634c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella // Count flushComplete events in the events that are about to the dropped. These will be sent 14644c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella // separately before the next batch of events. 14654c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella for (int j = 0; j < numEventsDropped; ++j) { 14664c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (scratch[j].type == SENSOR_TYPE_META_DATA) { 14674c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor); 14684c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushInfo.mPendingFlushEventsToSend++; 14694c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d", 14704c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushInfo.mPendingFlushEventsToSend); 14714c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 14724c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 14734c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella return; 14744c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella} 14754c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 14766c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akellaint SensorService::SensorEventConnection::findWakeUpSensorEventLocked( 14776c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella sensors_event_t const* scratch, const int count) { 14789a844cf78f09953145200b4074d47589257a408cAravind Akella for (int i = 0; i < count; ++i) { 14799a844cf78f09953145200b4074d47589257a408cAravind Akella if (mService->isWakeUpSensorEvent(scratch[i])) { 14806c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella return i; 14819a844cf78f09953145200b4074d47589257a408cAravind Akella } 14829a844cf78f09953145200b4074d47589257a408cAravind Akella } 14836c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella return -1; 14849a844cf78f09953145200b4074d47589257a408cAravind Akella} 14859a844cf78f09953145200b4074d47589257a408cAravind Akella 1486b3989276d17f2b083bec67b695d1078fb86c6c53Mathias Agopiansp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const 1487fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 1488fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return mChannel; 1489fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1490fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1491fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::SensorEventConnection::enableDisable( 1492724d91d778e71c8186399f4955de14b54812b3edAravind Akella int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, 1493724d91d778e71c8186399f4955de14b54812b3edAravind Akella int reservedFlags) 1494fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 1495fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian status_t err; 1496fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (enabled) { 1497724d91d778e71c8186399f4955de14b54812b3edAravind Akella err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs, 1498724d91d778e71c8186399f4955de14b54812b3edAravind Akella reservedFlags); 149956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 1500fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } else { 1501fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian err = mService->disable(this, handle); 1502fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 1503fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return err; 1504fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1505fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1506fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::SensorEventConnection::setEventRate( 1507724d91d778e71c8186399f4955de14b54812b3edAravind Akella int handle, nsecs_t samplingPeriodNs) 1508fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 1509724d91d778e71c8186399f4955de14b54812b3edAravind Akella return mService->setEventRate(this, handle, samplingPeriodNs); 1510fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1511fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1512701166d9f60a6e1149ff568aec0e03f3f3925292Aravind Akellastatus_t SensorService::SensorEventConnection::flush() { 15139e3adfcebf28c5c76085108dffe98c74df56857dAravind Akella return mService->flushSensor(this); 1514724d91d778e71c8186399f4955de14b54812b3edAravind Akella} 15154c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 15168a96955c8e14db40b16164236830fc9506a00872Aravind Akellaint SensorService::SensorEventConnection::handleEvent(int fd, int events, void* /*data*/) { 151756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (events & ALOOPER_EVENT_HANGUP || events & ALOOPER_EVENT_ERROR) { 15188a96955c8e14db40b16164236830fc9506a00872Aravind Akella { 15198a96955c8e14db40b16164236830fc9506a00872Aravind Akella // If the Looper encounters some error, set the flag mDead, reset mWakeLockRefCount, 15208a96955c8e14db40b16164236830fc9506a00872Aravind Akella // and remove the fd from Looper. Call checkWakeLockState to know if SensorService 15218a96955c8e14db40b16164236830fc9506a00872Aravind Akella // can release the wake-lock. 15228a96955c8e14db40b16164236830fc9506a00872Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "%p Looper error %d", this, fd); 15238a96955c8e14db40b16164236830fc9506a00872Aravind Akella Mutex::Autolock _l(mConnectionLock); 15248a96955c8e14db40b16164236830fc9506a00872Aravind Akella mDead = true; 15258a96955c8e14db40b16164236830fc9506a00872Aravind Akella mWakeLockRefCount = 0; 15268a96955c8e14db40b16164236830fc9506a00872Aravind Akella updateLooperRegistrationLocked(mService->getLooper()); 15278a96955c8e14db40b16164236830fc9506a00872Aravind Akella } 15288a96955c8e14db40b16164236830fc9506a00872Aravind Akella mService->checkWakeLockState(); 15298a96955c8e14db40b16164236830fc9506a00872Aravind Akella return 1; 15309a844cf78f09953145200b4074d47589257a408cAravind Akella } 153156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 153256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (events & ALOOPER_EVENT_INPUT) { 15338a96955c8e14db40b16164236830fc9506a00872Aravind Akella uint32_t numAcks = 0; 15348a96955c8e14db40b16164236830fc9506a00872Aravind Akella ssize_t ret = ::recv(fd, &numAcks, sizeof(numAcks), MSG_DONTWAIT); 153556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella { 153656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella Mutex::Autolock _l(mConnectionLock); 15378a96955c8e14db40b16164236830fc9506a00872Aravind Akella // Sanity check to ensure there are no read errors in recv, numAcks is always 15388a96955c8e14db40b16164236830fc9506a00872Aravind Akella // within the range and not zero. If any of the above don't hold reset mWakeLockRefCount 15398a96955c8e14db40b16164236830fc9506a00872Aravind Akella // to zero. 15408a96955c8e14db40b16164236830fc9506a00872Aravind Akella if (ret != sizeof(numAcks) || numAcks > mWakeLockRefCount || numAcks == 0) { 15418a96955c8e14db40b16164236830fc9506a00872Aravind Akella ALOGE("Looper read error ret=%d numAcks=%d", ret, numAcks); 15428a96955c8e14db40b16164236830fc9506a00872Aravind Akella mWakeLockRefCount = 0; 15438a96955c8e14db40b16164236830fc9506a00872Aravind Akella } else { 15448a96955c8e14db40b16164236830fc9506a00872Aravind Akella mWakeLockRefCount -= numAcks; 15450ec2066e4774b851c66176b99b0a5aa5abe6ad00Aravind Akella } 1546e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#if DEBUG_CONNECTIONS 15478a96955c8e14db40b16164236830fc9506a00872Aravind Akella mTotalAcksReceived += numAcks; 1548e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella#endif 154956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 155056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Check if wakelock can be released by sensorservice. mConnectionLock needs to be released 155156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // here as checkWakeLockState() will need it. 155256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mWakeLockRefCount == 0) { 155356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mService->checkWakeLockState(); 155456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 155556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // continue getting callbacks. 155656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return 1; 155756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 155856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 155956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (events & ALOOPER_EVENT_OUTPUT) { 1560b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella // send sensor data that is stored in mEventCache for this connection. 1561b4373ac9f53e3a6edee915715101d535e1a851a1Aravind Akella mService->sendEventsFromCache(this); 15629a844cf78f09953145200b4074d47589257a408cAravind Akella } 156356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return 1; 156456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella} 156556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 156656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellaint SensorService::SensorEventConnection::computeMaxCacheSizeLocked() const { 156756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int fifoWakeUpSensors = 0; 156856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int fifoNonWakeUpSensors = 0; 156956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella for (size_t i = 0; i < mSensorInfo.size(); ++i) { 157056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella const Sensor& sensor = mService->getSensorFromHandle(mSensorInfo.keyAt(i)); 157156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (sensor.getFifoReservedEventCount() == sensor.getFifoMaxEventCount()) { 157256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Each sensor has a reserved fifo. Sum up the fifo sizes for all wake up sensors and 157356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // non wake_up sensors. 157456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (sensor.isWakeUpSensor()) { 157556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoWakeUpSensors += sensor.getFifoReservedEventCount(); 157656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 157756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoNonWakeUpSensors += sensor.getFifoReservedEventCount(); 157856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 157956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 158056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Shared fifo. Compute the max of the fifo sizes for wake_up and non_wake up sensors. 158156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (sensor.isWakeUpSensor()) { 158256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoWakeUpSensors = fifoWakeUpSensors > sensor.getFifoMaxEventCount() ? 158356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoWakeUpSensors : sensor.getFifoMaxEventCount(); 158456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 158556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 158656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoNonWakeUpSensors = fifoNonWakeUpSensors > sensor.getFifoMaxEventCount() ? 158756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoNonWakeUpSensors : sensor.getFifoMaxEventCount(); 158856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 158956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 159056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 159156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 159256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (fifoWakeUpSensors + fifoNonWakeUpSensors == 0) { 159356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // It is extremely unlikely that there is a write failure in non batch mode. Return a cache 15946c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella // size that is equal to that of the batch mode. 1595e74baf6ca7d57375f38540b6b7ac5e4af019951bAravind Akella // ALOGW("Write failure in non-batch mode"); 15966c2664ae34fd582bc174d3c83e2b18e895ca2496Aravind Akella return MAX_SOCKET_BUFFER_SIZE_BATCHED/sizeof(sensors_event_t); 159756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 159856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return fifoWakeUpSensors + fifoNonWakeUpSensors; 15999a844cf78f09953145200b4074d47589257a408cAravind Akella} 16009a844cf78f09953145200b4074d47589257a408cAravind Akella 1601fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian// --------------------------------------------------------------------------- 1602fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian}; // namespace android 1603fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1604