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/Looper.h>
25
26 #include <gui/Sensor.h>
27 #include <gui/SensorChannel.h>
28 #include <gui/SensorEventQueue.h>
29 #include <gui/ISensorEventConnection.h>
30
31 #include <android/sensor.h>
32
33 // ----------------------------------------------------------------------------
34 namespace android {
35 // ----------------------------------------------------------------------------
36
SensorEventQueue(const sp<ISensorEventConnection> & connection)37 SensorEventQueue::SensorEventQueue(const sp<ISensorEventConnection>& connection)
38 : mSensorEventConnection(connection)
39 {
40 }
41
~SensorEventQueue()42 SensorEventQueue::~SensorEventQueue()
43 {
44 }
45
onFirstRef()46 void SensorEventQueue::onFirstRef()
47 {
48 mSensorChannel = mSensorEventConnection->getSensorChannel();
49 }
50
getFd() const51 int SensorEventQueue::getFd() const
52 {
53 return mSensorChannel->getFd();
54 }
55
write(ASensorEvent const * events,size_t numEvents)56 ssize_t SensorEventQueue::write(ASensorEvent const* events, size_t numEvents)
57 {
58 ssize_t size = mSensorChannel->write(events, numEvents * sizeof(events[0]));
59 if (size >= 0) {
60 if (size % sizeof(events[0])) {
61 // partial write!!! should never happen.
62 return -EINVAL;
63 }
64 // returns number of events written
65 size /= sizeof(events[0]);
66 }
67 return size;
68 }
69
read(ASensorEvent * events,size_t numEvents)70 ssize_t SensorEventQueue::read(ASensorEvent* events, size_t numEvents)
71 {
72 ssize_t size = mSensorChannel->read(events, numEvents*sizeof(events[0]));
73 LOGE_IF(size<0 && size!=-EAGAIN,
74 "SensorChannel::read error (%s)", strerror(-size));
75 if (size >= 0) {
76 if (size % sizeof(events[0])) {
77 // partial read!!! should never happen.
78 LOGE("SensorEventQueue partial read (event-size=%u, read=%d)",
79 sizeof(events[0]), int(size));
80 return -EINVAL;
81 }
82 // returns number of events read
83 size /= sizeof(events[0]);
84 }
85 return size;
86 }
87
getLooper() const88 sp<Looper> SensorEventQueue::getLooper() const
89 {
90 Mutex::Autolock _l(mLock);
91 if (mLooper == 0) {
92 mLooper = new Looper(true);
93 mLooper->addFd(getFd(), getFd(), ALOOPER_EVENT_INPUT, NULL, NULL);
94 }
95 return mLooper;
96 }
97
waitForEvent() const98 status_t SensorEventQueue::waitForEvent() const
99 {
100 const int fd = getFd();
101 sp<Looper> looper(getLooper());
102
103 int32_t result;
104 do {
105 result = looper->pollOnce(-1);
106 if (result == ALOOPER_EVENT_ERROR) {
107 LOGE("SensorChannel::waitForEvent error (errno=%d)", errno);
108 result = -EPIPE; // unknown error, so we make up one
109 break;
110 }
111 } while (result != fd);
112
113 return (result == fd) ? status_t(NO_ERROR) : result;
114 }
115
wake() const116 status_t SensorEventQueue::wake() const
117 {
118 sp<Looper> looper(getLooper());
119 looper->wake();
120 return NO_ERROR;
121 }
122
enableSensor(Sensor const * sensor) const123 status_t SensorEventQueue::enableSensor(Sensor const* sensor) const {
124 return mSensorEventConnection->enableDisable(sensor->getHandle(), true);
125 }
126
disableSensor(Sensor const * sensor) const127 status_t SensorEventQueue::disableSensor(Sensor const* sensor) const {
128 return mSensorEventConnection->enableDisable(sensor->getHandle(), false);
129 }
130
enableSensor(int32_t handle,int32_t us) const131 status_t SensorEventQueue::enableSensor(int32_t handle, int32_t us) const {
132 status_t err = mSensorEventConnection->enableDisable(handle, true);
133 if (err == NO_ERROR) {
134 mSensorEventConnection->setEventRate(handle, us2ns(us));
135 }
136 return err;
137 }
138
disableSensor(int32_t handle) const139 status_t SensorEventQueue::disableSensor(int32_t handle) const {
140 return mSensorEventConnection->enableDisable(handle, false);
141 }
142
setEventRate(Sensor const * sensor,nsecs_t ns) const143 status_t SensorEventQueue::setEventRate(Sensor const* sensor, nsecs_t ns) const {
144 return mSensorEventConnection->setEventRate(sensor->getHandle(), ns);
145 }
146
147 // ----------------------------------------------------------------------------
148 }; // namespace android
149
150