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