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// ----------------------------------------------------------------------------
36namespace android {
37// ----------------------------------------------------------------------------
38
39android::Mutex android::SensorManager::sLock;
40std::map<String16, SensorManager*> android::SensorManager::sPackageInstances;
41
42SensorManager& 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
91SensorManager::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
97SensorManager::~SensorManager() {
98    free(mSensorList);
99}
100
101void SensorManager::sensorManagerDied() {
102    Mutex::Autolock _l(mLock);
103    mSensorServer.clear();
104    free(mSensorList);
105    mSensorList = NULL;
106    mSensors.clear();
107}
108
109status_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
164ssize_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
174ssize_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
187Sensor 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
213sp<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
231bool 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