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
33 using android::sp;
34 using android::Sensor;
35 using android::SensorManager;
36 using android::SensorEventQueue;
37 using android::String8;
38
39 /*****************************************************************************/
40
ASensorManager_getInstance()41 ASensorManager* ASensorManager_getInstance()
42 {
43 return &SensorManager::getInstance();
44 }
45
ASensorManager_getSensorList(ASensorManager * manager,ASensorList * list)46 int ASensorManager_getSensorList(ASensorManager* manager,
47 ASensorList* list)
48 {
49 Sensor const* const* l;
50 int c = static_cast<SensorManager*>(manager)->getSensorList(&l);
51 if (list) {
52 *list = reinterpret_cast<ASensorList>(l);
53 }
54 return c;
55 }
56
ASensorManager_getDefaultSensor(ASensorManager * manager,int type)57 ASensor const* ASensorManager_getDefaultSensor(ASensorManager* manager, int type)
58 {
59 return static_cast<SensorManager*>(manager)->getDefaultSensor(type);
60 }
61
ASensorManager_createEventQueue(ASensorManager * manager,ALooper * looper,int ident,ALooper_callbackFunc callback,void * data)62 ASensorEventQueue* ASensorManager_createEventQueue(ASensorManager* manager,
63 ALooper* looper, int ident, ALooper_callbackFunc callback, void* data)
64 {
65 sp<SensorEventQueue> queue =
66 static_cast<SensorManager*>(manager)->createEventQueue();
67 if (queue != 0) {
68 ALooper_addFd(looper, queue->getFd(), ident, ALOOPER_EVENT_INPUT, callback, data);
69 queue->looper = looper;
70 queue->incStrong(manager);
71 }
72 return static_cast<ASensorEventQueue*>(queue.get());
73 }
74
ASensorManager_destroyEventQueue(ASensorManager * manager,ASensorEventQueue * inQueue)75 int ASensorManager_destroyEventQueue(ASensorManager* manager,
76 ASensorEventQueue* inQueue)
77 {
78 sp<SensorEventQueue> queue = static_cast<SensorEventQueue*>(inQueue);
79 ALooper_removeFd(queue->looper, queue->getFd());
80 queue->decStrong(manager);
81 return 0;
82 }
83
84 /*****************************************************************************/
85
ASensorEventQueue_enableSensor(ASensorEventQueue * queue,ASensor const * sensor)86 int ASensorEventQueue_enableSensor(ASensorEventQueue* queue, ASensor const* sensor)
87 {
88 return static_cast<SensorEventQueue*>(queue)->enableSensor(
89 static_cast<Sensor const*>(sensor));
90 }
91
ASensorEventQueue_disableSensor(ASensorEventQueue * queue,ASensor const * sensor)92 int ASensorEventQueue_disableSensor(ASensorEventQueue* queue, ASensor const* sensor)
93 {
94 return static_cast<SensorEventQueue*>(queue)->disableSensor(
95 static_cast<Sensor const*>(sensor));
96 }
97
ASensorEventQueue_setEventRate(ASensorEventQueue * queue,ASensor const * sensor,int32_t usec)98 int ASensorEventQueue_setEventRate(ASensorEventQueue* queue, ASensor const* sensor,
99 int32_t usec)
100 {
101 return static_cast<SensorEventQueue*>(queue)->setEventRate(
102 static_cast<Sensor const*>(sensor), us2ns(usec));
103 }
104
ASensorEventQueue_hasEvents(ASensorEventQueue * queue)105 int ASensorEventQueue_hasEvents(ASensorEventQueue* queue)
106 {
107 struct pollfd pfd;
108 pfd.fd = static_cast<SensorEventQueue*>(queue)->getFd();
109 pfd.events = POLLIN;
110 pfd.revents = 0;
111
112 int nfd = poll(&pfd, 1, 0);
113
114 if (nfd < 0)
115 return -errno;
116
117 if (pfd.revents != POLLIN)
118 return -1;
119
120 return (nfd == 0) ? 0 : 1;
121 }
122
ASensorEventQueue_getEvents(ASensorEventQueue * queue,ASensorEvent * events,size_t count)123 ssize_t ASensorEventQueue_getEvents(ASensorEventQueue* queue,
124 ASensorEvent* events, size_t count)
125 {
126 return static_cast<SensorEventQueue*>(queue)->read(events, count);
127 }
128
129
130 /*****************************************************************************/
131
ASensor_getName(ASensor const * sensor)132 const char* ASensor_getName(ASensor const* sensor)
133 {
134 return static_cast<Sensor const*>(sensor)->getName().string();
135 }
136
ASensor_getVendor(ASensor const * sensor)137 const char* ASensor_getVendor(ASensor const* sensor)
138 {
139 return static_cast<Sensor const*>(sensor)->getVendor().string();
140 }
141
ASensor_getType(ASensor const * sensor)142 int ASensor_getType(ASensor const* sensor)
143 {
144 return static_cast<Sensor const*>(sensor)->getType();
145 }
146
ASensor_getResolution(ASensor const * sensor)147 float ASensor_getResolution(ASensor const* sensor)
148 {
149 return static_cast<Sensor const*>(sensor)->getResolution();
150 }
151
ASensor_getMinDelay(ASensor const * sensor)152 int ASensor_getMinDelay(ASensor const* sensor)
153 {
154 return static_cast<Sensor const*>(sensor)->getMinDelay();
155 }
156