android_hardware_SensorManager.cpp revision 18ebf732b84d0575c871db35b25bf000e0c7c6a6 
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 <map>
20
21#include <ScopedUtfChars.h>
22#include <ScopedLocalRef.h>
23
24#include <utils/Log.h>
25#include <utils/Looper.h>
26
27#include <gui/Sensor.h>
28#include <gui/SensorManager.h>
29#include <gui/SensorEventQueue.h>
30
31#include "jni.h"
32#include "JNIHelp.h"
33#include "android_os_MessageQueue.h"
34#include <android_runtime/AndroidRuntime.h>
35
36#include "core_jni_helpers.h"
37
38static struct {
39    jclass clazz;
40    jmethodID dispatchSensorEvent;
41    jmethodID dispatchFlushCompleteEvent;
42} gBaseEventQueueClassInfo;
43
44namespace android {
45
46struct SensorOffsets
47{
48    jfieldID    name;
49    jfieldID    vendor;
50    jfieldID    version;
51    jfieldID    handle;
52    jfieldID    range;
53    jfieldID    resolution;
54    jfieldID    power;
55    jfieldID    minDelay;
56    jfieldID    fifoReservedEventCount;
57    jfieldID    fifoMaxEventCount;
58    jfieldID    stringType;
59    jfieldID    requiredPermission;
60    jfieldID    maxDelay;
61    jfieldID    flags;
62    jmethodID   setType;
63} gSensorOffsets;
64
65
66/*
67 * The method below are not thread-safe and not intended to be
68 */
69
70static void
71nativeClassInit (JNIEnv *_env, jclass _this)
72{
73    jclass sensorClass = _env->FindClass("android/hardware/Sensor");
74    SensorOffsets& sensorOffsets = gSensorOffsets;
75    sensorOffsets.name        = _env->GetFieldID(sensorClass, "mName",      "Ljava/lang/String;");
76    sensorOffsets.vendor      = _env->GetFieldID(sensorClass, "mVendor",    "Ljava/lang/String;");
77    sensorOffsets.version     = _env->GetFieldID(sensorClass, "mVersion",   "I");
78    sensorOffsets.handle      = _env->GetFieldID(sensorClass, "mHandle",    "I");
79    sensorOffsets.range       = _env->GetFieldID(sensorClass, "mMaxRange",  "F");
80    sensorOffsets.resolution  = _env->GetFieldID(sensorClass, "mResolution","F");
81    sensorOffsets.power       = _env->GetFieldID(sensorClass, "mPower",     "F");
82    sensorOffsets.minDelay    = _env->GetFieldID(sensorClass, "mMinDelay",  "I");
83    sensorOffsets.fifoReservedEventCount =
84            _env->GetFieldID(sensorClass, "mFifoReservedEventCount",  "I");
85    sensorOffsets.fifoMaxEventCount = _env->GetFieldID(sensorClass, "mFifoMaxEventCount",  "I");
86    sensorOffsets.stringType = _env->GetFieldID(sensorClass, "mStringType", "Ljava/lang/String;");
87    sensorOffsets.requiredPermission = _env->GetFieldID(sensorClass, "mRequiredPermission",
88                                                        "Ljava/lang/String;");
89    sensorOffsets.maxDelay    = _env->GetFieldID(sensorClass, "mMaxDelay",  "I");
90    sensorOffsets.flags = _env->GetFieldID(sensorClass, "mFlags",  "I");
91    sensorOffsets.setType = _env->GetMethodID(sensorClass, "setType", "(I)Z");
92}
93
94/**
95 * A key comparator predicate.
96 * It is used to intern strings associated with Sensor data.
97 * It defines a 'Strict weak ordering' for the interned strings.
98 */
99class InternedStringCompare {
100public:
101    bool operator()(const String8* string1, const String8* string2) const {
102        if (string1 == NULL) {
103            return string2 != NULL;
104        }
105        if (string2 == NULL) {
106            return false;
107        }
108        return string1->compare(*string2) < 0;
109    }
110};
111
112/**
113 * A localized interning mechanism for Sensor strings.
114 * We implement our own interning to avoid the overhead of using java.lang.String#intern().
115 * It is common that Vendor, StringType, and RequirePermission data is common between many of the
116 * Sensors, by interning the memory usage to represent Sensors is optimized.
117 */
118static jstring
119getInternedString(JNIEnv *env, const String8* string) {
120    static std::map<const String8*, jstring, InternedStringCompare> internedStrings;
121
122    jstring internedString;
123    std::map<const String8*, jstring>::iterator iterator = internedStrings.find(string);
124    if (iterator != internedStrings.end()) {
125        internedString = iterator->second;
126    } else {
127        jstring localString = env->NewStringUTF(string->string());
128        // we are implementing our own interning so expect these strings to be backed by global refs
129        internedString = (jstring) env->NewGlobalRef(localString);
130        internedStrings.insert(std::make_pair(string, internedString));
131        env->DeleteLocalRef(localString);
132    }
133
134    return internedString;
135}
136
137static jint
138nativeGetNextSensor(JNIEnv *env, jclass clazz, jobject sensor, jint next)
139{
140    SensorManager& mgr(SensorManager::getInstance());
141
142    Sensor const* const* sensorList;
143    size_t count = mgr.getSensorList(&sensorList);
144    if (size_t(next) >= count) {
145        return -1;
146    }
147
148    Sensor const* const list = sensorList[next];
149    const SensorOffsets& sensorOffsets(gSensorOffsets);
150    jstring name = getInternedString(env, &list->getName());
151    jstring vendor = getInternedString(env, &list->getVendor());
152    jstring requiredPermission = getInternedString(env, &list->getRequiredPermission());
153    env->SetObjectField(sensor, sensorOffsets.name,      name);
154    env->SetObjectField(sensor, sensorOffsets.vendor,    vendor);
155    env->SetIntField(sensor, sensorOffsets.version,      list->getVersion());
156    env->SetIntField(sensor, sensorOffsets.handle,       list->getHandle());
157    env->SetFloatField(sensor, sensorOffsets.range,      list->getMaxValue());
158    env->SetFloatField(sensor, sensorOffsets.resolution, list->getResolution());
159    env->SetFloatField(sensor, sensorOffsets.power,      list->getPowerUsage());
160    env->SetIntField(sensor, sensorOffsets.minDelay,     list->getMinDelay());
161    env->SetIntField(sensor, sensorOffsets.fifoReservedEventCount,
162                     list->getFifoReservedEventCount());
163    env->SetIntField(sensor, sensorOffsets.fifoMaxEventCount,
164                     list->getFifoMaxEventCount());
165    env->SetObjectField(sensor, sensorOffsets.requiredPermission,
166                        requiredPermission);
167    env->SetIntField(sensor, sensorOffsets.maxDelay, list->getMaxDelay());
168    env->SetIntField(sensor, sensorOffsets.flags, list->getFlags());
169    if (env->CallBooleanMethod(sensor, sensorOffsets.setType, list->getType()) == JNI_FALSE) {
170        jstring stringType = getInternedString(env, &list->getStringType());
171        env->SetObjectField(sensor, sensorOffsets.stringType, stringType);
172    }
173    next++;
174    return size_t(next) < count ? next : 0;
175}
176
177static int nativeEnableDataInjection(JNIEnv *_env, jclass _this, jboolean enable) {
178     SensorManager& mgr(SensorManager::getInstance());
179     return mgr.enableDataInjection(enable);
180}
181
182//----------------------------------------------------------------------------
183
184class Receiver : public LooperCallback {
185    sp<SensorEventQueue> mSensorQueue;
186    sp<MessageQueue> mMessageQueue;
187    jobject mReceiverWeakGlobal;
188    jfloatArray mScratch;
189public:
190    Receiver(const sp<SensorEventQueue>& sensorQueue,
191            const sp<MessageQueue>& messageQueue,
192            jobject receiverWeak, jfloatArray scratch) {
193        JNIEnv* env = AndroidRuntime::getJNIEnv();
194        mSensorQueue = sensorQueue;
195        mMessageQueue = messageQueue;
196        mReceiverWeakGlobal = env->NewGlobalRef(receiverWeak);
197        mScratch = (jfloatArray)env->NewGlobalRef(scratch);
198    }
199    ~Receiver() {
200        JNIEnv* env = AndroidRuntime::getJNIEnv();
201        env->DeleteGlobalRef(mReceiverWeakGlobal);
202        env->DeleteGlobalRef(mScratch);
203    }
204    sp<SensorEventQueue> getSensorEventQueue() const {
205        return mSensorQueue;
206    }
207
208    void destroy() {
209        mMessageQueue->getLooper()->removeFd( mSensorQueue->getFd() );
210    }
211
212private:
213    virtual void onFirstRef() {
214        LooperCallback::onFirstRef();
215        mMessageQueue->getLooper()->addFd(mSensorQueue->getFd(), 0,
216                ALOOPER_EVENT_INPUT, this, mSensorQueue.get());
217    }
218
219    virtual int handleEvent(int fd, int events, void* data) {
220        JNIEnv* env = AndroidRuntime::getJNIEnv();
221        sp<SensorEventQueue> q = reinterpret_cast<SensorEventQueue *>(data);
222        ScopedLocalRef<jobject> receiverObj(env, jniGetReferent(env, mReceiverWeakGlobal));
223
224        ssize_t n;
225        ASensorEvent buffer[16];
226        while ((n = q->read(buffer, 16)) > 0) {
227            for (int i=0 ; i<n ; i++) {
228                if (buffer[i].type == SENSOR_TYPE_STEP_COUNTER) {
229                    // step-counter returns a uint64, but the java API only deals with floats
230                    float value = float(buffer[i].u64.step_counter);
231                    env->SetFloatArrayRegion(mScratch, 0, 1, &value);
232                } else {
233                    env->SetFloatArrayRegion(mScratch, 0, 16, buffer[i].data);
234                }
235
236                if (buffer[i].type == SENSOR_TYPE_META_DATA) {
237                    // This is a flush complete sensor event. Call dispatchFlushCompleteEvent
238                    // method.
239                    if (receiverObj.get()) {
240                        env->CallVoidMethod(receiverObj.get(),
241                                            gBaseEventQueueClassInfo.dispatchFlushCompleteEvent,
242                                            buffer[i].meta_data.sensor);
243                    }
244                } else {
245                    int8_t status;
246                    switch (buffer[i].type) {
247                    case SENSOR_TYPE_ORIENTATION:
248                    case SENSOR_TYPE_MAGNETIC_FIELD:
249                    case SENSOR_TYPE_ACCELEROMETER:
250                    case SENSOR_TYPE_GYROSCOPE:
251                        status = buffer[i].vector.status;
252                        break;
253                    case SENSOR_TYPE_HEART_RATE:
254                        status = buffer[i].heart_rate.status;
255                        break;
256                    default:
257                        status = SENSOR_STATUS_ACCURACY_HIGH;
258                        break;
259                    }
260                    if (receiverObj.get()) {
261                        env->CallVoidMethod(receiverObj.get(),
262                                            gBaseEventQueueClassInfo.dispatchSensorEvent,
263                                            buffer[i].sensor,
264                                            mScratch,
265                                            status,
266                                            buffer[i].timestamp);
267                    }
268                }
269                if (env->ExceptionCheck()) {
270                    mSensorQueue->sendAck(buffer, n);
271                    ALOGE("Exception dispatching input event.");
272                    return 1;
273                }
274            }
275            mSensorQueue->sendAck(buffer, n);
276        }
277        if (n<0 && n != -EAGAIN) {
278            // FIXME: error receiving events, what to do in this case?
279        }
280        return 1;
281    }
282};
283
284static jlong nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQWeak, jobject msgQ,
285        jfloatArray scratch, jstring packageName, jint mode) {
286    SensorManager& mgr(SensorManager::getInstance());
287    ScopedUtfChars packageUtf(env, packageName);
288    String8 clientName(packageUtf.c_str());
289    sp<SensorEventQueue> queue(mgr.createEventQueue(clientName, mode));
290
291    sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, msgQ);
292    if (messageQueue == NULL) {
293        jniThrowRuntimeException(env, "MessageQueue is not initialized.");
294        return 0;
295    }
296
297    sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQWeak, scratch);
298    receiver->incStrong((void*)nativeInitSensorEventQueue);
299    return jlong(receiver.get());
300}
301
302static jint nativeEnableSensor(JNIEnv *env, jclass clazz, jlong eventQ, jint handle, jint rate_us,
303                               jint maxBatchReportLatency) {
304    sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
305    return receiver->getSensorEventQueue()->enableSensor(handle, rate_us, maxBatchReportLatency,
306                                                         0);
307}
308
309static jint nativeDisableSensor(JNIEnv *env, jclass clazz, jlong eventQ, jint handle) {
310    sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
311    return receiver->getSensorEventQueue()->disableSensor(handle);
312}
313
314static void nativeDestroySensorEventQueue(JNIEnv *env, jclass clazz, jlong eventQ) {
315    sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
316    receiver->destroy();
317    receiver->decStrong((void*)nativeInitSensorEventQueue);
318}
319
320static jint nativeFlushSensor(JNIEnv *env, jclass clazz, jlong eventQ) {
321    sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
322    return receiver->getSensorEventQueue()->flush();
323}
324
325static jint nativeInjectSensorData(JNIEnv *env, jclass clazz, jlong eventQ, jint handle,
326        jfloatArray values, jint accuracy, jlong timestamp) {
327    sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
328    // Create a sensor_event from the above data which can be injected into the HAL.
329    ASensorEvent sensor_event;
330    memset(&sensor_event, 0, sizeof(sensor_event));
331    sensor_event.sensor = handle;
332    sensor_event.timestamp = timestamp;
333    env->GetFloatArrayRegion(values, 0, env->GetArrayLength(values), sensor_event.data);
334    return receiver->getSensorEventQueue()->injectSensorEvent(sensor_event);
335}
336//----------------------------------------------------------------------------
337
338static JNINativeMethod gSystemSensorManagerMethods[] = {
339    {"nativeClassInit",
340            "()V",
341            (void*)nativeClassInit },
342
343    {"nativeGetNextSensor",
344            "(Landroid/hardware/Sensor;I)I",
345            (void*)nativeGetNextSensor },
346
347    {"nativeEnableDataInjection",
348            "(Z)I",
349            (void*)nativeEnableDataInjection },
350};
351
352static JNINativeMethod gBaseEventQueueMethods[] = {
353    {"nativeInitBaseEventQueue",
354     "(Ljava/lang/ref/WeakReference;Landroid/os/MessageQueue;[FLjava/lang/String;I)J",
355     (void*)nativeInitSensorEventQueue },
356
357    {"nativeEnableSensor",
358            "(JIII)I",
359            (void*)nativeEnableSensor },
360
361    {"nativeDisableSensor",
362            "(JI)I",
363            (void*)nativeDisableSensor },
364
365    {"nativeDestroySensorEventQueue",
366            "(J)V",
367            (void*)nativeDestroySensorEventQueue },
368
369    {"nativeFlushSensor",
370            "(J)I",
371            (void*)nativeFlushSensor },
372
373    {"nativeInjectSensorData",
374            "(JI[FIJ)I",
375            (void*)nativeInjectSensorData },
376};
377
378}; // namespace android
379
380using namespace android;
381
382int register_android_hardware_SensorManager(JNIEnv *env)
383{
384    RegisterMethodsOrDie(env, "android/hardware/SystemSensorManager",
385            gSystemSensorManagerMethods, NELEM(gSystemSensorManagerMethods));
386
387    RegisterMethodsOrDie(env, "android/hardware/SystemSensorManager$BaseEventQueue",
388            gBaseEventQueueMethods, NELEM(gBaseEventQueueMethods));
389
390    gBaseEventQueueClassInfo.clazz = FindClassOrDie(env,
391            "android/hardware/SystemSensorManager$BaseEventQueue");
392
393    gBaseEventQueueClassInfo.dispatchSensorEvent = GetMethodIDOrDie(env,
394            gBaseEventQueueClassInfo.clazz, "dispatchSensorEvent", "(I[FIJ)V");
395
396    gBaseEventQueueClassInfo.dispatchFlushCompleteEvent = GetMethodIDOrDie(env,
397            gBaseEventQueueClassInfo.clazz, "dispatchFlushCompleteEvent", "(I)V");
398
399    return 0;
400}
401