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
getInstanceForPackage(const String16 & packageName)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
SensorManager(const String16 & opPackageName)91 SensorManager::SensorManager(const String16& opPackageName)
92 : mSensorList(0), mOpPackageName(opPackageName)
93 {
94 // okay we're not locked here, but it's not needed during construction
95 assertStateLocked();
96 }
97
~SensorManager()98 SensorManager::~SensorManager()
99 {
100 free(mSensorList);
101 }
102
sensorManagerDied()103 void SensorManager::sensorManagerDied()
104 {
105 Mutex::Autolock _l(mLock);
106 mSensorServer.clear();
107 free(mSensorList);
108 mSensorList = NULL;
109 mSensors.clear();
110 }
111
assertStateLocked() const112 status_t SensorManager::assertStateLocked() const {
113 bool initSensorManager = false;
114 if (mSensorServer == NULL) {
115 initSensorManager = true;
116 } else {
117 // Ping binder to check if sensorservice is alive.
118 status_t err = IInterface::asBinder(mSensorServer)->pingBinder();
119 if (err != NO_ERROR) {
120 initSensorManager = true;
121 }
122 }
123 if (initSensorManager) {
124 // try for 300 seconds (60*5(getService() tries for 5 seconds)) before giving up ...
125 const String16 name("sensorservice");
126 for (int i = 0; i < 60; i++) {
127 status_t err = getService(name, &mSensorServer);
128 if (err == NAME_NOT_FOUND) {
129 sleep(1);
130 continue;
131 }
132 if (err != NO_ERROR) {
133 return err;
134 }
135 break;
136 }
137
138 class DeathObserver : public IBinder::DeathRecipient {
139 SensorManager& mSensorManger;
140 virtual void binderDied(const wp<IBinder>& who) {
141 ALOGW("sensorservice died [%p]", who.unsafe_get());
142 mSensorManger.sensorManagerDied();
143 }
144 public:
145 DeathObserver(SensorManager& mgr) : mSensorManger(mgr) { }
146 };
147
148 LOG_ALWAYS_FATAL_IF(mSensorServer.get() == NULL, "getService(SensorService) NULL");
149
150 mDeathObserver = new DeathObserver(*const_cast<SensorManager *>(this));
151 IInterface::asBinder(mSensorServer)->linkToDeath(mDeathObserver);
152
153 mSensors = mSensorServer->getSensorList(mOpPackageName);
154 size_t count = mSensors.size();
155 mSensorList =
156 static_cast<Sensor const**>(malloc(count * sizeof(Sensor*)));
157 LOG_ALWAYS_FATAL_IF(mSensorList == NULL, "mSensorList NULL");
158
159 for (size_t i=0 ; i<count ; i++) {
160 mSensorList[i] = mSensors.array() + i;
161 }
162 }
163
164 return NO_ERROR;
165 }
166
getSensorList(Sensor const * const ** list) const167 ssize_t SensorManager::getSensorList(Sensor const* const** list) const
168 {
169 Mutex::Autolock _l(mLock);
170 status_t err = assertStateLocked();
171 if (err < 0) {
172 return static_cast<ssize_t>(err);
173 }
174 *list = mSensorList;
175 return static_cast<ssize_t>(mSensors.size());
176 }
177
getDefaultSensor(int type)178 Sensor const* SensorManager::getDefaultSensor(int type)
179 {
180 Mutex::Autolock _l(mLock);
181 if (assertStateLocked() == NO_ERROR) {
182 bool wakeUpSensor = false;
183 // For the following sensor types, return a wake-up sensor. These types are by default
184 // defined as wake-up sensors. For the rest of the sensor types defined in sensors.h return
185 // a non_wake-up version.
186 if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION ||
187 type == SENSOR_TYPE_TILT_DETECTOR || type == SENSOR_TYPE_WAKE_GESTURE ||
188 type == SENSOR_TYPE_GLANCE_GESTURE || type == SENSOR_TYPE_PICK_UP_GESTURE) {
189 wakeUpSensor = true;
190 }
191 // For now we just return the first sensor of that type we find.
192 // in the future it will make sense to let the SensorService make
193 // that decision.
194 for (size_t i=0 ; i<mSensors.size() ; i++) {
195 if (mSensorList[i]->getType() == type &&
196 mSensorList[i]->isWakeUpSensor() == wakeUpSensor) {
197 return mSensorList[i];
198 }
199 }
200 }
201 return NULL;
202 }
203
createEventQueue(String8 packageName,int mode)204 sp<SensorEventQueue> SensorManager::createEventQueue(String8 packageName, int mode) {
205 sp<SensorEventQueue> queue;
206
207 Mutex::Autolock _l(mLock);
208 while (assertStateLocked() == NO_ERROR) {
209 sp<ISensorEventConnection> connection =
210 mSensorServer->createSensorEventConnection(packageName, mode, mOpPackageName);
211 if (connection == NULL) {
212 // SensorService just died or the app doesn't have required permissions.
213 ALOGE("createEventQueue: connection is NULL.");
214 return NULL;
215 }
216 queue = new SensorEventQueue(connection);
217 break;
218 }
219 return queue;
220 }
221
isDataInjectionEnabled()222 bool SensorManager::isDataInjectionEnabled() {
223 Mutex::Autolock _l(mLock);
224 if (assertStateLocked() == NO_ERROR) {
225 return mSensorServer->isDataInjectionEnabled();
226 }
227 return false;
228 }
229
230 // ----------------------------------------------------------------------------
231 }; // namespace android
232