SensorManager.cpp revision fe5476a3cc7323f2142c58333984fb98dec50376 
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 <sensor/SensorManager.h>
20
21#include <stdint.h>
22#include <sys/types.h>
23
24#include <cutils/native_handle.h>
25#include <utils/Errors.h>
26#include <utils/RefBase.h>
27#include <utils/Singleton.h>
28
29#include <binder/IBinder.h>
30#include <binder/IServiceManager.h>
31
32#include <sensor/ISensorServer.h>
33#include <sensor/ISensorEventConnection.h>
34#include <sensor/Sensor.h>
35#include <sensor/SensorEventQueue.h>
36
37// ----------------------------------------------------------------------------
38namespace android {
39// ----------------------------------------------------------------------------
40
41Mutex SensorManager::sLock;
42std::map<String16, SensorManager*> SensorManager::sPackageInstances;
43
44SensorManager& SensorManager::getInstanceForPackage(const String16& packageName) {
45    waitForSensorService(nullptr);
46
47    Mutex::Autolock _l(sLock);
48    SensorManager* sensorManager;
49    auto iterator = sPackageInstances.find(packageName);
50
51    if (iterator != sPackageInstances.end()) {
52        sensorManager = iterator->second;
53    } else {
54        String16 opPackageName = packageName;
55
56        // It is possible that the calling code has no access to the package name.
57        // In this case we will get the packages for the calling UID and pick the
58        // first one for attributing the app op. This will work correctly for
59        // runtime permissions as for legacy apps we will toggle the app op for
60        // all packages in the UID. The caveat is that the operation may be attributed
61        // to the wrong package and stats based on app ops may be slightly off.
62        if (opPackageName.size() <= 0) {
63            sp<IBinder> binder = defaultServiceManager()->getService(String16("permission"));
64            if (binder != 0) {
65                const uid_t uid = IPCThreadState::self()->getCallingUid();
66                Vector<String16> packages;
67                interface_cast<IPermissionController>(binder)->getPackagesForUid(uid, packages);
68                if (!packages.isEmpty()) {
69                    opPackageName = packages[0];
70                } else {
71                    ALOGE("No packages for calling UID");
72                }
73            } else {
74                ALOGE("Cannot get permission service");
75            }
76        }
77
78        sensorManager = new SensorManager(opPackageName);
79
80        // If we had no package name, we looked it up from the UID and the sensor
81        // manager instance we created should also be mapped to the empty package
82        // name, to avoid looking up the packages for a UID and get the same result.
83        if (packageName.size() <= 0) {
84            sPackageInstances.insert(std::make_pair(String16(), sensorManager));
85        }
86
87        // Stash the per package sensor manager.
88        sPackageInstances.insert(std::make_pair(opPackageName, sensorManager));
89    }
90
91    return *sensorManager;
92}
93
94SensorManager::SensorManager(const String16& opPackageName)
95    : mSensorList(0), mOpPackageName(opPackageName), mDirectConnectionHandle(1) {
96    // okay we're not locked here, but it's not needed during construction
97    assertStateLocked();
98}
99
100SensorManager::~SensorManager() {
101    free(mSensorList);
102}
103
104status_t SensorManager::waitForSensorService(sp<ISensorServer> *server) {
105    // try for 300 seconds (60*5(getService() tries for 5 seconds)) before giving up ...
106    sp<ISensorServer> s;
107    const String16 name("sensorservice");
108    for (int i = 0; i < 60; i++) {
109        status_t err = getService(name, &s);
110        switch (err) {
111            case NAME_NOT_FOUND:
112                sleep(1);
113                continue;
114            case NO_ERROR:
115                if (server != nullptr) {
116                    *server = s;
117                }
118                return NO_ERROR;
119            default:
120                return err;
121        }
122    }
123    return TIMED_OUT;
124}
125
126void SensorManager::sensorManagerDied() {
127    Mutex::Autolock _l(mLock);
128    mSensorServer.clear();
129    free(mSensorList);
130    mSensorList = NULL;
131    mSensors.clear();
132}
133
134status_t SensorManager::assertStateLocked() {
135    bool initSensorManager = false;
136    if (mSensorServer == NULL) {
137        initSensorManager = true;
138    } else {
139        // Ping binder to check if sensorservice is alive.
140        status_t err = IInterface::asBinder(mSensorServer)->pingBinder();
141        if (err != NO_ERROR) {
142            initSensorManager = true;
143        }
144    }
145    if (initSensorManager) {
146        waitForSensorService(&mSensorServer);
147        LOG_ALWAYS_FATAL_IF(mSensorServer == nullptr, "getService(SensorService) NULL");
148
149        class DeathObserver : public IBinder::DeathRecipient {
150            SensorManager& mSensorManager;
151            virtual void binderDied(const wp<IBinder>& who) {
152                ALOGW("sensorservice died [%p]", who.unsafe_get());
153                mSensorManager.sensorManagerDied();
154            }
155        public:
156            explicit DeathObserver(SensorManager& mgr) : mSensorManager(mgr) { }
157        };
158
159        mDeathObserver = new DeathObserver(*const_cast<SensorManager *>(this));
160        IInterface::asBinder(mSensorServer)->linkToDeath(mDeathObserver);
161
162        mSensors = mSensorServer->getSensorList(mOpPackageName);
163        size_t count = mSensors.size();
164        mSensorList =
165                static_cast<Sensor const**>(malloc(count * sizeof(Sensor*)));
166        LOG_ALWAYS_FATAL_IF(mSensorList == NULL, "mSensorList NULL");
167
168        for (size_t i=0 ; i<count ; i++) {
169            mSensorList[i] = mSensors.array() + i;
170        }
171    }
172
173    return NO_ERROR;
174}
175
176ssize_t SensorManager::getSensorList(Sensor const* const** list) {
177    Mutex::Autolock _l(mLock);
178    status_t err = assertStateLocked();
179    if (err < 0) {
180        return static_cast<ssize_t>(err);
181    }
182    *list = mSensorList;
183    return static_cast<ssize_t>(mSensors.size());
184}
185
186ssize_t SensorManager::getDynamicSensorList(Vector<Sensor> & dynamicSensors) {
187    Mutex::Autolock _l(mLock);
188    status_t err = assertStateLocked();
189    if (err < 0) {
190        return static_cast<ssize_t>(err);
191    }
192
193    dynamicSensors = mSensorServer->getDynamicSensorList(mOpPackageName);
194    size_t count = dynamicSensors.size();
195
196    return static_cast<ssize_t>(count);
197}
198
199Sensor const* SensorManager::getDefaultSensor(int type)
200{
201    Mutex::Autolock _l(mLock);
202    if (assertStateLocked() == NO_ERROR) {
203        bool wakeUpSensor = false;
204        // For the following sensor types, return a wake-up sensor. These types are by default
205        // defined as wake-up sensors. For the rest of the sensor types defined in sensors.h return
206        // a non_wake-up version.
207        if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION ||
208            type == SENSOR_TYPE_TILT_DETECTOR || type == SENSOR_TYPE_WAKE_GESTURE ||
209            type == SENSOR_TYPE_GLANCE_GESTURE || type == SENSOR_TYPE_PICK_UP_GESTURE ||
210            type == SENSOR_TYPE_WRIST_TILT_GESTURE ||
211            type == SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT) {
212            wakeUpSensor = true;
213        }
214        // For now we just return the first sensor of that type we find.
215        // in the future it will make sense to let the SensorService make
216        // that decision.
217        for (size_t i=0 ; i<mSensors.size() ; i++) {
218            if (mSensorList[i]->getType() == type &&
219                mSensorList[i]->isWakeUpSensor() == wakeUpSensor) {
220                return mSensorList[i];
221            }
222        }
223    }
224    return NULL;
225}
226
227sp<SensorEventQueue> SensorManager::createEventQueue(String8 packageName, int mode) {
228    sp<SensorEventQueue> queue;
229
230    Mutex::Autolock _l(mLock);
231    while (assertStateLocked() == NO_ERROR) {
232        sp<ISensorEventConnection> connection =
233                mSensorServer->createSensorEventConnection(packageName, mode, mOpPackageName);
234        if (connection == NULL) {
235            // SensorService just died or the app doesn't have required permissions.
236            ALOGE("createEventQueue: connection is NULL.");
237            return NULL;
238        }
239        queue = new SensorEventQueue(connection);
240        break;
241    }
242    return queue;
243}
244
245bool SensorManager::isDataInjectionEnabled() {
246    Mutex::Autolock _l(mLock);
247    if (assertStateLocked() == NO_ERROR) {
248        return mSensorServer->isDataInjectionEnabled();
249    }
250    return false;
251}
252
253int SensorManager::createDirectChannel(
254        size_t size, int channelType, const native_handle_t *resourceHandle) {
255    Mutex::Autolock _l(mLock);
256    if (assertStateLocked() != NO_ERROR) {
257        return NO_INIT;
258    }
259
260    if (channelType != SENSOR_DIRECT_MEM_TYPE_ASHMEM
261            && channelType != SENSOR_DIRECT_MEM_TYPE_GRALLOC) {
262        ALOGE("Bad channel shared memory type %d", channelType);
263        return BAD_VALUE;
264    }
265
266    sp<ISensorEventConnection> conn =
267              mSensorServer->createSensorDirectConnection(mOpPackageName,
268                  static_cast<uint32_t>(size),
269                  static_cast<int32_t>(channelType),
270                  SENSOR_DIRECT_FMT_SENSORS_EVENT, resourceHandle);
271    if (conn == nullptr) {
272        return NO_MEMORY;
273    }
274
275    int nativeHandle = mDirectConnectionHandle++;
276    mDirectConnection.emplace(nativeHandle, conn);
277    return nativeHandle;
278}
279
280void SensorManager::destroyDirectChannel(int channelNativeHandle) {
281    Mutex::Autolock _l(mLock);
282    if (assertStateLocked() == NO_ERROR) {
283        mDirectConnection.erase(channelNativeHandle);
284    }
285}
286
287int SensorManager::configureDirectChannel(int channelNativeHandle, int sensorHandle, int rateLevel) {
288    Mutex::Autolock _l(mLock);
289    if (assertStateLocked() != NO_ERROR) {
290        return NO_INIT;
291    }
292
293    auto i = mDirectConnection.find(channelNativeHandle);
294    if (i == mDirectConnection.end()) {
295        ALOGE("Cannot find the handle in client direct connection table");
296        return BAD_VALUE;
297    }
298
299    int ret;
300    ret = i->second->configureChannel(sensorHandle, rateLevel);
301    ALOGE_IF(ret < 0, "SensorManager::configureChannel (%d, %d) returns %d",
302            static_cast<int>(sensorHandle), static_cast<int>(rateLevel),
303            static_cast<int>(ret));
304    return ret;
305}
306
307// ----------------------------------------------------------------------------
308}; // namespace android
309