static jlong nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) { SensorManager& mgr(SensorManager::getInstance()); sp<SensorEventQueue> queue(mgr.createEventQueue()); sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, msgQ); if (messageQueue == NULL) { jniThrowRuntimeException(env, "MessageQueue is not initialized."); return 0; } sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQ, scratch); receiver->incStrong((void*)nativeInitSensorEventQueue); return jlong(receiver.get()); }
static jboolean nativeConsumeBatchedInputEvents(JNIEnv* env, jclass clazz, jlong receiverPtr, jlong frameTimeNanos) { sp<NativeInputEventReceiver> receiver = reinterpret_cast<NativeInputEventReceiver*>(receiverPtr); bool consumedBatch; status_t status = receiver->consumeEvents(env, true /*consumeBatches*/, frameTimeNanos, &consumedBatch); if (status && status != DEAD_OBJECT && !env->ExceptionCheck()) { String8 message; message.appendFormat("Failed to consume batched input event. status=%d", status); jniThrowRuntimeException(env, message.string()); return JNI_FALSE; } return consumedBatch ? JNI_TRUE : JNI_FALSE; }
static void SurfaceTexture_init(JNIEnv* env, jobject thiz, jboolean isDetached, jint texName, jboolean singleBufferMode, jobject weakThiz) { sp<IGraphicBufferProducer> producer; sp<IGraphicBufferConsumer> consumer; BufferQueue::createBufferQueue(&producer, &consumer); if (singleBufferMode) { consumer->disableAsyncBuffer(); consumer->setDefaultMaxBufferCount(1); } sp<GLConsumer> surfaceTexture; if (isDetached) { surfaceTexture = new GLConsumer(consumer, GL_TEXTURE_EXTERNAL_OES, true, true); } else { surfaceTexture = new GLConsumer(consumer, texName, GL_TEXTURE_EXTERNAL_OES, true, true); } if (surfaceTexture == 0) { jniThrowException(env, OutOfResourcesException, "Unable to create native SurfaceTexture"); return; } surfaceTexture->setName(String8::format("SurfaceTexture-%d-%d-%d", (isDetached ? 0 : texName), getpid(), createProcessUniqueId())); SurfaceTexture_setSurfaceTexture(env, thiz, surfaceTexture); SurfaceTexture_setProducer(env, thiz, producer); jclass clazz = env->GetObjectClass(thiz); if (clazz == NULL) { jniThrowRuntimeException(env, "Can't find android/graphics/SurfaceTexture"); return; } sp<JNISurfaceTextureContext> ctx(new JNISurfaceTextureContext(env, weakThiz, clazz)); surfaceTexture->setFrameAvailableListener(ctx); SurfaceTexture_setFrameAvailableListener(env, thiz, ctx); }
static jlong nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jlong sensorManager, jobject eventQWeak, jobject msgQ, jfloatArray scratch, jstring packageName, jint mode) { SensorManager* mgr = reinterpret_cast<SensorManager*>(sensorManager); ScopedUtfChars packageUtf(env, packageName); String8 clientName(packageUtf.c_str()); sp<SensorEventQueue> queue(mgr->createEventQueue(clientName, mode)); sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, msgQ); if (messageQueue == NULL) { jniThrowRuntimeException(env, "MessageQueue is not initialized."); return 0; } sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQWeak, scratch); receiver->incStrong((void*)nativeInitSensorEventQueue); return jlong(receiver.get()); }
static void android_view_InputChannel_nativeReadFromParcel(JNIEnv* env, jobject obj, jobject parcelObj) { if (android_view_InputChannel_getNativeInputChannel(env, obj) != NULL) { jniThrowException(env, "java/lang/IllegalStateException", "This object already has a native input channel."); return; } Parcel* parcel = parcelForJavaObject(env, parcelObj); if (parcel) { bool isInitialized = parcel->readInt32(); if (isInitialized) { String8 name = parcel->readString8(); int32_t parcelAshmemFd = parcel->readFileDescriptor(); int32_t ashmemFd = dup(parcelAshmemFd); if (ashmemFd < 0) { ALOGE("Error %d dup ashmem fd %d.", errno, parcelAshmemFd); } int32_t parcelReceivePipeFd = parcel->readFileDescriptor(); int32_t receivePipeFd = dup(parcelReceivePipeFd); if (receivePipeFd < 0) { ALOGE("Error %d dup receive pipe fd %d.", errno, parcelReceivePipeFd); } int32_t parcelSendPipeFd = parcel->readFileDescriptor(); int32_t sendPipeFd = dup(parcelSendPipeFd); if (sendPipeFd < 0) { ALOGE("Error %d dup send pipe fd %d.", errno, parcelSendPipeFd); } if (ashmemFd < 0 || receivePipeFd < 0 || sendPipeFd < 0) { if (ashmemFd >= 0) ::close(ashmemFd); if (receivePipeFd >= 0) ::close(receivePipeFd); if (sendPipeFd >= 0) ::close(sendPipeFd); jniThrowRuntimeException(env, "Could not read input channel file descriptors from parcel."); return; } InputChannel* inputChannel = new InputChannel(name, ashmemFd, receivePipeFd, sendPipeFd); NativeInputChannel* nativeInputChannel = new NativeInputChannel(inputChannel); android_view_InputChannel_setNativeInputChannel(env, obj, nativeInputChannel); } } }
static jlong nativeSendKeyEvent(JNIEnv* env, jobject clazz, jlong ptr, jobject eventObj, jboolean predispatch) { InputQueue* queue = reinterpret_cast<InputQueue*>(ptr); KeyEvent* event = queue->createKeyEvent(); status_t status = android_view_KeyEvent_toNative(env, eventObj, event); if (status) { queue->recycleInputEvent(event); jniThrowRuntimeException(env, "Could not read contents of KeyEvent object."); return -1; } if (predispatch) { event->setFlags(event->getFlags() | AKEY_EVENT_FLAG_PREDISPATCH); } queue->enqueueEvent(event); return reinterpret_cast<jlong>(event); }
static jint android_view_MotionEvent_nativeReadFromParcel(JNIEnv* env, jclass clazz, jint nativePtr, jobject parcelObj) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); if (!event) { event = new MotionEvent(); } Parcel* parcel = parcelForJavaObject(env, parcelObj); status_t status = event->readFromParcel(parcel); if (status) { if (!nativePtr) { delete event; } jniThrowRuntimeException(env, "Failed to read MotionEvent parcel."); return 0; } return reinterpret_cast<jint>(event); }
/** * Checks if an error has occurred, throwing a suitable exception if so. * @param env JNI environment * @param errorCode code to determine if it is an error * @return 0 if errorCode is not an error, 1 if errorCode is an error, but the * creation of the exception to be thrown fails * @exception thrown if errorCode represents an error */ UBool icu4jni_error(JNIEnv *env, UErrorCode errorCode) { const char* message = u_errorName(errorCode); if (errorCode <= U_ZERO_ERROR || errorCode >= U_ERROR_LIMIT) { return 0; } switch (errorCode) { case U_ILLEGAL_ARGUMENT_ERROR: return jniThrowException(env, "java/lang/IllegalArgumentException", message); case U_INDEX_OUTOFBOUNDS_ERROR: case U_BUFFER_OVERFLOW_ERROR: return jniThrowException(env, "java/lang/ArrayIndexOutOfBoundsException", message); case U_UNSUPPORTED_ERROR: return jniThrowException(env, "java/lang/UnsupportedOperationException", message); default: return jniThrowRuntimeException(env, message); } }
static void SurfaceTexture_init(JNIEnv* env, jobject thiz, jint texName, jobject weakThiz, jboolean allowSynchronous) { sp<SurfaceTexture> surfaceTexture(new SurfaceTexture(texName, allowSynchronous)); if (surfaceTexture == 0) { jniThrowException(env, OutOfResourcesException, "Unable to create native SurfaceTexture"); return; } SurfaceTexture_setSurfaceTexture(env, thiz, surfaceTexture); jclass clazz = env->GetObjectClass(thiz); if (clazz == NULL) { jniThrowRuntimeException(env, "Can't find android/graphics/SurfaceTexture"); return; } sp<JNISurfaceTextureContext> ctx(new JNISurfaceTextureContext(env, weakThiz, clazz)); surfaceTexture->setFrameAvailableListener(ctx); }
static jobjectArray android_view_InputChannel_nativeOpenInputChannelPair(JNIEnv* env, jclass clazz, jstring nameObj) { const char* nameChars = env->GetStringUTFChars(nameObj, NULL); String8 name(nameChars); env->ReleaseStringUTFChars(nameObj, nameChars); sp<InputChannel> serverChannel; sp<InputChannel> clientChannel; status_t result = InputChannel::openInputChannelPair(name, serverChannel, clientChannel); if (result) { String8 message; message.appendFormat("Could not open input channel pair. status=%d", result); jniThrowRuntimeException(env, message.string()); return NULL; } jobjectArray channelPair = env->NewObjectArray(2, gInputChannelClassInfo.clazz, NULL); if (env->ExceptionCheck()) { return NULL; } jobject serverChannelObj = android_view_InputChannel_createInputChannel(env, new NativeInputChannel(serverChannel)); if (env->ExceptionCheck()) { return NULL; } jobject clientChannelObj = android_view_InputChannel_createInputChannel(env, new NativeInputChannel(clientChannel)); if (env->ExceptionCheck()) { return NULL; } env->SetObjectArrayElement(channelPair, 0, serverChannelObj); env->SetObjectArrayElement(channelPair, 1, clientChannelObj); return channelPair; }
void doThrowRE(JNIEnv* env, const char* msg) { jniThrowRuntimeException(env, msg); }
static void throwRuntimeException(JNIEnv* env, UErrorCode status) { jniThrowRuntimeException(env, u_errorName(status)); }