SensorService.cpp revision 56ae42613c91f6a6fb0dc3f626daa24666fd18c2
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() 691cb13461a8cf62e3ba634e5965332f2d284f6d42Mathias Agopian : mInitCheck(NO_INIT) 70fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 71fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 72fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 73fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianvoid SensorService::onFirstRef() 74fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 75a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD("nuSensorService starting..."); 7650df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian 77f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian SensorDevice& dev(SensorDevice::getInstance()); 78fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 79f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (dev.initCheck() == NO_ERROR) { 80f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensor_t const* list; 817b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian ssize_t count = dev.getSensorList(&list); 827b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian if (count > 0) { 837b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian ssize_t orientationIndex = -1; 847b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian bool hasGyro = false; 857b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian uint32_t virtualSensorsNeeds = 867b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian (1<<SENSOR_TYPE_GRAVITY) | 877b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian (1<<SENSOR_TYPE_LINEAR_ACCELERATION) | 887b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian (1<<SENSOR_TYPE_ROTATION_VECTOR); 897b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian 907b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian mLastEventSeen.setCapacity(count); 917b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian for (ssize_t i=0 ; i<count ; i++) { 927b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian registerSensor( new HardwareSensor(list[i]) ); 937b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian switch (list[i].type) { 947b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_ORIENTATION: 957b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian orientationIndex = i; 967b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian break; 977b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_GYROSCOPE: 980319306670b0344da99efa606b6f172dde575a39Mathias Agopian case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 997b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian hasGyro = true; 1007b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian break; 1017b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_GRAVITY: 1027b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_LINEAR_ACCELERATION: 1037b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian case SENSOR_TYPE_ROTATION_VECTOR: 1047b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian virtualSensorsNeeds &= ~(1<<list[i].type); 1057b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian break; 1067b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian } 10750df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian } 108fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1097b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian // it's safe to instantiate the SensorFusion object here 1107b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian // (it wants to be instantiated after h/w sensors have been 1117b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian // registered) 1127b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian const SensorFusion& fusion(SensorFusion::getInstance()); 1137b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian 1140319306670b0344da99efa606b6f172dde575a39Mathias Agopian // build the sensor list returned to users 1150319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList = mSensorList; 1160319306670b0344da99efa606b6f172dde575a39Mathias Agopian 1177b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian if (hasGyro) { 1180319306670b0344da99efa606b6f172dde575a39Mathias Agopian Sensor aSensor; 1197b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian 1200319306670b0344da99efa606b6f172dde575a39Mathias Agopian // Add Android virtual sensors if they're not already 1210319306670b0344da99efa606b6f172dde575a39Mathias Agopian // available in the HAL 1227b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian 1230319306670b0344da99efa606b6f172dde575a39Mathias Agopian aSensor = registerVirtualSensor( new RotationVectorSensor() ); 1240319306670b0344da99efa606b6f172dde575a39Mathias Agopian if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 1250319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList.add(aSensor); 1260319306670b0344da99efa606b6f172dde575a39Mathias Agopian } 127f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 1280319306670b0344da99efa606b6f172dde575a39Mathias Agopian aSensor = registerVirtualSensor( new GravitySensor(list, count) ); 1290319306670b0344da99efa606b6f172dde575a39Mathias Agopian if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) { 1300319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList.add(aSensor); 1310319306670b0344da99efa606b6f172dde575a39Mathias Agopian } 13233264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian 1330319306670b0344da99efa606b6f172dde575a39Mathias Agopian aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) ); 1340319306670b0344da99efa606b6f172dde575a39Mathias Agopian if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) { 1350319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList.add(aSensor); 1360319306670b0344da99efa606b6f172dde575a39Mathias Agopian } 13733264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian 1380319306670b0344da99efa606b6f172dde575a39Mathias Agopian aSensor = registerVirtualSensor( new OrientationSensor() ); 1390319306670b0344da99efa606b6f172dde575a39Mathias Agopian if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) { 1400319306670b0344da99efa606b6f172dde575a39Mathias Agopian // if we are doing our own rotation-vector, also add 1410319306670b0344da99efa606b6f172dde575a39Mathias Agopian // the orientation sensor and remove the HAL provided one. 1420319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorList.replaceAt(aSensor, orientationIndex); 1437b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian } 1440319306670b0344da99efa606b6f172dde575a39Mathias Agopian 1450319306670b0344da99efa606b6f172dde575a39Mathias Agopian // virtual debugging sensors are not added to mUserSensorList 1460319306670b0344da99efa606b6f172dde575a39Mathias Agopian registerVirtualSensor( new CorrectedGyroSensor(list, count) ); 1470319306670b0344da99efa606b6f172dde575a39Mathias Agopian registerVirtualSensor( new GyroDriftSensor() ); 148010e42230135815907e76e5d7e5f30edf9e1799dMathias Agopian } 149010e42230135815907e76e5d7e5f30edf9e1799dMathias Agopian 15033264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian // debugging sensor list 1510319306670b0344da99efa606b6f172dde575a39Mathias Agopian mUserSensorListDebug = mSensorList; 15233264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian 1534c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED; 1544c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r"); 1554c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella char line[128]; 1564c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) { 1574c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella line[sizeof(line) - 1] = '\0'; 15892dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn sscanf(line, "%zu", &mSocketBufferSize); 1594c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (mSocketBufferSize > MAX_SOCKET_BUFFER_SIZE_BATCHED) { 1604c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED; 1614c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 1624c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 1634c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (fp) { 1644c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella fclose(fp); 1654c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 1664c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 1679a844cf78f09953145200b4074d47589257a408cAravind Akella mWakeLockAcquired = false; 1687b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian run("SensorService", PRIORITY_URGENT_DISPLAY); 16956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mLooper = new Looper(false); 1707b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian mInitCheck = NO_ERROR; 1717b2b32f2e761a919deb6f82d978b379429f77b05Mathias Agopian } 172fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 173fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 174fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1750319306670b0344da99efa606b6f172dde575a39Mathias AgopianSensor SensorService::registerSensor(SensorInterface* s) 176f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian{ 177f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensors_event_t event; 178f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian memset(&event, 0, sizeof(event)); 179f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 180f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian const Sensor sensor(s->getSensor()); 181f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // add to the sensor list (returned to clients) 182f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mSensorList.add(sensor); 183f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // add to our handle->SensorInterface mapping 184f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mSensorMap.add(sensor.getHandle(), s); 185f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // create an entry in the mLastEventSeen array 186f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mLastEventSeen.add(sensor.getHandle(), event); 1870319306670b0344da99efa606b6f172dde575a39Mathias Agopian 1880319306670b0344da99efa606b6f172dde575a39Mathias Agopian return sensor; 189f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian} 190f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 1910319306670b0344da99efa606b6f172dde575a39Mathias AgopianSensor SensorService::registerVirtualSensor(SensorInterface* s) 192f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian{ 1930319306670b0344da99efa606b6f172dde575a39Mathias Agopian Sensor sensor = registerSensor(s); 194f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mVirtualSensorList.add( s ); 1950319306670b0344da99efa606b6f172dde575a39Mathias Agopian return sensor; 196f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian} 197f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 198fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias AgopianSensorService::~SensorService() 199fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 200f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian for (size_t i=0 ; i<mSensorMap.size() ; i++) 201f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian delete mSensorMap.valueAt(i); 202fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 203fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 2041cb13461a8cf62e3ba634e5965332f2d284f6d42Mathias Agopianstatic const String16 sDump("android.permission.DUMP"); 2051cb13461a8cf62e3ba634e5965332f2d284f6d42Mathias Agopian 20692dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzynstatus_t SensorService::dump(int fd, const Vector<String16>& /*args*/) 207fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 208fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian String8 result; 2091cb13461a8cf62e3ba634e5965332f2d284f6d42Mathias Agopian if (!PermissionCache::checkCallingPermission(sDump)) { 210ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat("Permission Denial: " 211700180487ffec09d9df1657b018a7caadac24b75Aravind Akella "can't dump SensorService from pid=%d, uid=%d\n", 212fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian IPCThreadState::self()->getCallingPid(), 213fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian IPCThreadState::self()->getCallingUid()); 214fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } else { 215fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian Mutex::Autolock _l(mLock); 216ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.append("Sensor List:\n"); 2173560fb24b668675627934356f210d84d19bf4e56Mathias Agopian for (size_t i=0 ; i<mSensorList.size() ; i++) { 2183560fb24b668675627934356f210d84d19bf4e56Mathias Agopian const Sensor& s(mSensorList[i]); 2193560fb24b668675627934356f210d84d19bf4e56Mathias Agopian const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle())); 220ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 221700180487ffec09d9df1657b018a7caadac24b75Aravind Akella "%-48s| %-32s| %-48s| 0x%08x | \"%s\"\n\t", 2223560fb24b668675627934356f210d84d19bf4e56Mathias Agopian s.getName().string(), 2233560fb24b668675627934356f210d84d19bf4e56Mathias Agopian s.getVendor().string(), 224700180487ffec09d9df1657b018a7caadac24b75Aravind Akella s.getStringType().string(), 225700180487ffec09d9df1657b018a7caadac24b75Aravind Akella s.getHandle(), 226700180487ffec09d9df1657b018a7caadac24b75Aravind Akella s.getRequiredPermission().string()); 227ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian 2280e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella const int reportingMode = s.getReportingMode(); 2290e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella if (reportingMode == AREPORTING_MODE_CONTINUOUS) { 2300e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella result.append("continuous |"); 2310e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella } else if (reportingMode == AREPORTING_MODE_ON_CHANGE) { 2320e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella result.append("on-change | "); 2330e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella } else if (reportingMode == AREPORTING_MODE_ONE_SHOT) { 2340e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella result.append("one-shot | "); 2350e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella } else { 2360e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella result.append("special-trigger | "); 2370e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella } 2380e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella 239ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian if (s.getMinDelay() > 0) { 2400e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella result.appendFormat("maxRate=%7.2fHz | ", 1e6f / s.getMinDelay()); 241ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian } else { 2420e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella result.appendFormat("minDelay=%5dus |", s.getMinDelay()); 243ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian } 2440e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella 245724d91d778e71c8186399f4955de14b54812b3edAravind Akella if (s.getFifoMaxEventCount() > 0) { 246700180487ffec09d9df1657b018a7caadac24b75Aravind Akella result.appendFormat("FifoMax=%d events | ", 247700180487ffec09d9df1657b018a7caadac24b75Aravind Akella s.getFifoMaxEventCount()); 248724d91d778e71c8186399f4955de14b54812b3edAravind Akella } else { 249724d91d778e71c8186399f4955de14b54812b3edAravind Akella result.append("no batching support | "); 250724d91d778e71c8186399f4955de14b54812b3edAravind Akella } 251ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian 252ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian switch (s.getType()) { 253ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_ROTATION_VECTOR: 254ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR: 255ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 256ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n", 257ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian e.data[0], e.data[1], e.data[2], e.data[3], e.data[4]); 258ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 259ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED: 260ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED: 261ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 262ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n", 263ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.data[5]); 264ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 265ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_GAME_ROTATION_VECTOR: 266ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 267ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian "last=<%5.1f,%5.1f,%5.1f,%5.1f>\n", 268ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian e.data[0], e.data[1], e.data[2], e.data[3]); 269ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 270ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_SIGNIFICANT_MOTION: 271ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_STEP_DETECTOR: 272ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( "last=<%f>\n", e.data[0]); 273ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 274ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian case SENSOR_TYPE_STEP_COUNTER: 27592dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn result.appendFormat( "last=<%" PRIu64 ">\n", e.u64.step_counter); 276ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 277ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian default: 278ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian // default to 3 values 279ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.appendFormat( 280ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian "last=<%5.1f,%5.1f,%5.1f>\n", 281ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian e.data[0], e.data[1], e.data[2]); 282ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian break; 283ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian } 2843560fb24b668675627934356f210d84d19bf4e56Mathias Agopian } 285ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian SensorFusion::getInstance().dump(result); 286ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian SensorDevice::getInstance().dump(result); 287ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian 288ba02cd2f6cc3f59adf66cb2b9176bfe6c9e382d1Mathias Agopian result.append("Active sensors:\n"); 289fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian for (size_t i=0 ; i<mActiveSensors.size() ; i++) { 2905d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian int handle = mActiveSensors.keyAt(i); 29192dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn result.appendFormat("%s (handle=0x%08x, connections=%zu)\n", 2925d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian getSensorName(handle).string(), 2935d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian handle, 294fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mActiveSensors.valueAt(i)->getNumConnections()); 295fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 2964c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 29792dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn result.appendFormat("%zu Max Socket Buffer size\n", mSocketBufferSize); 2989a844cf78f09953145200b4074d47589257a408cAravind Akella result.appendFormat("WakeLock Status: %s \n", mWakeLockAcquired ? "acquired" : "not held"); 29992dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn result.appendFormat("%zd active connections\n", mActiveConnections.size()); 3004c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 3014c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella for (size_t i=0 ; i < mActiveConnections.size() ; i++) { 3024c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 3034c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (connection != 0) { 30492dc3fc52cf097bd105460cf377779bdcf146d62Mark Salyzyn result.appendFormat("Connection Number: %zu \n", i); 3054c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella connection->dump(result); 3064c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 3074c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 308fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 309fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian write(fd, result.string(), result.size()); 310fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return NO_ERROR; 311fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 312fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 3139a844cf78f09953145200b4074d47589257a408cAravind Akellavoid SensorService::cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection, 3144342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh sensors_event_t const* buffer, const int count) { 3154342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh for (int i=0 ; i<count ; i++) { 3164342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh int handle = buffer[i].sensor; 3170e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella if (connection->hasSensor(handle)) { 3180e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella SensorInterface* sensor = mSensorMap.valueFor(handle); 3190e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella // If this buffer has an event from a one_shot sensor and this connection is registered 3200e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella // for this particular one_shot sensor, try cleaning up the connection. 3210e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella if (sensor != NULL && 3220e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 3230e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella sensor->autoDisable(connection.get(), handle); 3249a844cf78f09953145200b4074d47589257a408cAravind Akella cleanupWithoutDisableLocked(connection, handle); 3254342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 3264342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 3274342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 3284342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh} 3294342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 330fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianbool SensorService::threadLoop() 331fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 332a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD("nuSensorService thread starting..."); 333fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 33490ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian // each virtual sensor could generate an event per "real" event, that's why we need 33590ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT. 33690ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian // in practice, this is too aggressive, but guaranteed to be enough. 33790ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT; 33890ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size()); 33990ed3e8d7883d9c80fb8bf11b1c593bd8b2b39d0Mathias Agopian 340d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian sensors_event_t buffer[minBufferSize]; 341d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian sensors_event_t scratch[minBufferSize]; 342f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian SensorDevice& device(SensorDevice::getInstance()); 343f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian const size_t vcount = mVirtualSensorList.size(); 344fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 34556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella SensorEventAckReceiver sender(this); 34656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella sender.run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY); 347f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian ssize_t count; 3484342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh const int halVersion = device.getHalDeviceVersion(); 349fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian do { 350f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian count = device.poll(buffer, numEventMax); 351fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (count<0) { 352f5a1230d322c14c42331d0a1536b50c87742973bSteve Block ALOGE("sensor poll failed (%s)", strerror(-count)); 353fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian break; 354fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 35556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 35656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Reset sensors_event_t.flags to zero for all events in the buffer. 35756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella for (int i = 0; i < count; i++) { 35856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella buffer[i].flags = 0; 35956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 3609a844cf78f09953145200b4074d47589257a408cAravind Akella Mutex::Autolock _l(mLock); 3619a844cf78f09953145200b4074d47589257a408cAravind Akella // Poll has returned. Hold a wakelock if one of the events is from a wake up sensor. The 3629a844cf78f09953145200b4074d47589257a408cAravind Akella // rest of this loop is under a critical section protected by mLock. Acquiring a wakeLock, 3639a844cf78f09953145200b4074d47589257a408cAravind Akella // sending events to clients (incrementing SensorEventConnection::mWakeLockRefCount) should 3649a844cf78f09953145200b4074d47589257a408cAravind Akella // not be interleaved with decrementing SensorEventConnection::mWakeLockRefCount and 3659a844cf78f09953145200b4074d47589257a408cAravind Akella // releasing the wakelock. 3669a844cf78f09953145200b4074d47589257a408cAravind Akella bool bufferHasWakeUpEvent = false; 3674342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh for (int i = 0; i < count; i++) { 3689a844cf78f09953145200b4074d47589257a408cAravind Akella if (isWakeUpSensorEvent(buffer[i])) { 3699a844cf78f09953145200b4074d47589257a408cAravind Akella bufferHasWakeUpEvent = true; 3709a844cf78f09953145200b4074d47589257a408cAravind Akella break; 3714342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 3724342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 3734342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 3749a844cf78f09953145200b4074d47589257a408cAravind Akella if (bufferHasWakeUpEvent && !mWakeLockAcquired) { 3759a844cf78f09953145200b4074d47589257a408cAravind Akella acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 3769a844cf78f09953145200b4074d47589257a408cAravind Akella mWakeLockAcquired = true; 3779a844cf78f09953145200b4074d47589257a408cAravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock %s", WAKE_LOCK_NAME); 3789a844cf78f09953145200b4074d47589257a408cAravind Akella } 3799a844cf78f09953145200b4074d47589257a408cAravind Akella recordLastValueLocked(buffer, count); 38094e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian 381f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // handle virtual sensors 382f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (count && vcount) { 383984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian sensors_event_t const * const event = buffer; 3849a844cf78f09953145200b4074d47589257a408cAravind Akella const size_t activeVirtualSensorCount = mActiveVirtualSensors.size(); 385f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (activeVirtualSensorCount) { 386f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian size_t k = 0; 387984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian SensorFusion& fusion(SensorFusion::getInstance()); 388984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian if (fusion.isEnabled()) { 389984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian for (size_t i=0 ; i<size_t(count) ; i++) { 390984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian fusion.process(event[i]); 391984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian } 392984826cc158193e61e3a00359ef4f6699c7d748aMathias Agopian } 393d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) { 394f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian for (size_t j=0 ; j<activeVirtualSensorCount ; j++) { 395d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian if (count + k >= minBufferSize) { 396d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian ALOGE("buffer too small to hold all events: " 397db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn "count=%zd, k=%zu, size=%zu", 398d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian count, k, minBufferSize); 399d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian break; 400d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian } 401f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensors_event_t out; 4029a844cf78f09953145200b4074d47589257a408cAravind Akella SensorInterface* si = mActiveVirtualSensors.valueAt(j); 403d1920ffede9e9bc107104ad94c291ca0f0f18bc3Mathias Agopian if (si->process(&out, event[i])) { 404f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian buffer[count + k] = out; 405f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian k++; 406f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 407f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 408f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 409f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (k) { 410f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // record the last synthesized values 4119a844cf78f09953145200b4074d47589257a408cAravind Akella recordLastValueLocked(&buffer[count], k); 412f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian count += k; 413f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian // sort the buffer by time-stamps 414f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sortEventBuffer(buffer, count); 415f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 416f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 417f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 418f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 4194342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // handle backward compatibility for RotationVector sensor 4204342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) { 4214342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh for (int i = 0; i < count; i++) { 4227438fd1a0132bc6de101e2a5f75040a119b6f29bMathias Agopian if (buffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) { 4234342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // All the 4 components of the quaternion should be available 4244342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // No heading accuracy. Set it to -1 4254342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh buffer[i].data[4] = -1; 4264342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 4274342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 4284342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 4294342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 4309a844cf78f09953145200b4074d47589257a408cAravind Akella // Send our events to clients. Check the state of wake lock for each client and release the 4319a844cf78f09953145200b4074d47589257a408cAravind Akella // lock if none of the clients need it. 4329a844cf78f09953145200b4074d47589257a408cAravind Akella bool needsWakeLock = false; 4339a844cf78f09953145200b4074d47589257a408cAravind Akella for (size_t i=0 ; i < mActiveConnections.size(); i++) { 4349a844cf78f09953145200b4074d47589257a408cAravind Akella sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 435f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (connection != 0) { 436f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian connection->sendEvents(buffer, count, scratch); 4379a844cf78f09953145200b4074d47589257a408cAravind Akella needsWakeLock |= connection->needsWakeLock(); 4384342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // Some sensors need to be auto disabled after the trigger 4399a844cf78f09953145200b4074d47589257a408cAravind Akella cleanupAutoDisabledSensorLocked(connection, buffer, count); 440fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 441fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 4424342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 4439a844cf78f09953145200b4074d47589257a408cAravind Akella if (mWakeLockAcquired && !needsWakeLock) { 4449a844cf78f09953145200b4074d47589257a408cAravind Akella release_wake_lock(WAKE_LOCK_NAME); 4459a844cf78f09953145200b4074d47589257a408cAravind Akella mWakeLockAcquired = false; 4469a844cf78f09953145200b4074d47589257a408cAravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "released wakelock %s", WAKE_LOCK_NAME); 4479a844cf78f09953145200b4074d47589257a408cAravind Akella } 448fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } while (count >= 0 || Thread::exitPending()); 449fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 4503c20fbed7f3a916ced10f2ed5a272271b7d81edeSteve Block ALOGW("Exiting SensorService::threadLoop => aborting..."); 4511a62301fc58cd2af18239b0415813461bf5fc41bMathias Agopian abort(); 452fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return false; 453fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 454fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 45556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellasp<Looper> SensorService::getLooper() const { 45656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return mLooper; 45756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella} 45856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 45956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellabool SensorService::SensorEventAckReceiver::threadLoop() { 46056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOGD("new thread SensorEventAckReceiver"); 46156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella do { 46256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella sp<Looper> looper = mService->getLooper(); 46356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella looper->pollOnce(-1); 46456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } while(!Thread::exitPending()); 46556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return false; 46656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella} 46756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 4689a844cf78f09953145200b4074d47589257a408cAravind Akellavoid SensorService::recordLastValueLocked( 4694b84704b97300eff3ebfab85652e64d54149d205Aravind Akella const sensors_event_t* buffer, size_t count) { 4704b84704b97300eff3ebfab85652e64d54149d205Aravind Akella const sensors_event_t* last = NULL; 4714b84704b97300eff3ebfab85652e64d54149d205Aravind Akella for (size_t i = 0; i < count; i++) { 4724b84704b97300eff3ebfab85652e64d54149d205Aravind Akella const sensors_event_t* event = &buffer[i]; 4734b84704b97300eff3ebfab85652e64d54149d205Aravind Akella if (event->type != SENSOR_TYPE_META_DATA) { 4744b84704b97300eff3ebfab85652e64d54149d205Aravind Akella if (last && event->sensor != last->sensor) { 4754b84704b97300eff3ebfab85652e64d54149d205Aravind Akella mLastEventSeen.editValueFor(last->sensor) = *last; 4764b84704b97300eff3ebfab85652e64d54149d205Aravind Akella } 4774b84704b97300eff3ebfab85652e64d54149d205Aravind Akella last = event; 47894e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian } 47994e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian } 4804b84704b97300eff3ebfab85652e64d54149d205Aravind Akella if (last) { 4814b84704b97300eff3ebfab85652e64d54149d205Aravind Akella mLastEventSeen.editValueFor(last->sensor) = *last; 4824b84704b97300eff3ebfab85652e64d54149d205Aravind Akella } 48394e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian} 48494e8f6813f3fb2beaa9bcbfb1ad9b4ae2eb46949Mathias Agopian 485f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopianvoid SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count) 486f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian{ 487f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian struct compar { 488f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian static int cmp(void const* lhs, void const* rhs) { 489f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs); 490f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs); 491a5c106a4f0afcf061728a1cb7c8c3b908728575dMathias Agopian return l->timestamp - r->timestamp; 492f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 493f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian }; 494f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian qsort(buffer, count, sizeof(sensors_event_t), compar::cmp); 495f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian} 496f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian 4975d2707214dfb97bd8dfcc6620be36841d3c82420Mathias AgopianString8 SensorService::getSensorName(int handle) const { 498010e42230135815907e76e5d7e5f30edf9e1799dMathias Agopian size_t count = mUserSensorList.size(); 4995d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian for (size_t i=0 ; i<count ; i++) { 500010e42230135815907e76e5d7e5f30edf9e1799dMathias Agopian const Sensor& sensor(mUserSensorList[i]); 5015d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian if (sensor.getHandle() == handle) { 5025d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian return sensor.getName(); 5035d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian } 5045d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian } 5055d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian String8 result("unknown"); 5065d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian return result; 5075d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian} 5085d2707214dfb97bd8dfcc6620be36841d3c82420Mathias Agopian 509b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akellabool SensorService::isVirtualSensor(int handle) const { 510b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akella SensorInterface* sensor = mSensorMap.valueFor(handle); 511b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akella return sensor->isVirtual(); 512b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akella} 513b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akella 5149a844cf78f09953145200b4074d47589257a408cAravind Akellabool SensorService::isWakeUpSensorEvent(const sensors_event_t& event) const { 5157869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan int handle = event.sensor; 5167869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan if (event.type == SENSOR_TYPE_META_DATA) { 5177869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan handle = event.meta_data.sensor; 5187869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan } 5197869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan SensorInterface* sensor = mSensorMap.valueFor(handle); 5207869e224aaaf717b5ab86df00b60fd5be5a0996cSean Wan return sensor != NULL && sensor->getSensor().isWakeUpSensor(); 5219a844cf78f09953145200b4074d47589257a408cAravind Akella} 5229a844cf78f09953145200b4074d47589257a408cAravind Akella 523fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias AgopianVector<Sensor> SensorService::getSensorList() 524fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 52533264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian char value[PROPERTY_VALUE_MAX]; 52633264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian property_get("debug.sensors", value, "0"); 527700180487ffec09d9df1657b018a7caadac24b75Aravind Akella const Vector<Sensor>& initialSensorList = (atoi(value)) ? 528700180487ffec09d9df1657b018a7caadac24b75Aravind Akella mUserSensorListDebug : mUserSensorList; 529700180487ffec09d9df1657b018a7caadac24b75Aravind Akella Vector<Sensor> accessibleSensorList; 530700180487ffec09d9df1657b018a7caadac24b75Aravind Akella for (size_t i = 0; i < initialSensorList.size(); i++) { 531700180487ffec09d9df1657b018a7caadac24b75Aravind Akella Sensor sensor = initialSensorList[i]; 532700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (canAccessSensor(sensor)) { 533700180487ffec09d9df1657b018a7caadac24b75Aravind Akella accessibleSensorList.add(sensor); 534700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } else { 535700180487ffec09d9df1657b018a7caadac24b75Aravind Akella String8 infoMessage; 536700180487ffec09d9df1657b018a7caadac24b75Aravind Akella infoMessage.appendFormat( 537700180487ffec09d9df1657b018a7caadac24b75Aravind Akella "Skipped sensor %s because it requires permission %s", 538700180487ffec09d9df1657b018a7caadac24b75Aravind Akella sensor.getName().string(), 539700180487ffec09d9df1657b018a7caadac24b75Aravind Akella sensor.getRequiredPermission().string()); 540700180487ffec09d9df1657b018a7caadac24b75Aravind Akella ALOGI(infoMessage.string()); 541700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 54233264868ba0aaccb9d4b5e5a067a79a43633f6ecMathias Agopian } 543700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return accessibleSensorList; 544fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 545fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 546fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopiansp<ISensorEventConnection> SensorService::createSensorEventConnection() 547fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 5485307d17fe33fc26eeeacd6339a9fbfe96cf56873Mathias Agopian uid_t uid = IPCThreadState::self()->getCallingUid(); 5495307d17fe33fc26eeeacd6339a9fbfe96cf56873Mathias Agopian sp<SensorEventConnection> result(new SensorEventConnection(this, uid)); 550fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return result; 551fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 552fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 553db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopianvoid SensorService::cleanupConnection(SensorEventConnection* c) 554fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 555fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian Mutex::Autolock _l(mLock); 556db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian const wp<SensorEventConnection> connection(c); 5577c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian size_t size = mActiveSensors.size(); 558db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn ALOGD_IF(DEBUG_CONNECTIONS, "%zu active sensors", size); 5597c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian for (size_t i=0 ; i<size ; ) { 560db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian int handle = mActiveSensors.keyAt(i); 561db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian if (c->hasSensor(handle)) { 562db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn ALOGD_IF(DEBUG_CONNECTIONS, "%zu: disabling handle=0x%08x", i, handle); 563f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian SensorInterface* sensor = mSensorMap.valueFor( handle ); 564f5a1230d322c14c42331d0a1536b50c87742973bSteve Block ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle); 565f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian if (sensor) { 566db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian sensor->activate(c, false); 567f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 568db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian } 569db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian SensorRecord* rec = mActiveSensors.valueAt(i); 570db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn ALOGE_IF(!rec, "mActiveSensors[%zu] is null (handle=0x%08x)!", i, handle); 571a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD_IF(DEBUG_CONNECTIONS, 572db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn "removing connection %p for sensor[%zu].handle=0x%08x", 573a1b7db95b6ccf5be9d8dfaac1b8f45494813edc0Mathias Agopian c, i, handle); 574a1b7db95b6ccf5be9d8dfaac1b8f45494813edc0Mathias Agopian 575db5b4bce9e65ec9c2c7762b601297e4abadbc22aMathias Agopian if (rec && rec->removeConnection(connection)) { 576a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD_IF(DEBUG_CONNECTIONS, "... and it was the last connection"); 5777c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian mActiveSensors.removeItemsAt(i, 1); 578f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mActiveVirtualSensors.removeItem(handle); 5797c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian delete rec; 5807c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian size--; 5817c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian } else { 5827c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian i++; 583fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 584fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 5857c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian mActiveConnections.remove(connection); 586787ac1b388f144f5e6dd38f8b807866a5256dafcMathias Agopian BatteryService::cleanup(c->getUid()); 5879a844cf78f09953145200b4074d47589257a408cAravind Akella if (c->needsWakeLock()) { 5889a844cf78f09953145200b4074d47589257a408cAravind Akella checkWakeLockStateLocked(); 5899a844cf78f09953145200b4074d47589257a408cAravind Akella } 590fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 591fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 592700180487ffec09d9df1657b018a7caadac24b75Aravind AkellaSensor SensorService::getSensorFromHandle(int handle) const { 593700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return mSensorMap.valueFor(handle)->getSensor(); 594700180487ffec09d9df1657b018a7caadac24b75Aravind Akella} 595700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 596fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::enable(const sp<SensorEventConnection>& connection, 597724d91d778e71c8186399f4955de14b54812b3edAravind Akella int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags) 598fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 59950df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian if (mInitCheck != NO_ERROR) 60050df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian return mInitCheck; 60150df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian 602f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian SensorInterface* sensor = mSensorMap.valueFor(handle); 603ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian if (sensor == NULL) { 604ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian return BAD_VALUE; 605ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian } 606700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 607700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (!verifyCanAccessSensor(sensor->getSensor(), "Tried enabling")) { 608700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return BAD_VALUE; 609700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 610700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 611ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian Mutex::Autolock _l(mLock); 6124342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh SensorRecord* rec = mActiveSensors.valueFor(handle); 6134342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (rec == 0) { 6144342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh rec = new SensorRecord(connection); 6154342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh mActiveSensors.add(handle, rec); 6164342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (sensor->isVirtual()) { 6174342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh mActiveVirtualSensors.add(handle, sensor); 6183560fb24b668675627934356f210d84d19bf4e56Mathias Agopian } 6194342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } else { 6204342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (rec->addConnection(connection)) { 6219a844cf78f09953145200b4074d47589257a408cAravind Akella // this sensor is already activated, but we are adding a connection that uses it. 6229a844cf78f09953145200b4074d47589257a408cAravind Akella // Immediately send down the last known value of the requested sensor if it's not a 6234342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // "continuous" sensor. 6240e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ON_CHANGE) { 6259a844cf78f09953145200b4074d47589257a408cAravind Akella // NOTE: The wake_up flag of this event may get set to 6269a844cf78f09953145200b4074d47589257a408cAravind Akella // WAKE_UP_SENSOR_EVENT_NEEDS_ACK if this is a wake_up event. 6274342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh sensors_event_t& event(mLastEventSeen.editValueFor(handle)); 6284342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (event.version == sizeof(sensors_event_t)) { 6299a844cf78f09953145200b4074d47589257a408cAravind Akella if (isWakeUpSensorEvent(event) && !mWakeLockAcquired) { 6309a844cf78f09953145200b4074d47589257a408cAravind Akella acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME); 6319a844cf78f09953145200b4074d47589257a408cAravind Akella mWakeLockAcquired = true; 6329a844cf78f09953145200b4074d47589257a408cAravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock for on_change sensor %s", 6339a844cf78f09953145200b4074d47589257a408cAravind Akella WAKE_LOCK_NAME); 6349a844cf78f09953145200b4074d47589257a408cAravind Akella } 6359a844cf78f09953145200b4074d47589257a408cAravind Akella connection->sendEvents(&event, 1, NULL); 6369a844cf78f09953145200b4074d47589257a408cAravind Akella if (!connection->needsWakeLock() && mWakeLockAcquired) { 6379a844cf78f09953145200b4074d47589257a408cAravind Akella checkWakeLockStateLocked(); 6389a844cf78f09953145200b4074d47589257a408cAravind Akella } 639f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian } 6407c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian } 641fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 642fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 6434342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 6444342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (connection->addSensor(handle)) { 6454342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh BatteryService::enableSensor(connection->getUid(), handle); 6464342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // the sensor was added (which means it wasn't already there) 6474342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh // so, see if this connection becomes active 6484342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (mActiveConnections.indexOf(connection) < 0) { 6494342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh mActiveConnections.add(connection); 6504342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 6514342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } else { 6524342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh ALOGW("sensor %08x already enabled in connection %p (ignoring)", 6534342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh handle, connection.get()); 6544342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 6554342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 656724d91d778e71c8186399f4955de14b54812b3edAravind Akella nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 657724d91d778e71c8186399f4955de14b54812b3edAravind Akella if (samplingPeriodNs < minDelayNs) { 658724d91d778e71c8186399f4955de14b54812b3edAravind Akella samplingPeriodNs = minDelayNs; 659724d91d778e71c8186399f4955de14b54812b3edAravind Akella } 660724d91d778e71c8186399f4955de14b54812b3edAravind Akella 661db45861ff4b636b9dd833d622dd64e2ad24b0645Mark Salyzyn ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d rate=%" PRId64 " timeout== %" PRId64, 662724d91d778e71c8186399f4955de14b54812b3edAravind Akella handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs); 663724d91d778e71c8186399f4955de14b54812b3edAravind Akella 664724d91d778e71c8186399f4955de14b54812b3edAravind Akella status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs, 665724d91d778e71c8186399f4955de14b54812b3edAravind Akella maxBatchReportLatencyNs); 6664c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (err == NO_ERROR) { 6674c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella connection->setFirstFlushPending(handle, true); 6684c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella status_t err_flush = sensor->flush(connection.get(), handle); 6694c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella // Flush may return error if the sensor is not activated or the underlying h/w sensor does 6704c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella // not support flush. 6714c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (err_flush != NO_ERROR) { 6724c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella connection->setFirstFlushPending(handle, false); 6734c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 6744c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 675724d91d778e71c8186399f4955de14b54812b3edAravind Akella 676724d91d778e71c8186399f4955de14b54812b3edAravind Akella if (err == NO_ERROR) { 677724d91d778e71c8186399f4955de14b54812b3edAravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle); 678724d91d778e71c8186399f4955de14b54812b3edAravind Akella err = sensor->activate(connection.get(), true); 679724d91d778e71c8186399f4955de14b54812b3edAravind Akella } 680724d91d778e71c8186399f4955de14b54812b3edAravind Akella 68156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (err == NO_ERROR && sensor->getSensor().isWakeUpSensor()) { 68256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Add the file descriptor to the Looper for receiving acknowledgments; 68356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int ret = mLooper->addFd(connection->getSensorChannel()->getSendFd(), 0, 68456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOOPER_EVENT_INPUT, connection.get(), NULL); 68556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 68656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 6874342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (err != NO_ERROR) { 688724d91d778e71c8186399f4955de14b54812b3edAravind Akella // batch/activate has failed, reset our state. 689ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian cleanupWithoutDisableLocked(connection, handle); 6904342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 691fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return err; 692fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 693fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 694fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::disable(const sp<SensorEventConnection>& connection, 695fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian int handle) 696fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 69750df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian if (mInitCheck != NO_ERROR) 69850df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian return mInitCheck; 69950df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian 700ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian Mutex::Autolock _l(mLock); 701ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian status_t err = cleanupWithoutDisableLocked(connection, handle); 7024342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh if (err == NO_ERROR) { 7034342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh SensorInterface* sensor = mSensorMap.valueFor(handle); 7044342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE); 7054342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh } 7064342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh return err; 7074342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh} 7084342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh 709ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopianstatus_t SensorService::cleanupWithoutDisable( 710ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian const sp<SensorEventConnection>& connection, int handle) { 711fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian Mutex::Autolock _l(mLock); 712ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian return cleanupWithoutDisableLocked(connection, handle); 713ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian} 714ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian 715ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopianstatus_t SensorService::cleanupWithoutDisableLocked( 716ac9a96da65f6eae4513654adaad8a457d1c1575cMathias Agopian const sp<SensorEventConnection>& connection, int handle) { 717fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian SensorRecord* rec = mActiveSensors.valueFor(handle); 718fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (rec) { 719fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian // see if this connection becomes inactive 720787ac1b388f144f5e6dd38f8b807866a5256dafcMathias Agopian if (connection->removeSensor(handle)) { 721787ac1b388f144f5e6dd38f8b807866a5256dafcMathias Agopian BatteryService::disableSensor(connection->getUid(), handle); 722787ac1b388f144f5e6dd38f8b807866a5256dafcMathias Agopian } 723fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (connection->hasAnySensor() == false) { 724fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mActiveConnections.remove(connection); 725fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 726fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian // see if this sensor becomes inactive 727fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (rec->removeConnection(connection)) { 728fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mActiveSensors.removeItem(handle); 729f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian mActiveVirtualSensors.removeItem(handle); 730fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian delete rec; 731fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 7324342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh return NO_ERROR; 7337c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian } 7344342fdf14ffb792a36c1de25ad14b745df628da2Jaikumar Ganesh return BAD_VALUE; 735fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 736fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 7377c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopianstatus_t SensorService::setEventRate(const sp<SensorEventConnection>& connection, 738fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian int handle, nsecs_t ns) 739fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 74050df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian if (mInitCheck != NO_ERROR) 74150df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian return mInitCheck; 74250df2959e58fc7408f98d11d77c8428397dca445Mathias Agopian 743ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian SensorInterface* sensor = mSensorMap.valueFor(handle); 744ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian if (!sensor) 745ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian return BAD_VALUE; 746ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian 747700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) { 748700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return BAD_VALUE; 749700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 750700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 7511cd700015318727d6d42236ab6274f1949fb08baMathias Agopian if (ns < 0) 7521cd700015318727d6d42236ab6274f1949fb08baMathias Agopian return BAD_VALUE; 7531cd700015318727d6d42236ab6274f1949fb08baMathias Agopian 75462569ecf526c7c01cb68ea461c6bbd3cb26057d2Mathias Agopian nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs(); 75562569ecf526c7c01cb68ea461c6bbd3cb26057d2Mathias Agopian if (ns < minDelayNs) { 75662569ecf526c7c01cb68ea461c6bbd3cb26057d2Mathias Agopian ns = minDelayNs; 757ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian } 758ae09d65f5b35cb51da2e1386a6dd7a52085f1325Mathias Agopian 759f001c92436b4a66eb7687286325ced7f10c9f917Mathias Agopian return sensor->setDelay(connection.get(), handle, ns); 760fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 761fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 762724d91d778e71c8186399f4955de14b54812b3edAravind Akellastatus_t SensorService::flushSensor(const sp<SensorEventConnection>& connection, 763724d91d778e71c8186399f4955de14b54812b3edAravind Akella int handle) { 764700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (mInitCheck != NO_ERROR) return mInitCheck; 765700180487ffec09d9df1657b018a7caadac24b75Aravind Akella SensorInterface* sensor = mSensorMap.valueFor(handle); 766700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (sensor == NULL) { 767700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return BAD_VALUE; 768700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 769700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 770700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (!verifyCanAccessSensor(sensor->getSensor(), "Tried flushing")) { 771700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return BAD_VALUE; 772700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 773700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 7740e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) { 7750e025c5af365e45e02cb75c1d46b46c7f4cd44cbAravind Akella ALOGE("flush called on a one-shot sensor"); 776700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return INVALID_OPERATION; 777700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 778700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return sensor->flush(connection.get(), handle); 779700180487ffec09d9df1657b018a7caadac24b75Aravind Akella} 780700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 781700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 782700180487ffec09d9df1657b018a7caadac24b75Aravind Akellabool SensorService::canAccessSensor(const Sensor& sensor) { 78356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return (sensor.getRequiredPermission().isEmpty()) || 78456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella PermissionCache::checkCallingPermission(String16(sensor.getRequiredPermission())); 785724d91d778e71c8186399f4955de14b54812b3edAravind Akella} 786700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 787700180487ffec09d9df1657b018a7caadac24b75Aravind Akellabool SensorService::verifyCanAccessSensor(const Sensor& sensor, const char* operation) { 788700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (canAccessSensor(sensor)) { 789700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return true; 790700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } else { 791700180487ffec09d9df1657b018a7caadac24b75Aravind Akella String8 errorMessage; 792700180487ffec09d9df1657b018a7caadac24b75Aravind Akella errorMessage.appendFormat( 793700180487ffec09d9df1657b018a7caadac24b75Aravind Akella "%s a sensor (%s) without holding its required permission: %s", 794700180487ffec09d9df1657b018a7caadac24b75Aravind Akella operation, 795700180487ffec09d9df1657b018a7caadac24b75Aravind Akella sensor.getName().string(), 796700180487ffec09d9df1657b018a7caadac24b75Aravind Akella sensor.getRequiredPermission().string()); 797700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return false; 798700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 799700180487ffec09d9df1657b018a7caadac24b75Aravind Akella} 800700180487ffec09d9df1657b018a7caadac24b75Aravind Akella 8019a844cf78f09953145200b4074d47589257a408cAravind Akellavoid SensorService::checkWakeLockState() { 8029a844cf78f09953145200b4074d47589257a408cAravind Akella Mutex::Autolock _l(mLock); 8039a844cf78f09953145200b4074d47589257a408cAravind Akella checkWakeLockStateLocked(); 8049a844cf78f09953145200b4074d47589257a408cAravind Akella} 8059a844cf78f09953145200b4074d47589257a408cAravind Akella 8069a844cf78f09953145200b4074d47589257a408cAravind Akellavoid SensorService::checkWakeLockStateLocked() { 8079a844cf78f09953145200b4074d47589257a408cAravind Akella if (!mWakeLockAcquired) { 8089a844cf78f09953145200b4074d47589257a408cAravind Akella return; 8099a844cf78f09953145200b4074d47589257a408cAravind Akella } 8109a844cf78f09953145200b4074d47589257a408cAravind Akella bool releaseLock = true; 8119a844cf78f09953145200b4074d47589257a408cAravind Akella for (size_t i=0 ; i<mActiveConnections.size() ; i++) { 8129a844cf78f09953145200b4074d47589257a408cAravind Akella sp<SensorEventConnection> connection(mActiveConnections[i].promote()); 8139a844cf78f09953145200b4074d47589257a408cAravind Akella if (connection != 0) { 8149a844cf78f09953145200b4074d47589257a408cAravind Akella if (connection->needsWakeLock()) { 8159a844cf78f09953145200b4074d47589257a408cAravind Akella releaseLock = false; 8169a844cf78f09953145200b4074d47589257a408cAravind Akella break; 8179a844cf78f09953145200b4074d47589257a408cAravind Akella } 8189a844cf78f09953145200b4074d47589257a408cAravind Akella } 8199a844cf78f09953145200b4074d47589257a408cAravind Akella } 8209a844cf78f09953145200b4074d47589257a408cAravind Akella if (releaseLock) { 8219a844cf78f09953145200b4074d47589257a408cAravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "releasing wakelock %s", WAKE_LOCK_NAME); 8229a844cf78f09953145200b4074d47589257a408cAravind Akella release_wake_lock(WAKE_LOCK_NAME); 8239a844cf78f09953145200b4074d47589257a408cAravind Akella mWakeLockAcquired = false; 8249a844cf78f09953145200b4074d47589257a408cAravind Akella } 8259a844cf78f09953145200b4074d47589257a408cAravind Akella} 826fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian// --------------------------------------------------------------------------- 827fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias AgopianSensorService::SensorRecord::SensorRecord( 828fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian const sp<SensorEventConnection>& connection) 829fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 830fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mConnections.add(connection); 831fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 832fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 8337c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopianbool SensorService::SensorRecord::addConnection( 834fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian const sp<SensorEventConnection>& connection) 835fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 836fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (mConnections.indexOf(connection) < 0) { 837fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mConnections.add(connection); 8387c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return true; 839fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 8407c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return false; 841fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 842fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 843fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianbool SensorService::SensorRecord::removeConnection( 844fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian const wp<SensorEventConnection>& connection) 845fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 846fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian ssize_t index = mConnections.indexOf(connection); 847fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (index >= 0) { 848fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mConnections.removeItemsAt(index, 1); 849fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 850fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return mConnections.size() ? false : true; 851fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 852fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 853fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian// --------------------------------------------------------------------------- 854fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 855fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias AgopianSensorService::SensorEventConnection::SensorEventConnection( 8565307d17fe33fc26eeeacd6339a9fbfe96cf56873Mathias Agopian const sp<SensorService>& service, uid_t uid) 85756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella : mService(service), mUid(uid), mWakeLockRefCount(0), mEventCache(NULL), mCacheSize(0), 85856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mMaxCacheSize(0) { 8594c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella const SensorDevice& device(SensorDevice::getInstance()); 8604c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (device.getHalDeviceVersion() >= SENSORS_DEVICE_API_VERSION_1_1) { 86156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Increase socket buffer size to a max of 100 KB for batching capabilities. 86256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mChannel = new BitTube(mService->mSocketBufferSize); 8634c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } else { 8644c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella mChannel = new BitTube(SOCKET_BUFFER_SIZE_NON_BATCHED); 8654c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 86656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 86756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsReceived = mEventsSentFromCache = mEventsSent = 0; 86856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 869fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 870fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 87156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind AkellaSensorService::SensorEventConnection::~SensorEventConnection() { 872a551237de142549fb8a6608ee9d2fbf4b7ca2ebfSteve Block ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this); 87356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mEventCache != NULL) { 87456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella delete mEventCache; 87556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 876fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian mService->cleanupConnection(this); 877fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 878fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 87956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellavoid SensorService::SensorEventConnection::onFirstRef() { 88056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella LooperCallback::onFirstRef(); 881fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 882fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 8839a844cf78f09953145200b4074d47589257a408cAravind Akellabool SensorService::SensorEventConnection::needsWakeLock() { 8849a844cf78f09953145200b4074d47589257a408cAravind Akella Mutex::Autolock _l(mConnectionLock); 8859a844cf78f09953145200b4074d47589257a408cAravind Akella return mWakeLockRefCount > 0; 8869a844cf78f09953145200b4074d47589257a408cAravind Akella} 8879a844cf78f09953145200b4074d47589257a408cAravind Akella 8884c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akellavoid SensorService::SensorEventConnection::dump(String8& result) { 8894c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella Mutex::Autolock _l(mConnectionLock); 89056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella result.appendFormat("\t %d WakeLockRefCount \n", mWakeLockRefCount); 8914c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella for (size_t i = 0; i < mSensorInfo.size(); ++i) { 8924c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella const FlushInfo& flushInfo = mSensorInfo.valueAt(i); 89356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella result.appendFormat("\t %s | status: %s | pending flush events %d | flush calls %d| uid %d|" 89456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella "cache size: %d max cache size %d\n", 8954c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella mService->getSensorName(mSensorInfo.keyAt(i)).string(), 8964c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushInfo.mFirstFlushPending ? "First flush pending" : 8974c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella "active", 898eefced119bc568d773b86c34cd8bc9d9574638f6Patrick Tjin flushInfo.mPendingFlushEventsToSend, 89956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella flushInfo.mNumFlushCalls, 90056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mUid, 90156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize, 90256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mMaxCacheSize); 90356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 90456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d\n", 90556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsReceived, 90656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsSent, 90756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsSentFromCache, 90856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsReceived - (mEventsSentFromCache + 90956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsSent + mCacheSize)); 91056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 91156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 9124c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 9134c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella} 9144c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 9157c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopianbool SensorService::SensorEventConnection::addSensor(int32_t handle) { 91671d7a5c289c6ef6b5fc86dd4784a075ca6470e38Mathias Agopian Mutex::Autolock _l(mConnectionLock); 917700180487ffec09d9df1657b018a7caadac24b75Aravind Akella if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) { 918700180487ffec09d9df1657b018a7caadac24b75Aravind Akella return false; 919700180487ffec09d9df1657b018a7caadac24b75Aravind Akella } 9204c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (mSensorInfo.indexOfKey(handle) < 0) { 9214c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella mSensorInfo.add(handle, FlushInfo()); 9227c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return true; 923fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 9247c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return false; 925fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 926fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 9277c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopianbool SensorService::SensorEventConnection::removeSensor(int32_t handle) { 92871d7a5c289c6ef6b5fc86dd4784a075ca6470e38Mathias Agopian Mutex::Autolock _l(mConnectionLock); 9294c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (mSensorInfo.removeItem(handle) >= 0) { 9307c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return true; 9317c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian } 9327c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return false; 933fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 934fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 935fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianbool SensorService::SensorEventConnection::hasSensor(int32_t handle) const { 93671d7a5c289c6ef6b5fc86dd4784a075ca6470e38Mathias Agopian Mutex::Autolock _l(mConnectionLock); 9374c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella return mSensorInfo.indexOfKey(handle) >= 0; 938fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 939fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 940fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianbool SensorService::SensorEventConnection::hasAnySensor() const { 94171d7a5c289c6ef6b5fc86dd4784a075ca6470e38Mathias Agopian Mutex::Autolock _l(mConnectionLock); 9427c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian return mSensorInfo.size() ? true : false; 9437c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian} 9447c1c531872a95051cb11ec829e3daf890d9bb58aMathias Agopian 9454c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akellavoid SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle, 9464c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella bool value) { 9474c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella Mutex::Autolock _l(mConnectionLock); 9484c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ssize_t index = mSensorInfo.indexOfKey(handle); 9494c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (index >= 0) { 9504c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 9514c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushInfo.mFirstFlushPending = value; 9524c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 9534c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella} 9544c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 955fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::SensorEventConnection::sendEvents( 956cf51001dbf28e9885fcacd4048902f1c75768fe9Mathias Agopian sensors_event_t const* buffer, size_t numEvents, 95756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella sensors_event_t* scratch) { 958cf51001dbf28e9885fcacd4048902f1c75768fe9Mathias Agopian // filter out events not for this connection 9593560fb24b668675627934356f210d84d19bf4e56Mathias Agopian size_t count = 0; 9609a844cf78f09953145200b4074d47589257a408cAravind Akella Mutex::Autolock _l(mConnectionLock); 9613560fb24b668675627934356f210d84d19bf4e56Mathias Agopian if (scratch) { 9623560fb24b668675627934356f210d84d19bf4e56Mathias Agopian size_t i=0; 9633560fb24b668675627934356f210d84d19bf4e56Mathias Agopian while (i<numEvents) { 964724d91d778e71c8186399f4955de14b54812b3edAravind Akella int32_t curr = buffer[i].sensor; 965724d91d778e71c8186399f4955de14b54812b3edAravind Akella if (buffer[i].type == SENSOR_TYPE_META_DATA) { 966724d91d778e71c8186399f4955de14b54812b3edAravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ", 967724d91d778e71c8186399f4955de14b54812b3edAravind Akella buffer[i].meta_data.sensor); 968724d91d778e71c8186399f4955de14b54812b3edAravind Akella // Setting curr to the correct sensor to ensure the sensor events per connection are 969724d91d778e71c8186399f4955de14b54812b3edAravind Akella // filtered correctly. buffer[i].sensor is zero for meta_data events. 970724d91d778e71c8186399f4955de14b54812b3edAravind Akella curr = buffer[i].meta_data.sensor; 971724d91d778e71c8186399f4955de14b54812b3edAravind Akella } 9724c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ssize_t index = mSensorInfo.indexOfKey(curr); 97356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Check if this connection has registered for this sensor. If not continue to the 97456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // next sensor_event. 97556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (index < 0) { 97656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ++i; 97756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella continue; 9784c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 97956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 98056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Check if there is a pending flush_complete event for this sensor on this connection. 98156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueAt(index); 98256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (buffer[i].type == SENSOR_TYPE_META_DATA) { 98356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (flushInfo.mFirstFlushPending == true) { 98456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // This is the first flush before activate is called. Events can now be sent for 98556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // this sensor on this connection. 98656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ", 98756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella buffer[i].meta_data.sensor); 98856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella flushInfo.mFirstFlushPending = false; 98956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ++i; 99056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella continue; 99156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 99256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 99356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 99456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // If there is a pending flush complete event for this sensor on this connection, 99556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // ignore the event and proceed to the next. 99656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (flushInfo.mFirstFlushPending) { 99756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ++i; 99856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella continue; 9993560fb24b668675627934356f210d84d19bf4e56Mathias Agopian } 100056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 100156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella do { 100256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (buffer[i].type == SENSOR_TYPE_META_DATA) { 100356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Send flush complete event only if flush() has been explicitly called by 100456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // this app else ignore. 100556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (flushInfo.mNumFlushCalls > 0) { 100656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella scratch[count++] = buffer[i]; 100756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella flushInfo.mNumFlushCalls--; 100856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 100956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ++i; 101056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 101156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Regular sensor event, just copy it to the scratch buffer. 101256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella scratch[count++] = buffer[i++]; 101356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 101456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } while ((i<numEvents) && ((buffer[i].sensor == curr) || 101556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella (buffer[i].type == SENSOR_TYPE_META_DATA && 101656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella buffer[i].meta_data.sensor == curr))); 1017cf51001dbf28e9885fcacd4048902f1c75768fe9Mathias Agopian } 10183560fb24b668675627934356f210d84d19bf4e56Mathias Agopian } else { 10193560fb24b668675627934356f210d84d19bf4e56Mathias Agopian scratch = const_cast<sensors_event_t *>(buffer); 10203560fb24b668675627934356f210d84d19bf4e56Mathias Agopian count = numEvents; 1021cf51001dbf28e9885fcacd4048902f1c75768fe9Mathias Agopian } 1022fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 102356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Early return if there are no events for this connection. 102456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (count == 0) { 102556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return status_t(NO_ERROR); 102656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 102756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 102856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 102956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsReceived += count; 103056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 103156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mCacheSize != 0) { 103256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // There are some events in the cache which need to be sent first. Copy this buffer to 103356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // the end of cache. 103456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mCacheSize + count <= mMaxCacheSize) { 103556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 103656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize += count; 103756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 103856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Some events need to be dropped. 103956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int remaningCacheSize = mMaxCacheSize - mCacheSize; 104056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (remaningCacheSize != 0) { 104156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memcpy(&mEventCache[mCacheSize], scratch, 104256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella remaningCacheSize * sizeof(sensors_event_t)); 104356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 104456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int numEventsDropped = count - remaningCacheSize; 104556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella countFlushCompleteEventsLocked(mEventCache, numEventsDropped); 104656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Drop the first "numEventsDropped" in the cache. 104756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memmove(mEventCache, &mEventCache[numEventsDropped], 104856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella (mCacheSize - numEventsDropped) * sizeof(sensors_event_t)); 104956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 105056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Copy the remainingEvents in scratch buffer to the end of cache. 105156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memcpy(&mEventCache[mCacheSize - numEventsDropped], scratch + remaningCacheSize, 105256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella numEventsDropped * sizeof(sensors_event_t)); 105356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 105456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return status_t(NO_ERROR); 105556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 105656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 105756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int numWakeUpSensorEvents = countWakeUpSensorEventsLocked(scratch, count); 105856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mWakeLockRefCount += numWakeUpSensorEvents; 105956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 106056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // NOTE: ASensorEvent and sensors_event_t are the same type. 106156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ssize_t size = SensorEventQueue::write(mChannel, 106256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella reinterpret_cast<ASensorEvent const*>(scratch), count); 106356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (size < 0) { 106456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Write error, copy events to local cache. 106556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mWakeLockRefCount -= numWakeUpSensorEvents; 106656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mEventCache == NULL) { 106756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mMaxCacheSize = computeMaxCacheSizeLocked(); 106856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventCache = new sensors_event_t[mMaxCacheSize]; 106956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize = 0; 107056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 107156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t)); 107256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize += count; 107356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 107456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Add this file descriptor to the looper to get a callback when this fd is available for 107556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // writing. 107656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mService->getLooper()->addFd(mChannel->getSendFd(), 0, 107756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOOPER_EVENT_OUTPUT | ALOOPER_EVENT_INPUT, this, NULL); 107856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return size; 107956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 108056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 108156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 108256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (size > 0) { 108356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsSent += count; 108456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 108556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 108656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 108756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return size < 0 ? status_t(size) : status_t(NO_ERROR); 108856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella} 108956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 109056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellavoid SensorService::SensorEventConnection::writeToSocketFromCacheLocked() { 109156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // At a time write at most half the size of the receiver buffer in SensorEventQueue. 109256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella const int maxWriteSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT/2; 109356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Send pending flush events (if any) before sending events from the buffer. 10944c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella { 10954c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ASensorEvent flushCompleteEvent; 10964c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushCompleteEvent.type = SENSOR_TYPE_META_DATA; 10974c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushCompleteEvent.sensor = 0; 10984c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella // Loop through all the sensors for this connection and check if there are any pending 10994c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella // flush complete events to be sent. 11004c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella for (size_t i = 0; i < mSensorInfo.size(); ++i) { 11014c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueAt(i); 11024c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella while (flushInfo.mPendingFlushEventsToSend > 0) { 11034c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushCompleteEvent.meta_data.sensor = mSensorInfo.keyAt(i); 11044c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1); 11054c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (size < 0) { 110656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return; 11074c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 11084c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ", 110956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella flushCompleteEvent.meta_data.sensor); 11104c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushInfo.mPendingFlushEventsToSend--; 11114c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 11124c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 11134c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 111456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Write "count" events at a time. 111556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella for (int numEventsSent = 0; numEventsSent < mCacheSize;) { 111656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella const int count = (mCacheSize - numEventsSent) < maxWriteSize ? 111756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize - numEventsSent : maxWriteSize; 111856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int numWakeUpSensorEvents = 111956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella countWakeUpSensorEventsLocked(mEventCache + numEventsSent, count); 112056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mWakeLockRefCount += numWakeUpSensorEvents; 112156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 112256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ssize_t size = SensorEventQueue::write(mChannel, 112356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella reinterpret_cast<ASensorEvent const*>(mEventCache + numEventsSent), 112456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella count); 112556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (size < 0) { 112656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella memmove(mEventCache, &mEventCache[numEventsSent], 112756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella (mCacheSize - numEventsSent) * sizeof(sensors_event_t)); 112856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "wrote %d events from cache size==%d ", 112956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella numEventsSent, mCacheSize); 113056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize -= numEventsSent; 113156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mWakeLockRefCount -= numWakeUpSensorEvents; 113256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return; 113356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 113456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella numEventsSent += count; 113556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#if DEBUG_CONNECTIONS 113656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mEventsSentFromCache += count; 113756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella#endif 1138fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 113956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "wrote all events from cache size=%d ", mCacheSize); 114056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // All events from the cache have been sent. Reset cache size to zero. 114156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mCacheSize = 0; 114256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Poll only for ALOOPER_EVENT_INPUT(read) on the file descriptor. 114356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mService->getLooper()->addFd(mChannel->getSendFd(), 0, ALOOPER_EVENT_INPUT, this, NULL); 1144fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1145fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1146c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akellavoid SensorService::SensorEventConnection::countFlushCompleteEventsLocked( 11474c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella sensors_event_t* scratch, const int numEventsDropped) { 11484c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped); 11494c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella // Count flushComplete events in the events that are about to the dropped. These will be sent 11504c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella // separately before the next batch of events. 11514c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella for (int j = 0; j < numEventsDropped; ++j) { 11524c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella if (scratch[j].type == SENSOR_TYPE_META_DATA) { 11534c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor); 11544c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushInfo.mPendingFlushEventsToSend++; 11554c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d", 11564c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella flushInfo.mPendingFlushEventsToSend); 11574c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 11584c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella } 11594c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella return; 11604c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella} 11614c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 11629a844cf78f09953145200b4074d47589257a408cAravind Akellaint SensorService::SensorEventConnection::countWakeUpSensorEventsLocked( 11639a844cf78f09953145200b4074d47589257a408cAravind Akella sensors_event_t* scratch, const int count) { 11649a844cf78f09953145200b4074d47589257a408cAravind Akella for (int i = 0; i < count; ++i) { 11659a844cf78f09953145200b4074d47589257a408cAravind Akella if (mService->isWakeUpSensorEvent(scratch[i])) { 11669a844cf78f09953145200b4074d47589257a408cAravind Akella scratch[i].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK; 11679a844cf78f09953145200b4074d47589257a408cAravind Akella return 1; 11689a844cf78f09953145200b4074d47589257a408cAravind Akella } 11699a844cf78f09953145200b4074d47589257a408cAravind Akella } 11709a844cf78f09953145200b4074d47589257a408cAravind Akella return 0; 11719a844cf78f09953145200b4074d47589257a408cAravind Akella} 11729a844cf78f09953145200b4074d47589257a408cAravind Akella 1173b3989276d17f2b083bec67b695d1078fb86c6c53Mathias Agopiansp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const 1174fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 1175fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return mChannel; 1176fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1177fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1178fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::SensorEventConnection::enableDisable( 1179724d91d778e71c8186399f4955de14b54812b3edAravind Akella int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, 1180724d91d778e71c8186399f4955de14b54812b3edAravind Akella int reservedFlags) 1181fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 1182fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian status_t err; 1183fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian if (enabled) { 1184724d91d778e71c8186399f4955de14b54812b3edAravind Akella err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs, 1185724d91d778e71c8186399f4955de14b54812b3edAravind Akella reservedFlags); 118656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 1187fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } else { 1188fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian err = mService->disable(this, handle); 1189fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian } 1190fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian return err; 1191fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1192fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1193fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopianstatus_t SensorService::SensorEventConnection::setEventRate( 1194724d91d778e71c8186399f4955de14b54812b3edAravind Akella int handle, nsecs_t samplingPeriodNs) 1195fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian{ 1196724d91d778e71c8186399f4955de14b54812b3edAravind Akella return mService->setEventRate(this, handle, samplingPeriodNs); 1197fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian} 1198fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1199701166d9f60a6e1149ff568aec0e03f3f3925292Aravind Akellastatus_t SensorService::SensorEventConnection::flush() { 1200c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella SensorDevice& dev(SensorDevice::getInstance()); 1201c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella const int halVersion = dev.getHalDeviceVersion(); 1202701166d9f60a6e1149ff568aec0e03f3f3925292Aravind Akella Mutex::Autolock _l(mConnectionLock); 1203701166d9f60a6e1149ff568aec0e03f3f3925292Aravind Akella status_t err(NO_ERROR); 1204c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella // Loop through all sensors for this connection and call flush on each of them. 1205701166d9f60a6e1149ff568aec0e03f3f3925292Aravind Akella for (size_t i = 0; i < mSensorInfo.size(); ++i) { 1206701166d9f60a6e1149ff568aec0e03f3f3925292Aravind Akella const int handle = mSensorInfo.keyAt(i); 120756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella FlushInfo& flushInfo = mSensorInfo.editValueFor(handle); 1208b4099e77ec2bf8e9d4259ff30f0cb1d621deed91Aravind Akella if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 || mService->isVirtualSensor(handle)) { 1209c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella // For older devices just increment pending flush count which will send a trivial 1210c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella // flush complete event. 1211c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella flushInfo.mPendingFlushEventsToSend++; 1212c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella } else { 1213c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella status_t err_flush = mService->flushSensor(this, handle); 121456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (err_flush == NO_ERROR) { 121556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella flushInfo.mNumFlushCalls++; 121656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 1217c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella ALOGE("Flush error handle=%d %s", handle, strerror(-err_flush)); 1218c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella } 1219c551eac5b16a53f872cbb692d3a0c81e39329725Aravind Akella err = (err_flush != NO_ERROR) ? err_flush : err; 1220701166d9f60a6e1149ff568aec0e03f3f3925292Aravind Akella } 1221701166d9f60a6e1149ff568aec0e03f3f3925292Aravind Akella } 1222701166d9f60a6e1149ff568aec0e03f3f3925292Aravind Akella return err; 1223724d91d778e71c8186399f4955de14b54812b3edAravind Akella} 12244c8b951f8d6a121e758bd3905fa8987c77863790Aravind Akella 122556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellaint SensorService::SensorEventConnection::handleEvent(int fd, int events, void* data) { 122656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (events & ALOOPER_EVENT_HANGUP || events & ALOOPER_EVENT_ERROR) { 122756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return 0; 12289a844cf78f09953145200b4074d47589257a408cAravind Akella } 122956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 123056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (events & ALOOPER_EVENT_INPUT) { 123156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella char buf; 123256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ssize_t ret = ::recv(fd, &buf, sizeof(buf), MSG_DONTWAIT); 123356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 123456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella { 123556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella Mutex::Autolock _l(mConnectionLock); 123656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella --mWakeLockRefCount; 123756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 123856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Check if wakelock can be released by sensorservice. mConnectionLock needs to be released 123956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // here as checkWakeLockState() will need it. 124056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (mWakeLockRefCount == 0) { 124156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella mService->checkWakeLockState(); 124256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 124356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // continue getting callbacks. 124456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return 1; 124556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 124656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 124756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (events & ALOOPER_EVENT_OUTPUT) { 124856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // send sensor data that is stored in mEventCache. 124956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella Mutex::Autolock _l(mConnectionLock); 125056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella writeToSocketFromCacheLocked(); 12519a844cf78f09953145200b4074d47589257a408cAravind Akella } 125256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return 1; 125356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella} 125456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 125556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akellaint SensorService::SensorEventConnection::computeMaxCacheSizeLocked() const { 125656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int fifoWakeUpSensors = 0; 125756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella int fifoNonWakeUpSensors = 0; 125856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella for (size_t i = 0; i < mSensorInfo.size(); ++i) { 125956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella const Sensor& sensor = mService->getSensorFromHandle(mSensorInfo.keyAt(i)); 126056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (sensor.getFifoReservedEventCount() == sensor.getFifoMaxEventCount()) { 126156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Each sensor has a reserved fifo. Sum up the fifo sizes for all wake up sensors and 126256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // non wake_up sensors. 126356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (sensor.isWakeUpSensor()) { 126456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoWakeUpSensors += sensor.getFifoReservedEventCount(); 126556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 126656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoNonWakeUpSensors += sensor.getFifoReservedEventCount(); 126756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 126856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 126956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // Shared fifo. Compute the max of the fifo sizes for wake_up and non_wake up sensors. 127056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (sensor.isWakeUpSensor()) { 127156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoWakeUpSensors = fifoWakeUpSensors > sensor.getFifoMaxEventCount() ? 127256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoWakeUpSensors : sensor.getFifoMaxEventCount(); 127356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 127456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } else { 127556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoNonWakeUpSensors = fifoNonWakeUpSensors > sensor.getFifoMaxEventCount() ? 127656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella fifoNonWakeUpSensors : sensor.getFifoMaxEventCount(); 127756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella 127856ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 127956ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 128056ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 128156ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella if (fifoWakeUpSensors + fifoNonWakeUpSensors == 0) { 128256ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // It is extremely unlikely that there is a write failure in non batch mode. Return a cache 128356ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella // size of 100. 128456ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella ALOGI("Write failure in non-batch mode"); 128556ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return 100; 128656ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella } 128756ae42613c91f6a6fb0dc3f626daa24666fd18c2Aravind Akella return fifoWakeUpSensors + fifoNonWakeUpSensors; 12889a844cf78f09953145200b4074d47589257a408cAravind Akella} 12899a844cf78f09953145200b4074d47589257a408cAravind Akella 1290fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian// --------------------------------------------------------------------------- 1291fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian}; // namespace android 1292fc32881fcc68640d008c7515cdd1bcd866f72cd5Mathias Agopian 1293