From a931d5218cfee89c7629ffa6cde324fa966449f9 Mon Sep 17 00:00:00 2001 From: Ashok Bhat Date: Wed, 8 Jan 2014 14:04:51 +0000 Subject: AArch64: Use long for pointers in view/input classes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit For storing pointers, long is used in view/input classes, as native pointers can be 64-bit. In addition, some minor changes have been done to conform with standard JNI practice (e.g. use of jint instead of int in JNI function prototypes) Change-Id: Iafda9f4653c023bcba95b873637d935d0b569f5d Signed-off-by: Ashok Bhat Signed-off-by: Marcus Oakland Signed-off-by: Kévin PETIT --- core/java/android/view/InputChannel.java | 2 +- core/java/android/view/InputEventReceiver.java | 10 +++++----- core/java/android/view/InputEventSender.java | 10 +++++----- core/java/android/view/InputQueue.java | 22 +++++++++++----------- core/jni/android_view_InputChannel.cpp | 10 +++++----- core/jni/android_view_InputEventReceiver.cpp | 22 +++++++++++----------- core/jni/android_view_InputEventSender.cpp | 18 +++++++++--------- core/jni/android_view_InputQueue.cpp | 26 +++++++++++++------------- 8 files changed, 60 insertions(+), 60 deletions(-) (limited to 'core') diff --git a/core/java/android/view/InputChannel.java b/core/java/android/view/InputChannel.java index 40ee1ad..de195ae 100644 --- a/core/java/android/view/InputChannel.java +++ b/core/java/android/view/InputChannel.java @@ -46,7 +46,7 @@ public final class InputChannel implements Parcelable { }; @SuppressWarnings("unused") - private int mPtr; // used by native code + private long mPtr; // used by native code private static native InputChannel[] nativeOpenInputChannelPair(String name); diff --git a/core/java/android/view/InputEventReceiver.java b/core/java/android/view/InputEventReceiver.java index 25972e7..91ef50d 100644 --- a/core/java/android/view/InputEventReceiver.java +++ b/core/java/android/view/InputEventReceiver.java @@ -34,7 +34,7 @@ public abstract class InputEventReceiver { private final CloseGuard mCloseGuard = CloseGuard.get(); - private int mReceiverPtr; + private long mReceiverPtr; // We keep references to the input channel and message queue objects here so that // they are not GC'd while the native peer of the receiver is using them. @@ -44,11 +44,11 @@ public abstract class InputEventReceiver { // Map from InputEvent sequence numbers to dispatcher sequence numbers. private final SparseIntArray mSeqMap = new SparseIntArray(); - private static native int nativeInit(WeakReference receiver, + private static native long nativeInit(WeakReference receiver, InputChannel inputChannel, MessageQueue messageQueue); - private static native void nativeDispose(int receiverPtr); - private static native void nativeFinishInputEvent(int receiverPtr, int seq, boolean handled); - private static native boolean nativeConsumeBatchedInputEvents(int receiverPtr, + private static native void nativeDispose(long receiverPtr); + private static native void nativeFinishInputEvent(long receiverPtr, int seq, boolean handled); + private static native boolean nativeConsumeBatchedInputEvents(long receiverPtr, long frameTimeNanos); /** diff --git a/core/java/android/view/InputEventSender.java b/core/java/android/view/InputEventSender.java index be6a623..304ea3f 100644 --- a/core/java/android/view/InputEventSender.java +++ b/core/java/android/view/InputEventSender.java @@ -33,18 +33,18 @@ public abstract class InputEventSender { private final CloseGuard mCloseGuard = CloseGuard.get(); - private int mSenderPtr; + private long mSenderPtr; // We keep references to the input channel and message queue objects here so that // they are not GC'd while the native peer of the receiver is using them. private InputChannel mInputChannel; private MessageQueue mMessageQueue; - private static native int nativeInit(WeakReference sender, + private static native long nativeInit(WeakReference sender, InputChannel inputChannel, MessageQueue messageQueue); - private static native void nativeDispose(int senderPtr); - private static native boolean nativeSendKeyEvent(int senderPtr, int seq, KeyEvent event); - private static native boolean nativeSendMotionEvent(int senderPtr, int seq, MotionEvent event); + private static native void nativeDispose(long senderPtr); + private static native boolean nativeSendKeyEvent(long senderPtr, int seq, KeyEvent event); + private static native boolean nativeSendMotionEvent(long senderPtr, int seq, MotionEvent event); /** * Creates an input event sender bound to the specified input channel. diff --git a/core/java/android/view/InputQueue.java b/core/java/android/view/InputQueue.java index e3de89d..d5cec49 100644 --- a/core/java/android/view/InputQueue.java +++ b/core/java/android/view/InputQueue.java @@ -23,7 +23,7 @@ import android.os.Looper; import android.os.MessageQueue; import android.util.Pools.Pool; import android.util.Pools.SimplePool; -import android.util.SparseArray; +import android.util.LongSparseArray; import java.lang.ref.WeakReference; @@ -32,20 +32,20 @@ import java.lang.ref.WeakReference; * input events. Currently only usable from native code. */ public final class InputQueue { - private final SparseArray mActiveEventArray = - new SparseArray(20); + private final LongSparseArray mActiveEventArray = + new LongSparseArray(20); private final Pool mActiveInputEventPool = new SimplePool(20); private final CloseGuard mCloseGuard = CloseGuard.get(); - private int mPtr; + private long mPtr; - private static native int nativeInit(WeakReference weakQueue, + private static native long nativeInit(WeakReference weakQueue, MessageQueue messageQueue); - private static native int nativeSendKeyEvent(int ptr, KeyEvent e, boolean preDispatch); - private static native int nativeSendMotionEvent(int ptr, MotionEvent e); - private static native void nativeDispose(int ptr); + private static native long nativeSendKeyEvent(long ptr, KeyEvent e, boolean preDispatch); + private static native long nativeSendMotionEvent(long ptr, MotionEvent e); + private static native void nativeDispose(long ptr); /** @hide */ public InputQueue() { @@ -84,7 +84,7 @@ public final class InputQueue { } /** @hide */ - public int getNativePtr() { + public long getNativePtr() { return mPtr; } @@ -92,7 +92,7 @@ public final class InputQueue { public void sendInputEvent(InputEvent e, Object token, boolean predispatch, FinishedInputEventCallback callback) { ActiveInputEvent event = obtainActiveInputEvent(token, callback); - int id; + long id; if (e instanceof KeyEvent) { id = nativeSendKeyEvent(mPtr, (KeyEvent) e, predispatch); } else { @@ -101,7 +101,7 @@ public final class InputQueue { mActiveEventArray.put(id, event); } - private void finishInputEvent(int id, boolean handled) { + private void finishInputEvent(long id, boolean handled) { int index = mActiveEventArray.indexOfKey(id); if (index >= 0) { ActiveInputEvent e = mActiveEventArray.valueAt(index); diff --git a/core/jni/android_view_InputChannel.cpp b/core/jni/android_view_InputChannel.cpp index ce475e0..d667920 100644 --- a/core/jni/android_view_InputChannel.cpp +++ b/core/jni/android_view_InputChannel.cpp @@ -81,14 +81,14 @@ void NativeInputChannel::invokeAndRemoveDisposeCallback(JNIEnv* env, jobject obj static NativeInputChannel* android_view_InputChannel_getNativeInputChannel(JNIEnv* env, jobject inputChannelObj) { - jint intPtr = env->GetIntField(inputChannelObj, gInputChannelClassInfo.mPtr); - return reinterpret_cast(intPtr); + jlong longPtr = env->GetLongField(inputChannelObj, gInputChannelClassInfo.mPtr); + return reinterpret_cast(longPtr); } static void android_view_InputChannel_setNativeInputChannel(JNIEnv* env, jobject inputChannelObj, NativeInputChannel* nativeInputChannel) { - env->SetIntField(inputChannelObj, gInputChannelClassInfo.mPtr, - reinterpret_cast(nativeInputChannel)); + env->SetLongField(inputChannelObj, gInputChannelClassInfo.mPtr, + reinterpret_cast(nativeInputChannel)); } sp android_view_InputChannel_getInputChannel(JNIEnv* env, jobject inputChannelObj) { @@ -296,7 +296,7 @@ int register_android_view_InputChannel(JNIEnv* env) { FIND_CLASS(gInputChannelClassInfo.clazz, "android/view/InputChannel"); GET_FIELD_ID(gInputChannelClassInfo.mPtr, gInputChannelClassInfo.clazz, - "mPtr", "I"); + "mPtr", "J"); GET_METHOD_ID(gInputChannelClassInfo.ctor, gInputChannelClassInfo.clazz, "", "()V"); diff --git a/core/jni/android_view_InputEventReceiver.cpp b/core/jni/android_view_InputEventReceiver.cpp index 92a3e62..f36bf31 100644 --- a/core/jni/android_view_InputEventReceiver.cpp +++ b/core/jni/android_view_InputEventReceiver.cpp @@ -330,7 +330,7 @@ status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env, } -static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak, +static jlong nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak, jobject inputChannelObj, jobject messageQueueObj) { sp inputChannel = android_view_InputChannel_getInputChannel(env, inputChannelObj); @@ -356,17 +356,17 @@ static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak, } receiver->incStrong(gInputEventReceiverClassInfo.clazz); // retain a reference for the object - return reinterpret_cast(receiver.get()); + return reinterpret_cast(receiver.get()); } -static void nativeDispose(JNIEnv* env, jclass clazz, jint receiverPtr) { +static void nativeDispose(JNIEnv* env, jclass clazz, jlong receiverPtr) { sp receiver = reinterpret_cast(receiverPtr); receiver->dispose(); receiver->decStrong(gInputEventReceiverClassInfo.clazz); // drop reference held by the object } -static void nativeFinishInputEvent(JNIEnv* env, jclass clazz, jint receiverPtr, +static void nativeFinishInputEvent(JNIEnv* env, jclass clazz, jlong receiverPtr, jint seq, jboolean handled) { sp receiver = reinterpret_cast(receiverPtr); @@ -378,7 +378,7 @@ static void nativeFinishInputEvent(JNIEnv* env, jclass clazz, jint receiverPtr, } } -static bool nativeConsumeBatchedInputEvents(JNIEnv* env, jclass clazz, jint receiverPtr, +static jboolean nativeConsumeBatchedInputEvents(JNIEnv* env, jclass clazz, jlong receiverPtr, jlong frameTimeNanos) { sp receiver = reinterpret_cast(receiverPtr); @@ -389,22 +389,22 @@ static bool nativeConsumeBatchedInputEvents(JNIEnv* env, jclass clazz, jint rece String8 message; message.appendFormat("Failed to consume batched input event. status=%d", status); jniThrowRuntimeException(env, message.string()); - return false; + return JNI_FALSE; } - return consumedBatch; + return consumedBatch ? JNI_TRUE : JNI_FALSE; } static JNINativeMethod gMethods[] = { /* name, signature, funcPtr */ { "nativeInit", - "(Ljava/lang/ref/WeakReference;Landroid/view/InputChannel;Landroid/os/MessageQueue;)I", + "(Ljava/lang/ref/WeakReference;Landroid/view/InputChannel;Landroid/os/MessageQueue;)J", (void*)nativeInit }, - { "nativeDispose", "(I)V", + { "nativeDispose", "(J)V", (void*)nativeDispose }, - { "nativeFinishInputEvent", "(IIZ)V", + { "nativeFinishInputEvent", "(JIZ)V", (void*)nativeFinishInputEvent }, - { "nativeConsumeBatchedInputEvents", "(IJ)Z", + { "nativeConsumeBatchedInputEvents", "(JJ)Z", (void*)nativeConsumeBatchedInputEvents }, }; diff --git a/core/jni/android_view_InputEventSender.cpp b/core/jni/android_view_InputEventSender.cpp index e4b65a1..f156b9a 100644 --- a/core/jni/android_view_InputEventSender.cpp +++ b/core/jni/android_view_InputEventSender.cpp @@ -230,7 +230,7 @@ status_t NativeInputEventSender::receiveFinishedSignals(JNIEnv* env) { } -static jint nativeInit(JNIEnv* env, jclass clazz, jobject senderWeak, +static jlong nativeInit(JNIEnv* env, jclass clazz, jobject senderWeak, jobject inputChannelObj, jobject messageQueueObj) { sp inputChannel = android_view_InputChannel_getInputChannel(env, inputChannelObj); @@ -256,17 +256,17 @@ static jint nativeInit(JNIEnv* env, jclass clazz, jobject senderWeak, } sender->incStrong(gInputEventSenderClassInfo.clazz); // retain a reference for the object - return reinterpret_cast(sender.get()); + return reinterpret_cast(sender.get()); } -static void nativeDispose(JNIEnv* env, jclass clazz, jint senderPtr) { +static void nativeDispose(JNIEnv* env, jclass clazz, jlong senderPtr) { sp sender = reinterpret_cast(senderPtr); sender->dispose(); sender->decStrong(gInputEventSenderClassInfo.clazz); // drop reference held by the object } -static jboolean nativeSendKeyEvent(JNIEnv* env, jclass clazz, jint senderPtr, +static jboolean nativeSendKeyEvent(JNIEnv* env, jclass clazz, jlong senderPtr, jint seq, jobject eventObj) { sp sender = reinterpret_cast(senderPtr); @@ -276,7 +276,7 @@ static jboolean nativeSendKeyEvent(JNIEnv* env, jclass clazz, jint senderPtr, return !status; } -static jboolean nativeSendMotionEvent(JNIEnv* env, jclass clazz, jint senderPtr, +static jboolean nativeSendMotionEvent(JNIEnv* env, jclass clazz, jlong senderPtr, jint seq, jobject eventObj) { sp sender = reinterpret_cast(senderPtr); @@ -289,13 +289,13 @@ static jboolean nativeSendMotionEvent(JNIEnv* env, jclass clazz, jint senderPtr, static JNINativeMethod gMethods[] = { /* name, signature, funcPtr */ { "nativeInit", - "(Ljava/lang/ref/WeakReference;Landroid/view/InputChannel;Landroid/os/MessageQueue;)I", + "(Ljava/lang/ref/WeakReference;Landroid/view/InputChannel;Landroid/os/MessageQueue;)J", (void*)nativeInit }, - { "nativeDispose", "(I)V", + { "nativeDispose", "(J)V", (void*)nativeDispose }, - { "nativeSendKeyEvent", "(IILandroid/view/KeyEvent;)Z", + { "nativeSendKeyEvent", "(JILandroid/view/KeyEvent;)Z", (void*)nativeSendKeyEvent }, - { "nativeSendMotionEvent", "(IILandroid/view/MotionEvent;)Z", + { "nativeSendMotionEvent", "(JILandroid/view/MotionEvent;)Z", (void*)nativeSendMotionEvent }, }; diff --git a/core/jni/android_view_InputQueue.cpp b/core/jni/android_view_InputQueue.cpp index 7532c9d..21b73b1 100644 --- a/core/jni/android_view_InputQueue.cpp +++ b/core/jni/android_view_InputQueue.cpp @@ -151,7 +151,7 @@ void InputQueue::handleMessage(const Message& message) { mFinishedEvents.removeAt(0); } env->CallVoidMethod(inputQueueObj.get(), gInputQueueClassInfo.finishInputEvent, - reinterpret_cast(event), handled); + reinterpret_cast(event), handled); recycleInputEvent(event); } break; @@ -193,7 +193,7 @@ InputQueue* InputQueue::createQueue(jobject inputQueueObj, const sp& loo return new InputQueue(inputQueueObj, looper, pipeFds[0], pipeFds[1]); } -static jint nativeInit(JNIEnv* env, jobject clazz, jobject queueWeak, jobject jMsgQueue) { +static jlong nativeInit(JNIEnv* env, jobject clazz, jobject queueWeak, jobject jMsgQueue) { sp messageQueue = android_os_MessageQueue_getMessageQueue(env, jMsgQueue); if (messageQueue == NULL) { jniThrowRuntimeException(env, "MessageQueue is not initialized."); @@ -205,16 +205,16 @@ static jint nativeInit(JNIEnv* env, jobject clazz, jobject queueWeak, jobject jM return 0; } queue->incStrong(&gInputQueueClassInfo); - return reinterpret_cast(queue.get()); + return reinterpret_cast(queue.get()); } -static void nativeDispose(JNIEnv* env, jobject clazz, jint ptr) { +static void nativeDispose(JNIEnv* env, jobject clazz, jlong ptr) { sp queue = reinterpret_cast(ptr); queue->detachLooper(); queue->decStrong(&gInputQueueClassInfo); } -static jint nativeSendKeyEvent(JNIEnv* env, jobject clazz, jint ptr, jobject eventObj, +static jlong nativeSendKeyEvent(JNIEnv* env, jobject clazz, jlong ptr, jobject eventObj, jboolean predispatch) { InputQueue* queue = reinterpret_cast(ptr); KeyEvent* event = queue->createKeyEvent(); @@ -230,10 +230,10 @@ static jint nativeSendKeyEvent(JNIEnv* env, jobject clazz, jint ptr, jobject eve } queue->enqueueEvent(event); - return reinterpret_cast(event); + return reinterpret_cast(event); } -static jint nativeSendMotionEvent(JNIEnv* env, jobject clazz, jint ptr, jobject eventObj) { +static jlong nativeSendMotionEvent(JNIEnv* env, jobject clazz, jlong ptr, jobject eventObj) { sp queue = reinterpret_cast(ptr); MotionEvent* originalEvent = android_view_MotionEvent_getNativePtr(env, eventObj); if (!originalEvent) { @@ -243,15 +243,15 @@ static jint nativeSendMotionEvent(JNIEnv* env, jobject clazz, jint ptr, jobject MotionEvent* event = queue->createMotionEvent(); event->copyFrom(originalEvent, true /* keepHistory */); queue->enqueueEvent(event); - return reinterpret_cast(event); + return reinterpret_cast(event); } static const JNINativeMethod g_methods[] = { - { "nativeInit", "(Ljava/lang/ref/WeakReference;Landroid/os/MessageQueue;)I", + { "nativeInit", "(Ljava/lang/ref/WeakReference;Landroid/os/MessageQueue;)J", (void*) nativeInit }, - { "nativeDispose", "(I)V", (void*) nativeDispose }, - { "nativeSendKeyEvent", "(ILandroid/view/KeyEvent;Z)I", (void*) nativeSendKeyEvent }, - { "nativeSendMotionEvent", "(ILandroid/view/MotionEvent;)I", (void*) nativeSendMotionEvent }, + { "nativeDispose", "(J)V", (void*) nativeDispose }, + { "nativeSendKeyEvent", "(JLandroid/view/KeyEvent;Z)J", (void*) nativeSendKeyEvent }, + { "nativeSendMotionEvent", "(JLandroid/view/MotionEvent;)J", (void*) nativeSendMotionEvent }, }; static const char* const kInputQueuePathName = "android/view/InputQueue"; @@ -272,7 +272,7 @@ int register_android_view_InputQueue(JNIEnv* env) { jclass clazz; FIND_CLASS(clazz, kInputQueuePathName); - GET_METHOD_ID(gInputQueueClassInfo.finishInputEvent, clazz, "finishInputEvent", "(IZ)V"); + GET_METHOD_ID(gInputQueueClassInfo.finishInputEvent, clazz, "finishInputEvent", "(JZ)V"); return AndroidRuntime::registerNativeMethods( env, kInputQueuePathName, -- cgit v1.1