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        mSensorServer->asBinder()->linkToDeath(mDeathObserver);
90
91        mSensors = mSensorServer->getSensorList();
92        size_t count = mSensors.size();
93        mSensorList = (Sensor const**)malloc(count * sizeof(Sensor*));
94        for (size_t i=0 ; i<count ; i++) {
95            mSensorList[i] = mSensors.array() + i;
96        }
97    }
98
99    return NO_ERROR;
100}
101
102
103
104ssize_t SensorManager::getSensorList(Sensor const* const** list) const
105{
106    Mutex::Autolock _l(mLock);
107    status_t err = assertStateLocked();
108    if (err < 0) {
109        return ssize_t(err);
110    }
111    *list = mSensorList;
112    return mSensors.size();
113}
114
115Sensor const* SensorManager::getDefaultSensor(int type)
116{
117    Mutex::Autolock _l(mLock);
118    if (assertStateLocked() == NO_ERROR) {
119        bool wakeUpSensor = false;
120        // For the following sensor types, return a wake-up sensor. These types are by default
121        // defined as wake-up sensors. For the rest of the sensor types defined in sensors.h return
122        // a non_wake-up version.
123        if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION ||
124            type == SENSOR_TYPE_TILT_DETECTOR || type == SENSOR_TYPE_WAKE_GESTURE ||
125            type == SENSOR_TYPE_GLANCE_GESTURE || type == SENSOR_TYPE_PICK_UP_GESTURE) {
126            wakeUpSensor = true;
127        }
128        // For now we just return the first sensor of that type we find.
129        // in the future it will make sense to let the SensorService make
130        // that decision.
131        for (size_t i=0 ; i<mSensors.size() ; i++) {
132            if (mSensorList[i]->getType() == type &&
133                mSensorList[i]->isWakeUpSensor() == wakeUpSensor) {
134                return mSensorList[i];
135            }
136        }
137    }
138    return NULL;
139}
140
141sp<SensorEventQueue> SensorManager::createEventQueue()
142{
143    sp<SensorEventQueue> queue;
144
145    Mutex::Autolock _l(mLock);
146    while (assertStateLocked() == NO_ERROR) {
147        sp<ISensorEventConnection> connection =
148                mSensorServer->createSensorEventConnection();
149        if (connection == NULL) {
150            // SensorService just died.
151            ALOGE("createEventQueue: connection is NULL. SensorService died.");
152            continue;
153        }
154        queue = new SensorEventQueue(connection);
155        break;
156    }
157    return queue;
158}
159
160// ----------------------------------------------------------------------------
161}; // namespace android
162