Ensure the ShortcutManager uses the correct key character map.

The ShortcutManager used to only receive the key code of the key event
that triggered the shortcut.  This change now provides the shortcut
manager with the whole key event so it can look up the associated
character using the correct key character map.

To make this more efficient, added a mechanism for recycling
key events.  At the moment it is only used by key events owned by the
system process, since clients of the existing API (such as Views)
might continue to hold on to key events after dispatch has finished so
they would break if the key event were recycled by the framework.

Deprecated KeyCharacterMap.BUILT_IN_KEYBOARD.

Change-Id: I4313725dd63f2be01c350c005a41c7fde9bc67e8

5 files changed, 101 insertions, 33 deletions

diff --git a/core/jni/android_app_NativeActivity.cpp b/core/jni/android_app_NativeActivity.cpp
index 695d50a4..b033878 100644
--- a/core/jni/android_app_NativeActivity.cpp
+++ b/core/jni/android_app_NativeActivity.cpp
@@ -579,20 +579,30 @@ static int mainWorkCallback(int fd, int events, void* data) {
             while ((keyEvent=code->nativeInputQueue->consumeUnhandledEvent()) != NULL) {
                 jobject inputEventObj = android_view_KeyEvent_fromNative(
                         code->env, keyEvent);
-                jboolean handled = code->env->CallBooleanMethod(code->clazz,
-                        gNativeActivityClassInfo.dispatchUnhandledKeyEvent, inputEventObj);
-                checkAndClearExceptionFromCallback(code->env, "dispatchUnhandledKeyEvent");
-                code->env->DeleteLocalRef(inputEventObj);
+                jboolean handled;
+                if (inputEventObj) {
+                    handled = code->env->CallBooleanMethod(code->clazz,
+                            gNativeActivityClassInfo.dispatchUnhandledKeyEvent, inputEventObj);
+                    checkAndClearExceptionFromCallback(code->env, "dispatchUnhandledKeyEvent");
+                    code->env->DeleteLocalRef(inputEventObj);
+                } else {
+                    LOGE("Failed to obtain key event for dispatchUnhandledKeyEvent.");
+                    handled = false;
+                }
                 code->nativeInputQueue->finishEvent(keyEvent, handled, true);
             }
             int seq;
             while ((keyEvent=code->nativeInputQueue->consumePreDispatchingEvent(&seq)) != NULL) {
                 jobject inputEventObj = android_view_KeyEvent_fromNative(
                         code->env, keyEvent);
-                code->env->CallVoidMethod(code->clazz,
-                        gNativeActivityClassInfo.preDispatchKeyEvent, inputEventObj, seq);
-                checkAndClearExceptionFromCallback(code->env, "preDispatchKeyEvent");
-                code->env->DeleteLocalRef(inputEventObj);
+                if (inputEventObj) {
+                    code->env->CallVoidMethod(code->clazz,
+                            gNativeActivityClassInfo.preDispatchKeyEvent, inputEventObj, seq);
+                    checkAndClearExceptionFromCallback(code->env, "preDispatchKeyEvent");
+                    code->env->DeleteLocalRef(inputEventObj);
+                } else {
+                    LOGE("Failed to obtain key event for preDispatchKeyEvent.");
+                }
             }
         } break;
         case CMD_FINISH: {
@@ -987,7 +997,12 @@ dispatchKeyEvent_native(JNIEnv* env, jobject clazz, jint handle, jobject eventOb
         NativeCode* code = (NativeCode*)handle;
         if (code->nativeInputQueue != NULL) {
             KeyEvent* event = code->nativeInputQueue->createKeyEvent();
-            android_view_KeyEvent_toNative(env, eventObj, event);
+            status_t status = android_view_KeyEvent_toNative(env, eventObj, event);
+            if (status) {
+                delete event;
+                jniThrowRuntimeException(env, "Could not read contents of KeyEvent object.");
+                return;
+            }
             code->nativeInputQueue->dispatchEvent(event);
         }
     }
diff --git a/core/jni/android_view_KeyEvent.cpp b/core/jni/android_view_KeyEvent.cpp
index 7e7583c..4b04b8b 100644
--- a/core/jni/android_view_KeyEvent.cpp
+++ b/core/jni/android_view_KeyEvent.cpp
@@ -30,7 +30,8 @@ namespace android {
 static struct {
     jclass clazz;
 
-    jmethodID ctor;
+    jmethodID obtain;
+    jmethodID recycle;
 
     jfieldID mDeviceId;
     jfieldID mSource;
@@ -48,7 +49,8 @@ static struct {
 // ----------------------------------------------------------------------------
 
 jobject android_view_KeyEvent_fromNative(JNIEnv* env, const KeyEvent* event) {
-    return env->NewObject(gKeyEventClassInfo.clazz, gKeyEventClassInfo.ctor,
+    jobject eventObj = env->CallStaticObjectMethod(gKeyEventClassInfo.clazz,
+            gKeyEventClassInfo.obtain,
             nanoseconds_to_milliseconds(event->getDownTime()),
             nanoseconds_to_milliseconds(event->getEventTime()),
             event->getAction(),
@@ -58,10 +60,18 @@ jobject android_view_KeyEvent_fromNative(JNIEnv* env, const KeyEvent* event) {
             event->getDeviceId(),
             event->getScanCode(),
             event->getFlags(),
-            event->getSource());
+            event->getSource(),
+            NULL);
+    if (env->ExceptionCheck()) {
+        LOGE("An exception occurred while obtaining a key event.");
+        LOGE_EX(env);
+        env->ExceptionClear();
+        return NULL;
+    }
+    return eventObj;
 }
 
-void android_view_KeyEvent_toNative(JNIEnv* env, jobject eventObj,
+status_t android_view_KeyEvent_toNative(JNIEnv* env, jobject eventObj,
         KeyEvent* event) {
     jint deviceId = env->GetIntField(eventObj, gKeyEventClassInfo.mDeviceId);
     jint source = env->GetIntField(eventObj, gKeyEventClassInfo.mSource);
@@ -77,6 +87,18 @@ void android_view_KeyEvent_toNative(JNIEnv* env, jobject eventObj,
     event->initialize(deviceId, source, action, flags, keyCode, scanCode, metaState, repeatCount,
             milliseconds_to_nanoseconds(downTime),
             milliseconds_to_nanoseconds(eventTime));
+    return OK;
+}
+
+status_t android_view_KeyEvent_recycle(JNIEnv* env, jobject eventObj) {
+    env->CallVoidMethod(eventObj, gKeyEventClassInfo.recycle);
+    if (env->ExceptionCheck()) {
+        LOGW("An exception occurred while recycling a key event.");
+        LOGW_EX(env);
+        env->ExceptionClear();
+        return UNKNOWN_ERROR;
+    }
+    return OK;
 }
 
 static jboolean native_isSystemKey(JNIEnv* env, jobject clazz, jint keyCode) {
@@ -87,6 +109,7 @@ static jboolean native_hasDefaultAction(JNIEnv* env, jobject clazz, jint keyCode
     return KeyEvent::hasDefaultAction(keyCode);
 }
 
+
 // ----------------------------------------------------------------------------
 
 static const JNINativeMethod g_methods[] = {
@@ -99,6 +122,10 @@ static const JNINativeMethod g_methods[] = {
         LOG_FATAL_IF(! var, "Unable to find class " className); \
         var = jclass(env->NewGlobalRef(var));
 
+#define GET_STATIC_METHOD_ID(var, clazz, methodName, fieldDescriptor) \
+        var = env->GetStaticMethodID(clazz, methodName, fieldDescriptor); \
+        LOG_FATAL_IF(! var, "Unable to find static method" methodName);
+
 #define GET_METHOD_ID(var, clazz, methodName, fieldDescriptor) \
         var = env->GetMethodID(clazz, methodName, fieldDescriptor); \
         LOG_FATAL_IF(! var, "Unable to find method" methodName);
@@ -109,9 +136,11 @@ static const JNINativeMethod g_methods[] = {
 
 int register_android_view_KeyEvent(JNIEnv* env) {
     FIND_CLASS(gKeyEventClassInfo.clazz, "android/view/KeyEvent");
-        
-    GET_METHOD_ID(gKeyEventClassInfo.ctor, gKeyEventClassInfo.clazz,
-            "<init>", "(JJIIIIIIII)V");
+
+    GET_STATIC_METHOD_ID(gKeyEventClassInfo.obtain, gKeyEventClassInfo.clazz,
+            "obtain", "(JJIIIIIIIILjava/lang/String;)Landroid/view/KeyEvent;");
+    GET_METHOD_ID(gKeyEventClassInfo.recycle, gKeyEventClassInfo.clazz,
+            "recycle", "()V");
 
     GET_FIELD_ID(gKeyEventClassInfo.mDeviceId, gKeyEventClassInfo.clazz,
             "mDeviceId", "I");
diff --git a/core/jni/android_view_KeyEvent.h b/core/jni/android_view_KeyEvent.h
index 0bd410c..586eb2f 100644
--- a/core/jni/android_view_KeyEvent.h
+++ b/core/jni/android_view_KeyEvent.h
@@ -18,18 +18,28 @@
 #define _ANDROID_VIEW_KEYEVENT_H
 
 #include "jni.h"
+#include <utils/Errors.h>
+#include <utils/threads.h>
 
 namespace android {
 
 class KeyEvent;
 
-/* Obtains an instance of a DVM KeyEvent object as a copy of a native KeyEvent instance. */
+/* Obtains an instance of a DVM KeyEvent object as a copy of a native KeyEvent instance.
+ * Returns NULL on error. */
 extern jobject android_view_KeyEvent_fromNative(JNIEnv* env, const KeyEvent* event);
 
-/* Copies the contents of a DVM KeyEvent object to a native KeyEvent instance. */
-extern void android_view_KeyEvent_toNative(JNIEnv* env, jobject eventObj,
+/* Copies the contents of a DVM KeyEvent object to a native KeyEvent instance.
+ * Returns non-zero on error. */
+extern status_t android_view_KeyEvent_toNative(JNIEnv* env, jobject eventObj,
         KeyEvent* event);
 
+/* Recycles a DVM KeyEvent object.
+ * Key events should only be recycled if they are owned by the system since user
+ * code expects them to be essentially immutable, "tracking" notwithstanding.
+ * Returns non-zero on error. */
+extern status_t android_view_KeyEvent_recycle(JNIEnv* env, jobject eventObj);
+
 } // namespace android
 
 #endif // _ANDROID_OS_KEYEVENT_H
diff --git a/core/jni/android_view_MotionEvent.cpp b/core/jni/android_view_MotionEvent.cpp
index 537ac72..f32f0ff 100644
--- a/core/jni/android_view_MotionEvent.cpp
+++ b/core/jni/android_view_MotionEvent.cpp
@@ -169,7 +169,7 @@ jobject android_view_MotionEvent_fromNative(JNIEnv* env, const MotionEvent* even
     return eventObj;
 }
 
-void android_view_MotionEvent_toNative(JNIEnv* env, jobject eventObj,
+status_t android_view_MotionEvent_toNative(JNIEnv* env, jobject eventObj,
         MotionEvent* event) {
     jint deviceId = env->GetIntField(eventObj, gMotionEventClassInfo.mDeviceId);
     jint source = env->GetIntField(eventObj, gMotionEventClassInfo.mSource);
@@ -184,6 +184,16 @@ void android_view_MotionEvent_toNative(JNIEnv* env, jobject eventObj,
     jint flags = env->GetIntField(eventObj, gMotionEventClassInfo.mFlags);
     jint numPointers = env->GetIntField(eventObj, gMotionEventClassInfo.mNumPointers);
     jint numSamples = env->GetIntField(eventObj, gMotionEventClassInfo.mNumSamples);
+
+    if (numPointers == 0) {
+        LOGE("Malformed MotionEvent: mNumPointers was zero");
+        return BAD_VALUE;
+    }
+    if (numSamples == 0) {
+        LOGE("Malformed MotionEvent: mNumSamples was zero");
+        return BAD_VALUE;
+    }
+
     jintArray pointerIdentifierArray = jintArray(env->GetObjectField(eventObj,
             gMotionEventClassInfo.mPointerIdentifiers));
     jfloatArray dataSampleArray = jfloatArray(env->GetObjectField(eventObj,
@@ -191,9 +201,6 @@ void android_view_MotionEvent_toNative(JNIEnv* env, jobject eventObj,
     jlongArray eventTimeNanoSampleArray = jlongArray(env->GetObjectField(eventObj,
             gMotionEventClassInfo.mEventTimeNanoSamples));
 
-    LOG_FATAL_IF(numPointers == 0, "numPointers was zero");
-    LOG_FATAL_IF(numSamples == 0, "numSamples was zero");
-
     jint* pointerIdentifiers = (jint*)env->GetPrimitiveArrayCritical(pointerIdentifierArray, NULL);
     jfloat* dataSamples = (jfloat*)env->GetPrimitiveArrayCritical(dataSampleArray, NULL);
     jlong* eventTimeNanoSamples = (jlong*)env->GetPrimitiveArrayCritical(
@@ -236,22 +243,25 @@ void android_view_MotionEvent_toNative(JNIEnv* env, jobject eventObj,
         event->addSample(sampleEventTime, samplePointerCoords);
     }
 
-    env->ReleasePrimitiveArrayCritical(pointerIdentifierArray, pointerIdentifiers, JNI_ABORT);
-    env->ReleasePrimitiveArrayCritical(dataSampleArray, dataSamples, JNI_ABORT);
     env->ReleasePrimitiveArrayCritical(eventTimeNanoSampleArray, eventTimeNanoSamples, JNI_ABORT);
+    env->ReleasePrimitiveArrayCritical(dataSampleArray, dataSamples, JNI_ABORT);
+    env->ReleasePrimitiveArrayCritical(pointerIdentifierArray, pointerIdentifiers, JNI_ABORT);
 
-    env->DeleteLocalRef(pointerIdentifierArray);
-    env->DeleteLocalRef(dataSampleArray);
     env->DeleteLocalRef(eventTimeNanoSampleArray);
+    env->DeleteLocalRef(dataSampleArray);
+    env->DeleteLocalRef(pointerIdentifierArray);
+    return OK;
 }
 
-void android_view_MotionEvent_recycle(JNIEnv* env, jobject eventObj) {
+status_t android_view_MotionEvent_recycle(JNIEnv* env, jobject eventObj) {
     env->CallVoidMethod(eventObj, gMotionEventClassInfo.recycle);
     if (env->ExceptionCheck()) {
         LOGW("An exception occurred while recycling a motion event.");
         LOGW_EX(env);
         env->ExceptionClear();
+        return UNKNOWN_ERROR;
     }
+    return OK;
 }
 
 static inline float transformAngle(const SkMatrix* matrix, float angleRadians) {
diff --git a/core/jni/android_view_MotionEvent.h b/core/jni/android_view_MotionEvent.h
index 86e4bde..80dc861 100644
--- a/core/jni/android_view_MotionEvent.h
+++ b/core/jni/android_view_MotionEvent.h
@@ -18,20 +18,24 @@
 #define _ANDROID_VIEW_MOTIONEVENT_H
 
 #include "jni.h"
+#include <utils/Errors.h>
 
 namespace android {
 
 class MotionEvent;
 
-/* Obtains an instance of a DVM MotionEvent object as a copy of a native MotionEvent instance. */
+/* Obtains an instance of a DVM MotionEvent object as a copy of a native MotionEvent instance.
+ * Returns NULL on error. */
 extern jobject android_view_MotionEvent_fromNative(JNIEnv* env, const MotionEvent* event);
 
-/* Copies the contents of a DVM MotionEvent object to a native MotionEvent instance. */
-extern void android_view_MotionEvent_toNative(JNIEnv* env, jobject eventObj,
+/* Copies the contents of a DVM MotionEvent object to a native MotionEvent instance.
+ * Returns non-zero on error. */
+extern status_t android_view_MotionEvent_toNative(JNIEnv* env, jobject eventObj,
         MotionEvent* event);
 
-/* Recycles a DVM MotionEvent object. */
-extern void android_view_MotionEvent_recycle(JNIEnv* env, jobject eventObj);
+/* Recycles a DVM MotionEvent object.
+ * Returns non-zero on error. */
+extern status_t android_view_MotionEvent_recycle(JNIEnv* env, jobject eventObj);
 
 } // namespace android