1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "Sensors" 18 19 #include <stdint.h> 20 #include <sys/types.h> 21 22 #include <utils/Errors.h> 23 #include <utils/RefBase.h> 24 #include <utils/Singleton.h> 25 26 #include <binder/IBinder.h> 27 #include <binder/IServiceManager.h> 28 29 #include <gui/ISensorServer.h> 30 #include <gui/ISensorEventConnection.h> 31 #include <gui/Sensor.h> 32 #include <gui/SensorManager.h> 33 #include <gui/SensorEventQueue.h> 34 35 // ---------------------------------------------------------------------------- 36 namespace android { 37 // ---------------------------------------------------------------------------- 38 39 android::Mutex android::SensorManager::sLock; 40 std::map<String16, SensorManager*> android::SensorManager::sPackageInstances; 41 42 SensorManager& SensorManager::getInstanceForPackage(const String16& packageName) { 43 Mutex::Autolock _l(sLock); 44 SensorManager* sensorManager; 45 std::map<String16, SensorManager*>::iterator iterator = 46 sPackageInstances.find(packageName); 47 48 if (iterator != sPackageInstances.end()) { 49 sensorManager = iterator->second; 50 } else { 51 String16 opPackageName = packageName; 52 53 // It is possible that the calling code has no access to the package name. 54 // In this case we will get the packages for the calling UID and pick the 55 // first one for attributing the app op. This will work correctly for 56 // runtime permissions as for legacy apps we will toggle the app op for 57 // all packages in the UID. The caveat is that the operation may be attributed 58 // to the wrong package and stats based on app ops may be slightly off. 59 if (opPackageName.size() <= 0) { 60 sp<IBinder> binder = defaultServiceManager()->getService(String16("permission")); 61 if (binder != 0) { 62 const uid_t uid = IPCThreadState::self()->getCallingUid(); 63 Vector<String16> packages; 64 interface_cast<IPermissionController>(binder)->getPackagesForUid(uid, packages); 65 if (!packages.isEmpty()) { 66 opPackageName = packages[0]; 67 } else { 68 ALOGE("No packages for calling UID"); 69 } 70 } else { 71 ALOGE("Cannot get permission service"); 72 } 73 } 74 75 sensorManager = new SensorManager(opPackageName); 76 77 // If we had no package name, we looked it up from the UID and the sensor 78 // manager instance we created should also be mapped to the empty package 79 // name, to avoid looking up the packages for a UID and get the same result. 80 if (packageName.size() <= 0) { 81 sPackageInstances.insert(std::make_pair(String16(), sensorManager)); 82 } 83 84 // Stash the per package sensor manager. 85 sPackageInstances.insert(std::make_pair(opPackageName, sensorManager)); 86 } 87 88 return *sensorManager; 89 } 90 91 SensorManager::SensorManager(const String16& opPackageName) 92 : mSensorList(0), mOpPackageName(opPackageName) { 93 // okay we're not locked here, but it's not needed during construction 94 assertStateLocked(); 95 } 96 97 SensorManager::~SensorManager() { 98 free(mSensorList); 99 } 100 101 void SensorManager::sensorManagerDied() { 102 Mutex::Autolock _l(mLock); 103 mSensorServer.clear(); 104 free(mSensorList); 105 mSensorList = NULL; 106 mSensors.clear(); 107 } 108 109 status_t SensorManager::assertStateLocked() { 110 bool initSensorManager = false; 111 if (mSensorServer == NULL) { 112 initSensorManager = true; 113 } else { 114 // Ping binder to check if sensorservice is alive. 115 status_t err = IInterface::asBinder(mSensorServer)->pingBinder(); 116 if (err != NO_ERROR) { 117 initSensorManager = true; 118 } 119 } 120 if (initSensorManager) { 121 // try for 300 seconds (60*5(getService() tries for 5 seconds)) before giving up ... 122 const String16 name("sensorservice"); 123 for (int i = 0; i < 60; i++) { 124 status_t err = getService(name, &mSensorServer); 125 if (err == NAME_NOT_FOUND) { 126 sleep(1); 127 continue; 128 } 129 if (err != NO_ERROR) { 130 return err; 131 } 132 break; 133 } 134 135 class DeathObserver : public IBinder::DeathRecipient { 136 SensorManager& mSensorManager; 137 virtual void binderDied(const wp<IBinder>& who) { 138 ALOGW("sensorservice died [%p]", who.unsafe_get()); 139 mSensorManager.sensorManagerDied(); 140 } 141 public: 142 DeathObserver(SensorManager& mgr) : mSensorManager(mgr) { } 143 }; 144 145 LOG_ALWAYS_FATAL_IF(mSensorServer.get() == NULL, "getService(SensorService) NULL"); 146 147 mDeathObserver = new DeathObserver(*const_cast<SensorManager *>(this)); 148 IInterface::asBinder(mSensorServer)->linkToDeath(mDeathObserver); 149 150 mSensors = mSensorServer->getSensorList(mOpPackageName); 151 size_t count = mSensors.size(); 152 mSensorList = 153 static_cast<Sensor const**>(malloc(count * sizeof(Sensor*))); 154 LOG_ALWAYS_FATAL_IF(mSensorList == NULL, "mSensorList NULL"); 155 156 for (size_t i=0 ; i<count ; i++) { 157 mSensorList[i] = mSensors.array() + i; 158 } 159 } 160 161 return NO_ERROR; 162 } 163 164 ssize_t SensorManager::getSensorList(Sensor const* const** list) { 165 Mutex::Autolock _l(mLock); 166 status_t err = assertStateLocked(); 167 if (err < 0) { 168 return static_cast<ssize_t>(err); 169 } 170 *list = mSensorList; 171 return static_cast<ssize_t>(mSensors.size()); 172 } 173 174 ssize_t SensorManager::getDynamicSensorList(Vector<Sensor> & dynamicSensors) { 175 Mutex::Autolock _l(mLock); 176 status_t err = assertStateLocked(); 177 if (err < 0) { 178 return static_cast<ssize_t>(err); 179 } 180 181 dynamicSensors = mSensorServer->getDynamicSensorList(mOpPackageName); 182 size_t count = dynamicSensors.size(); 183 184 return static_cast<ssize_t>(count); 185 } 186 187 Sensor const* SensorManager::getDefaultSensor(int type) 188 { 189 Mutex::Autolock _l(mLock); 190 if (assertStateLocked() == NO_ERROR) { 191 bool wakeUpSensor = false; 192 // For the following sensor types, return a wake-up sensor. These types are by default 193 // defined as wake-up sensors. For the rest of the sensor types defined in sensors.h return 194 // a non_wake-up version. 195 if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION || 196 type == SENSOR_TYPE_TILT_DETECTOR || type == SENSOR_TYPE_WAKE_GESTURE || 197 type == SENSOR_TYPE_GLANCE_GESTURE || type == SENSOR_TYPE_PICK_UP_GESTURE) { 198 wakeUpSensor = true; 199 } 200 // For now we just return the first sensor of that type we find. 201 // in the future it will make sense to let the SensorService make 202 // that decision. 203 for (size_t i=0 ; i<mSensors.size() ; i++) { 204 if (mSensorList[i]->getType() == type && 205 mSensorList[i]->isWakeUpSensor() == wakeUpSensor) { 206 return mSensorList[i]; 207 } 208 } 209 } 210 return NULL; 211 } 212 213 sp<SensorEventQueue> SensorManager::createEventQueue(String8 packageName, int mode) { 214 sp<SensorEventQueue> queue; 215 216 Mutex::Autolock _l(mLock); 217 while (assertStateLocked() == NO_ERROR) { 218 sp<ISensorEventConnection> connection = 219 mSensorServer->createSensorEventConnection(packageName, mode, mOpPackageName); 220 if (connection == NULL) { 221 // SensorService just died or the app doesn't have required permissions. 222 ALOGE("createEventQueue: connection is NULL."); 223 return NULL; 224 } 225 queue = new SensorEventQueue(connection); 226 break; 227 } 228 return queue; 229 } 230 231 bool SensorManager::isDataInjectionEnabled() { 232 Mutex::Autolock _l(mLock); 233 if (assertStateLocked() == NO_ERROR) { 234 return mSensorServer->isDataInjectionEnabled(); 235 } 236 return false; 237 } 238 239 // ---------------------------------------------------------------------------- 240 }; // namespace android 241
