android_hardware_SensorManager.cpp revision b4c76b18a369d940f448bcc55d7245b6b30084dd 
1/*
2 * Copyright 2008, 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 "SensorManager"
18
19#include <utils/Log.h>
20#include <utils/Looper.h>
21
22#include <gui/Sensor.h>
23#include <gui/SensorManager.h>
24#include <gui/SensorEventQueue.h>
25
26#include "jni.h"
27#include "JNIHelp.h"
28#include "android_os_MessageQueue.h"
29#include <android_runtime/AndroidRuntime.h>
30
31static struct {
32    jclass clazz;
33    jmethodID dispatchSensorEvent;
34    jmethodID dispatchFlushCompleteEvent;
35} gBaseEventQueueClassInfo;
36
37namespace android {
38
39struct SensorOffsets
40{
41    jfieldID    name;
42    jfieldID    vendor;
43    jfieldID    version;
44    jfieldID    handle;
45    jfieldID    type;
46    jfieldID    range;
47    jfieldID    resolution;
48    jfieldID    power;
49    jfieldID    minDelay;
50    jfieldID    fifoReservedEventCount;
51    jfieldID    fifoMaxEventCount;
52} gSensorOffsets;
53
54
55/*
56 * The method below are not thread-safe and not intended to be
57 */
58
59static void
60nativeClassInit (JNIEnv *_env, jclass _this)
61{
62    jclass sensorClass = _env->FindClass("android/hardware/Sensor");
63    SensorOffsets& sensorOffsets = gSensorOffsets;
64    sensorOffsets.name        = _env->GetFieldID(sensorClass, "mName",      "Ljava/lang/String;");
65    sensorOffsets.vendor      = _env->GetFieldID(sensorClass, "mVendor",    "Ljava/lang/String;");
66    sensorOffsets.version     = _env->GetFieldID(sensorClass, "mVersion",   "I");
67    sensorOffsets.handle      = _env->GetFieldID(sensorClass, "mHandle",    "I");
68    sensorOffsets.type        = _env->GetFieldID(sensorClass, "mType",      "I");
69    sensorOffsets.range       = _env->GetFieldID(sensorClass, "mMaxRange",  "F");
70    sensorOffsets.resolution  = _env->GetFieldID(sensorClass, "mResolution","F");
71    sensorOffsets.power       = _env->GetFieldID(sensorClass, "mPower",     "F");
72    sensorOffsets.minDelay    = _env->GetFieldID(sensorClass, "mMinDelay",  "I");
73    sensorOffsets.fifoReservedEventCount =
74            _env->GetFieldID(sensorClass, "mFifoReservedEventCount",  "I");
75    sensorOffsets.fifoMaxEventCount = _env->GetFieldID(sensorClass, "mFifoMaxEventCount",  "I");
76}
77
78static jint
79nativeGetNextSensor(JNIEnv *env, jclass clazz, jobject sensor, jint next)
80{
81    SensorManager& mgr(SensorManager::getInstance());
82
83    Sensor const* const* sensorList;
84    size_t count = mgr.getSensorList(&sensorList);
85    if (size_t(next) >= count)
86        return -1;
87
88    Sensor const* const list = sensorList[next];
89    const SensorOffsets& sensorOffsets(gSensorOffsets);
90    jstring name = env->NewStringUTF(list->getName().string());
91    jstring vendor = env->NewStringUTF(list->getVendor().string());
92    env->SetObjectField(sensor, sensorOffsets.name,      name);
93    env->SetObjectField(sensor, sensorOffsets.vendor,    vendor);
94    env->SetIntField(sensor, sensorOffsets.version,      list->getVersion());
95    env->SetIntField(sensor, sensorOffsets.handle,       list->getHandle());
96    env->SetIntField(sensor, sensorOffsets.type,         list->getType());
97    env->SetFloatField(sensor, sensorOffsets.range,      list->getMaxValue());
98    env->SetFloatField(sensor, sensorOffsets.resolution, list->getResolution());
99    env->SetFloatField(sensor, sensorOffsets.power,      list->getPowerUsage());
100    env->SetIntField(sensor, sensorOffsets.minDelay,     list->getMinDelay());
101    env->SetIntField(sensor, sensorOffsets.fifoReservedEventCount,
102                     list->getFifoReservedEventCount());
103    env->SetIntField(sensor, sensorOffsets.fifoMaxEventCount, list->getFifoMaxEventCount());
104    next++;
105    return size_t(next) < count ? next : 0;
106}
107
108//----------------------------------------------------------------------------
109
110class Receiver : public LooperCallback {
111    sp<SensorEventQueue> mSensorQueue;
112    sp<MessageQueue> mMessageQueue;
113    jobject mReceiverObject;
114    jfloatArray mScratch;
115public:
116    Receiver(const sp<SensorEventQueue>& sensorQueue,
117            const sp<MessageQueue>& messageQueue,
118            jobject receiverObject, jfloatArray scratch) {
119        JNIEnv* env = AndroidRuntime::getJNIEnv();
120        mSensorQueue = sensorQueue;
121        mMessageQueue = messageQueue;
122        mReceiverObject = env->NewGlobalRef(receiverObject);
123        mScratch = (jfloatArray)env->NewGlobalRef(scratch);
124    }
125    ~Receiver() {
126        JNIEnv* env = AndroidRuntime::getJNIEnv();
127        env->DeleteGlobalRef(mReceiverObject);
128        env->DeleteGlobalRef(mScratch);
129    }
130    sp<SensorEventQueue> getSensorEventQueue() const {
131        return mSensorQueue;
132    }
133
134    void destroy() {
135        mMessageQueue->getLooper()->removeFd( mSensorQueue->getFd() );
136    }
137
138private:
139    virtual void onFirstRef() {
140        LooperCallback::onFirstRef();
141        mMessageQueue->getLooper()->addFd(mSensorQueue->getFd(), 0,
142                ALOOPER_EVENT_INPUT, this, mSensorQueue.get());
143    }
144
145    virtual int handleEvent(int fd, int events, void* data) {
146        JNIEnv* env = AndroidRuntime::getJNIEnv();
147        sp<SensorEventQueue> q = reinterpret_cast<SensorEventQueue *>(data);
148        ssize_t n;
149        ASensorEvent buffer[16];
150        while ((n = q->read(buffer, 16)) > 0) {
151            for (int i=0 ; i<n ; i++) {
152
153                if (buffer[i].type == SENSOR_TYPE_STEP_COUNTER) {
154                    // step-counter returns a uint64, but the java API only deals with floats
155                    float value = float(buffer[i].u64.step_counter);
156                    env->SetFloatArrayRegion(mScratch, 0, 1, &value);
157                } else {
158                    env->SetFloatArrayRegion(mScratch, 0, 16, buffer[i].data);
159                }
160
161                if (buffer[i].type == SENSOR_TYPE_META_DATA) {
162                    // This is a flush complete sensor event. Call dispatchFlushCompleteEvent
163                    // method.
164                    env->CallVoidMethod(mReceiverObject,
165                                        gBaseEventQueueClassInfo.dispatchFlushCompleteEvent,
166                                        buffer[i].meta_data.sensor);
167                } else {
168                    env->CallVoidMethod(mReceiverObject,
169                                        gBaseEventQueueClassInfo.dispatchSensorEvent,
170                                        buffer[i].sensor,
171                                        mScratch,
172                                        buffer[i].vector.status,
173                                        buffer[i].timestamp);
174                }
175
176                if (env->ExceptionCheck()) {
177                    ALOGE("Exception dispatching input event.");
178                    return 1;
179                }
180            }
181        }
182        if (n<0 && n != -EAGAIN) {
183            // FIXME: error receiving events, what to do in this case?
184        }
185
186        return 1;
187    }
188};
189
190static jint nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) {
191    SensorManager& mgr(SensorManager::getInstance());
192    sp<SensorEventQueue> queue(mgr.createEventQueue());
193
194    sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, msgQ);
195    if (messageQueue == NULL) {
196        jniThrowRuntimeException(env, "MessageQueue is not initialized.");
197        return 0;
198    }
199
200    sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQ, scratch);
201    receiver->incStrong((void*)nativeInitSensorEventQueue);
202    return jint(receiver.get());
203}
204
205static jint nativeEnableSensor(JNIEnv *env, jclass clazz, jint eventQ, jint handle, jint rate_us,
206                               jint maxBatchReportLatency, jint reservedFlags) {
207    sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
208    return receiver->getSensorEventQueue()->enableSensor(handle, rate_us, maxBatchReportLatency,
209                                                         reservedFlags);
210}
211
212static jint nativeDisableSensor(JNIEnv *env, jclass clazz, jint eventQ, jint handle) {
213    sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
214    return receiver->getSensorEventQueue()->disableSensor(handle);
215}
216
217static void nativeDestroySensorEventQueue(JNIEnv *env, jclass clazz, jint eventQ, jint handle) {
218    sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
219    receiver->destroy();
220    receiver->decStrong((void*)nativeInitSensorEventQueue);
221}
222
223static jint nativeFlushSensor(JNIEnv *env, jclass clazz, jint eventQ, jint handle) {
224    sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
225    return receiver->getSensorEventQueue()->flushSensor(handle);
226}
227
228//----------------------------------------------------------------------------
229
230static JNINativeMethod gSystemSensorManagerMethods[] = {
231    {"nativeClassInit",
232            "()V",
233            (void*)nativeClassInit },
234
235    {"nativeGetNextSensor",
236            "(Landroid/hardware/Sensor;I)I",
237            (void*)nativeGetNextSensor },
238};
239
240static JNINativeMethod gBaseEventQueueMethods[] = {
241    {"nativeInitBaseEventQueue",
242            "(Landroid/hardware/SystemSensorManager$BaseEventQueue;Landroid/os/MessageQueue;[F)I",
243            (void*)nativeInitSensorEventQueue },
244
245    {"nativeEnableSensor",
246            "(IIIII)I",
247            (void*)nativeEnableSensor },
248
249    {"nativeDisableSensor",
250            "(II)I",
251            (void*)nativeDisableSensor },
252
253    {"nativeDestroySensorEventQueue",
254            "(I)V",
255            (void*)nativeDestroySensorEventQueue },
256
257    {"nativeFlushSensor",
258            "(II)I",
259            (void*)nativeFlushSensor },
260};
261
262}; // namespace android
263
264using namespace android;
265
266#define FIND_CLASS(var, className) \
267        var = env->FindClass(className); \
268        LOG_FATAL_IF(! var, "Unable to find class " className); \
269        var = jclass(env->NewGlobalRef(var));
270
271#define GET_METHOD_ID(var, clazz, methodName, methodDescriptor) \
272        var = env->GetMethodID(clazz, methodName, methodDescriptor); \
273        LOG_FATAL_IF(! var, "Unable to find method " methodName);
274
275int register_android_hardware_SensorManager(JNIEnv *env)
276{
277    jniRegisterNativeMethods(env, "android/hardware/SystemSensorManager",
278            gSystemSensorManagerMethods, NELEM(gSystemSensorManagerMethods));
279
280    jniRegisterNativeMethods(env, "android/hardware/SystemSensorManager$BaseEventQueue",
281            gBaseEventQueueMethods, NELEM(gBaseEventQueueMethods));
282
283    FIND_CLASS(gBaseEventQueueClassInfo.clazz, "android/hardware/SystemSensorManager$BaseEventQueue");
284
285    GET_METHOD_ID(gBaseEventQueueClassInfo.dispatchSensorEvent,
286            gBaseEventQueueClassInfo.clazz,
287            "dispatchSensorEvent", "(I[FIJ)V");
288
289    GET_METHOD_ID(gBaseEventQueueClassInfo.dispatchFlushCompleteEvent,
290                  gBaseEventQueueClassInfo.clazz,
291                  "dispatchFlushCompleteEvent", "(I)V");
292
293    return 0;
294}
295