1/*
2 * Copyright (C) 2009 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 "sensor"
18#include <utils/Log.h>
19
20#include <android/looper.h>
21#include <android/sensor.h>
22
23#include <utils/RefBase.h>
24#include <utils/Looper.h>
25#include <utils/Timers.h>
26
27#include <gui/Sensor.h>
28#include <gui/SensorManager.h>
29#include <gui/SensorEventQueue.h>
30
31#include <poll.h>
32
33using android::sp;
34using android::Sensor;
35using android::SensorManager;
36using android::SensorEventQueue;
37using android::String8;
38using android::String16;
39
40/*****************************************************************************/
41ASensorManager* ASensorManager_getInstance()
42{
43    return ASensorManager_getInstanceForPackage(NULL);
44}
45
46ASensorManager* ASensorManager_getInstanceForPackage(const char* packageName)
47{
48    if (packageName) {
49        return &SensorManager::getInstanceForPackage(String16(packageName));
50    } else {
51        return &SensorManager::getInstanceForPackage(String16());
52    }
53}
54
55int ASensorManager_getSensorList(ASensorManager* manager,
56        ASensorList* list)
57{
58    Sensor const* const* l;
59    int c = static_cast<SensorManager*>(manager)->getSensorList(&l);
60    if (list) {
61        *list = reinterpret_cast<ASensorList>(l);
62    }
63    return c;
64}
65
66ASensor const* ASensorManager_getDefaultSensor(ASensorManager* manager, int type)
67{
68    return static_cast<SensorManager*>(manager)->getDefaultSensor(type);
69}
70
71ASensor const* ASensorManager_getDefaultSensorEx(ASensorManager* manager,
72        int type, bool wakeUp) {
73    Sensor const* const* sensorList;
74    size_t size = static_cast<SensorManager*>(manager)->getSensorList(&sensorList);
75    for (size_t i = 0; i < size; ++i) {
76        if (ASensor_getType(sensorList[i]) == type &&
77            ASensor_isWakeUpSensor(sensorList[i]) == wakeUp) {
78            return reinterpret_cast<ASensor const *>(sensorList[i]);
79       }
80    }
81    return NULL;
82}
83
84ASensorEventQueue* ASensorManager_createEventQueue(ASensorManager* manager,
85        ALooper* looper, int ident, ALooper_callbackFunc callback, void* data)
86{
87    sp<SensorEventQueue> queue =
88            static_cast<SensorManager*>(manager)->createEventQueue();
89    if (queue != 0) {
90        ALooper_addFd(looper, queue->getFd(), ident, ALOOPER_EVENT_INPUT, callback, data);
91        queue->looper = looper;
92        queue->incStrong(manager);
93    }
94    return static_cast<ASensorEventQueue*>(queue.get());
95}
96
97int ASensorManager_destroyEventQueue(ASensorManager* manager,
98        ASensorEventQueue* inQueue)
99{
100    sp<SensorEventQueue> queue = static_cast<SensorEventQueue*>(inQueue);
101    ALooper_removeFd(queue->looper, queue->getFd());
102    queue->decStrong(manager);
103    return 0;
104}
105
106/*****************************************************************************/
107
108int ASensorEventQueue_registerSensor(ASensorEventQueue* queue, ASensor const* sensor,
109        int32_t samplingPeriodUs, int maxBatchReportLatencyUs)
110{
111    return static_cast<SensorEventQueue*>(queue)->enableSensor(
112            static_cast<Sensor const*>(sensor)->getHandle(), samplingPeriodUs,
113                    maxBatchReportLatencyUs, 0);
114}
115
116int ASensorEventQueue_enableSensor(ASensorEventQueue* queue, ASensor const* sensor)
117{
118    return static_cast<SensorEventQueue*>(queue)->enableSensor(
119            static_cast<Sensor const*>(sensor));
120}
121
122int ASensorEventQueue_disableSensor(ASensorEventQueue* queue, ASensor const* sensor)
123{
124    return static_cast<SensorEventQueue*>(queue)->disableSensor(
125            static_cast<Sensor const*>(sensor));
126}
127
128int ASensorEventQueue_setEventRate(ASensorEventQueue* queue, ASensor const* sensor,
129        int32_t usec)
130{
131    return static_cast<SensorEventQueue*>(queue)->setEventRate(
132            static_cast<Sensor const*>(sensor), us2ns(usec));
133}
134
135int ASensorEventQueue_hasEvents(ASensorEventQueue* queue)
136{
137    struct pollfd pfd;
138    pfd.fd = static_cast<SensorEventQueue*>(queue)->getFd();
139    pfd.events = POLLIN;
140    pfd.revents = 0;
141
142    int nfd = poll(&pfd, 1, 0);
143
144    if (nfd < 0)
145        return -errno;
146
147    if (pfd.revents != POLLIN)
148        return -1;
149
150    return (nfd == 0) ? 0 : 1;
151}
152
153ssize_t ASensorEventQueue_getEvents(ASensorEventQueue* queue,
154                ASensorEvent* events, size_t count)
155{
156    ssize_t actual = static_cast<SensorEventQueue*>(queue)->read(events, count);
157    if (actual > 0) {
158        static_cast<SensorEventQueue*>(queue)->sendAck(events, actual);
159    }
160    return actual;
161}
162
163/*****************************************************************************/
164
165const char* ASensor_getName(ASensor const* sensor)
166{
167    return static_cast<Sensor const*>(sensor)->getName().string();
168}
169
170const char* ASensor_getVendor(ASensor const* sensor)
171{
172    return static_cast<Sensor const*>(sensor)->getVendor().string();
173}
174
175int ASensor_getType(ASensor const* sensor)
176{
177    return static_cast<Sensor const*>(sensor)->getType();
178}
179
180float ASensor_getResolution(ASensor const* sensor)
181{
182    return static_cast<Sensor const*>(sensor)->getResolution();
183}
184
185int ASensor_getMinDelay(ASensor const* sensor)
186{
187    return static_cast<Sensor const*>(sensor)->getMinDelay();
188}
189
190int ASensor_getFifoMaxEventCount(ASensor const* sensor)
191{
192    return static_cast<Sensor const*>(sensor)->getFifoMaxEventCount();
193}
194
195int ASensor_getFifoReservedEventCount(ASensor const* sensor)
196{
197    return static_cast<Sensor const*>(sensor)->getFifoReservedEventCount();
198}
199
200const char* ASensor_getStringType(ASensor const* sensor)
201{
202    return static_cast<Sensor const*>(sensor)->getStringType().string();
203}
204
205int ASensor_getReportingMode(ASensor const* sensor)
206{
207    return static_cast<Sensor const*>(sensor)->getReportingMode();
208}
209
210bool ASensor_isWakeUpSensor(ASensor const* sensor)
211{
212    return static_cast<Sensor const*>(sensor)->isWakeUpSensor();
213}
214