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