SensorDevice.cpp revision 50b66767f6c5635430483393e17d15969dfe2f05 
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#include <stdint.h>
18#include <math.h>
19#include <sys/types.h>
20
21#include <utils/Atomic.h>
22#include <utils/Errors.h>
23#include <utils/Singleton.h>
24
25#include <binder/BinderService.h>
26#include <binder/Parcel.h>
27#include <binder/IServiceManager.h>
28
29#include <hardware/sensors.h>
30
31#include "SensorDevice.h"
32
33namespace android {
34// ---------------------------------------------------------------------------
35class BatteryService : public Singleton<BatteryService> {
36    static const int TRANSACTION_noteStartSensor = IBinder::FIRST_CALL_TRANSACTION + 3;
37    static const int TRANSACTION_noteStopSensor = IBinder::FIRST_CALL_TRANSACTION + 4;
38    static const String16 DESCRIPTOR;
39
40    friend class Singleton<BatteryService>;
41    sp<IBinder> mBatteryStatService;
42
43    BatteryService() {
44        const sp<IServiceManager> sm(defaultServiceManager());
45        if (sm != NULL) {
46            const String16 name("batteryinfo");
47            mBatteryStatService = sm->getService(name);
48        }
49    }
50
51    status_t noteStartSensor(int uid, int handle) {
52        Parcel data, reply;
53        data.writeInterfaceToken(DESCRIPTOR);
54        data.writeInt32(uid);
55        data.writeInt32(handle);
56        status_t err = mBatteryStatService->transact(
57                TRANSACTION_noteStartSensor, data, &reply, 0);
58        err = reply.readExceptionCode();
59        return err;
60    }
61
62    status_t noteStopSensor(int uid, int handle) {
63        Parcel data, reply;
64        data.writeInterfaceToken(DESCRIPTOR);
65        data.writeInt32(uid);
66        data.writeInt32(handle);
67        status_t err = mBatteryStatService->transact(
68                TRANSACTION_noteStopSensor, data, &reply, 0);
69        err = reply.readExceptionCode();
70        return err;
71    }
72
73public:
74    void enableSensor(int handle) {
75        if (mBatteryStatService != 0) {
76            int uid = IPCThreadState::self()->getCallingUid();
77            int64_t identity = IPCThreadState::self()->clearCallingIdentity();
78            noteStartSensor(uid, handle);
79            IPCThreadState::self()->restoreCallingIdentity(identity);
80        }
81    }
82    void disableSensor(int handle) {
83        if (mBatteryStatService != 0) {
84            int uid = IPCThreadState::self()->getCallingUid();
85            int64_t identity = IPCThreadState::self()->clearCallingIdentity();
86            noteStopSensor(uid, handle);
87            IPCThreadState::self()->restoreCallingIdentity(identity);
88        }
89    }
90};
91
92const String16 BatteryService::DESCRIPTOR("com.android.internal.app.IBatteryStats");
93
94ANDROID_SINGLETON_STATIC_INSTANCE(BatteryService)
95
96// ---------------------------------------------------------------------------
97
98ANDROID_SINGLETON_STATIC_INSTANCE(SensorDevice)
99
100SensorDevice::SensorDevice()
101    :  mSensorDevice(0),
102       mSensorModule(0)
103{
104    status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,
105            (hw_module_t const**)&mSensorModule);
106
107    LOGE_IF(err, "couldn't load %s module (%s)",
108            SENSORS_HARDWARE_MODULE_ID, strerror(-err));
109
110    if (mSensorModule) {
111        err = sensors_open(&mSensorModule->common, &mSensorDevice);
112
113        LOGE_IF(err, "couldn't open device for module %s (%s)",
114                SENSORS_HARDWARE_MODULE_ID, strerror(-err));
115
116        if (mSensorDevice) {
117            sensor_t const* list;
118            ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
119            mActivationCount.setCapacity(count);
120            Info model;
121            for (size_t i=0 ; i<size_t(count) ; i++) {
122                mActivationCount.add(list[i].handle, model);
123                mSensorDevice->activate(mSensorDevice, list[i].handle, 0);
124            }
125        }
126    }
127}
128
129void SensorDevice::dump(String8& result, char* buffer, size_t SIZE)
130{
131    if (!mSensorModule) return;
132    sensor_t const* list;
133    ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
134
135    snprintf(buffer, SIZE, "%d h/w sensors:\n", int(count));
136    result.append(buffer);
137
138    Mutex::Autolock _l(mLock);
139    for (size_t i=0 ; i<size_t(count) ; i++) {
140        snprintf(buffer, SIZE, "handle=0x%08x, active-count=%d\n",
141                list[i].handle,
142                mActivationCount.valueFor(list[i].handle).rates.size());
143        result.append(buffer);
144    }
145}
146
147ssize_t SensorDevice::getSensorList(sensor_t const** list) {
148    if (!mSensorModule) return NO_INIT;
149    ssize_t count = mSensorModule->get_sensors_list(mSensorModule, list);
150    return count;
151}
152
153status_t SensorDevice::initCheck() const {
154    return mSensorDevice && mSensorModule ? NO_ERROR : NO_INIT;
155}
156
157ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
158    if (!mSensorDevice) return NO_INIT;
159    return mSensorDevice->poll(mSensorDevice, buffer, count);
160}
161
162status_t SensorDevice::activate(void* ident, int handle, int enabled)
163{
164    if (!mSensorDevice) return NO_INIT;
165    status_t err(NO_ERROR);
166    bool actuateHardware = false;
167
168    Info& info( mActivationCount.editValueFor(handle) );
169    if (enabled) {
170        Mutex::Autolock _l(mLock);
171        if (info.rates.indexOfKey(ident) < 0) {
172            info.rates.add(ident, DEFAULT_EVENTS_PERIOD);
173            actuateHardware = true;
174        } else {
175            // sensor was already activated for this ident
176        }
177    } else {
178        Mutex::Autolock _l(mLock);
179        if (info.rates.removeItem(ident) >= 0) {
180            if (info.rates.size() == 0) {
181                actuateHardware = true;
182            }
183        } else {
184            // sensor wasn't enabled for this ident
185        }
186    }
187
188    if (actuateHardware) {
189        err = mSensorDevice->activate(mSensorDevice, handle, enabled);
190        if (enabled) {
191            LOGE_IF(err, "Error activating sensor %d (%s)", handle, strerror(-err));
192            if (err == 0) {
193                BatteryService::getInstance().enableSensor(handle);
194            }
195        } else {
196            if (err == 0) {
197                BatteryService::getInstance().disableSensor(handle);
198            }
199        }
200    }
201
202    if (!actuateHardware || enabled) {
203        Mutex::Autolock _l(mLock);
204        nsecs_t ns = info.rates.valueAt(0);
205        for (size_t i=1 ; i<info.rates.size() ; i++) {
206            if (info.rates.valueAt(i) < ns) {
207                nsecs_t cur = info.rates.valueAt(i);
208                if (cur < ns) {
209                    ns = cur;
210                }
211            }
212        }
213        mSensorDevice->setDelay(mSensorDevice, handle, ns);
214    }
215
216    return err;
217}
218
219status_t SensorDevice::setDelay(void* ident, int handle, int64_t ns)
220{
221    if (!mSensorDevice) return NO_INIT;
222    Info& info( mActivationCount.editValueFor(handle) );
223    { // scope for lock
224        Mutex::Autolock _l(mLock);
225        ssize_t index = info.rates.indexOfKey(ident);
226        if (index < 0) return BAD_INDEX;
227        info.rates.editValueAt(index) = ns;
228        ns = info.rates.valueAt(0);
229        for (size_t i=1 ; i<info.rates.size() ; i++) {
230            nsecs_t cur = info.rates.valueAt(i);
231            if (cur < ns) {
232                ns = cur;
233            }
234        }
235    }
236    return mSensorDevice->setDelay(mSensorDevice, handle, ns);
237}
238
239// ---------------------------------------------------------------------------
240}; // namespace android
241
242