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
SensorManager(const String16 & opPackageName)39 SensorManager::SensorManager(const String16& opPackageName)
40 : mSensorList(0), mOpPackageName(opPackageName)
41 {
42 // okay we're not locked here, but it's not needed during construction
43 assertStateLocked();
44 }
45
~SensorManager()46 SensorManager::~SensorManager()
47 {
48 free(mSensorList);
49 }
50
sensorManagerDied()51 void SensorManager::sensorManagerDied()
52 {
53 Mutex::Autolock _l(mLock);
54 mSensorServer.clear();
55 free(mSensorList);
56 mSensorList = NULL;
57 mSensors.clear();
58 }
59
assertStateLocked() const60 status_t SensorManager::assertStateLocked() const {
61 if (mSensorServer == NULL) {
62 // try for one second
63 const String16 name("sensorservice");
64 for (int i=0 ; i<4 ; i++) {
65 status_t err = getService(name, &mSensorServer);
66 if (err == NAME_NOT_FOUND) {
67 usleep(250000);
68 continue;
69 }
70 if (err != NO_ERROR) {
71 return err;
72 }
73 break;
74 }
75
76 class DeathObserver : public IBinder::DeathRecipient {
77 SensorManager& mSensorManger;
78 virtual void binderDied(const wp<IBinder>& who) {
79 ALOGW("sensorservice died [%p]", who.unsafe_get());
80 mSensorManger.sensorManagerDied();
81 }
82 public:
83 DeathObserver(SensorManager& mgr) : mSensorManger(mgr) { }
84 };
85
86 mDeathObserver = new DeathObserver(*const_cast<SensorManager *>(this));
87 IInterface::asBinder(mSensorServer)->linkToDeath(mDeathObserver);
88
89 mSensors = mSensorServer->getSensorList(mOpPackageName);
90 size_t count = mSensors.size();
91 mSensorList =
92 static_cast<Sensor const**>(malloc(count * sizeof(Sensor*)));
93 for (size_t i=0 ; i<count ; i++) {
94 mSensorList[i] = mSensors.array() + i;
95 }
96 }
97
98 return NO_ERROR;
99 }
100
getSensorList(Sensor const * const ** list) const101 ssize_t SensorManager::getSensorList(Sensor const* const** list) const
102 {
103 Mutex::Autolock _l(mLock);
104 status_t err = assertStateLocked();
105 if (err < 0) {
106 return static_cast<ssize_t>(err);
107 }
108 *list = mSensorList;
109 return static_cast<ssize_t>(mSensors.size());
110 }
111
getDefaultSensor(int type)112 Sensor const* SensorManager::getDefaultSensor(int type)
113 {
114 Mutex::Autolock _l(mLock);
115 if (assertStateLocked() == NO_ERROR) {
116 bool wakeUpSensor = false;
117 // For the following sensor types, return a wake-up sensor. These types are by default
118 // defined as wake-up sensors. For the rest of the sensor types defined in sensors.h return
119 // a non_wake-up version.
120 if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION ||
121 type == SENSOR_TYPE_TILT_DETECTOR || type == SENSOR_TYPE_WAKE_GESTURE ||
122 type == SENSOR_TYPE_GLANCE_GESTURE || type == SENSOR_TYPE_PICK_UP_GESTURE) {
123 wakeUpSensor = true;
124 }
125 // For now we just return the first sensor of that type we find.
126 // in the future it will make sense to let the SensorService make
127 // that decision.
128 for (size_t i=0 ; i<mSensors.size() ; i++) {
129 if (mSensorList[i]->getType() == type &&
130 mSensorList[i]->isWakeUpSensor() == wakeUpSensor) {
131 return mSensorList[i];
132 }
133 }
134 }
135 return NULL;
136 }
137
createEventQueue(String8 packageName,int mode)138 sp<SensorEventQueue> SensorManager::createEventQueue(String8 packageName, int mode) {
139 sp<SensorEventQueue> queue;
140
141 Mutex::Autolock _l(mLock);
142 while (assertStateLocked() == NO_ERROR) {
143 sp<ISensorEventConnection> connection =
144 mSensorServer->createSensorEventConnection(packageName, mode, mOpPackageName);
145 if (connection == NULL) {
146 // SensorService just died or the app doesn't have required permissions.
147 ALOGE("createEventQueue: connection is NULL.");
148 return NULL;
149 }
150 queue = new SensorEventQueue(connection);
151 break;
152 }
153 return queue;
154 }
155
isDataInjectionEnabled()156 bool SensorManager::isDataInjectionEnabled() {
157 Mutex::Autolock _l(mLock);
158 if (assertStateLocked() == NO_ERROR) {
159 return mSensorServer->isDataInjectionEnabled();
160 }
161 return false;
162 }
163
164 // ----------------------------------------------------------------------------
165 }; // namespace android
166