Rewrite input handling for native applications

Bug: 8473020
Change-Id: Ic4353d8924ab877bec21aff8c2dba9fe725bf906

2 files changed, 85 insertions, 103 deletions

diff --git a/include/android_runtime/android_app_NativeActivity.h b/include/android_runtime/android_app_NativeActivity.h
index 7977c23..e096e91 100644
--- a/include/android_runtime/android_app_NativeActivity.h
+++ b/include/android_runtime/android_app_NativeActivity.h
@@ -17,7 +17,6 @@
 #ifndef _ANDROID_APP_NATIVEACTIVITY_H
 #define _ANDROID_APP_NATIVEACTIVITY_H
 
-#include <androidfw/InputTransport.h>
 #include <utils/Looper.h>
 
 #include <android/native_activity.h>
@@ -43,106 +42,4 @@ extern void android_NativeActivity_hideSoftInput(
 
 } // namespace android
 
-
-/*
- * NDK input queue API.
- *
- * Here is the event flow:
- * 1. Event arrives in input consumer, and is returned by getEvent().
- * 2. Application calls preDispatchEvent():
- *    a. Event is assigned a sequence ID and enqueued in mPreDispatchingKeys.
- *    b. Main thread picks up event, hands to input method.
- *    c. Input method eventually returns sequence # and whether it was handled.
- *    d. finishPreDispatch() is called to enqueue the information.
- *    e. next getEvent() call will:
- *       - finish any pre-dispatch events that the input method handled
- *       - return the next pre-dispatched event that the input method didn't handle.
- *    f. (A preDispatchEvent() call on this event will now return false).
- * 3. Application calls finishEvent() with whether it was handled.
- *    - If handled is true, the event is finished.
- *    - If handled is false, the event is put on mUnhandledKeys, and:
- *      a. Main thread receives event from consumeUnhandledEvent().
- *      b. Java sends event through default key handler.
- *      c. event is finished.
- */
-struct AInputQueue {
-public:
-    /* Creates a consumer associated with an input channel. */
-    explicit AInputQueue(const android::sp<android::InputChannel>& channel, int workWrite);
-
-    /* Destroys the consumer and releases its input channel. */
-    ~AInputQueue();
-
-    void attachLooper(ALooper* looper, int ident, ALooper_callbackFunc callback, void* data);
-
-    void detachLooper();
-
-    int32_t hasEvents();
-
-    int32_t getEvent(AInputEvent** outEvent);
-
-    bool preDispatchEvent(AInputEvent* event);
-
-    void finishEvent(AInputEvent* event, bool handled, bool didDefaultHandling);
-
-    // ----------------------------------------------------------
-
-    inline android::InputConsumer& getConsumer() { return mConsumer; }
-
-    void dispatchEvent(android::KeyEvent* event);
-
-    void finishPreDispatch(int seq, bool handled);
-
-    android::KeyEvent* consumeUnhandledEvent();
-    android::KeyEvent* consumePreDispatchingEvent(int* outSeq);
-
-    android::KeyEvent* createKeyEvent();
-
-    int mWorkWrite;
-
-private:
-    void doUnhandledKey(android::KeyEvent* keyEvent);
-    bool preDispatchKey(android::KeyEvent* keyEvent);
-    void wakeupDispatchLocked();
-
-    android::PooledInputEventFactory mPooledInputEventFactory;
-    android::InputConsumer mConsumer;
-    android::sp<android::Looper> mLooper;
-
-    int mDispatchKeyRead;
-    int mDispatchKeyWrite;
-
-    struct in_flight_event {
-        android::InputEvent* event;
-        int seq; // internal sequence number for synthetic pre-dispatch events
-        uint32_t finishSeq; // sequence number for sendFinishedSignal, or 0 if finish not required
-    };
-
-    struct finish_pre_dispatch {
-        int seq;
-        bool handled;
-    };
-
-    android::Mutex mLock;
-
-    int mSeq;
-
-    // All input events that are actively being processed.
-    android::Vector<in_flight_event> mInFlightEvents;
-
-    // Key events that the app didn't handle, and are pending for
-    // delivery to the activity's default key handling.
-    android::Vector<android::KeyEvent*> mUnhandledKeys;
-
-    // Keys that arrived in the Java framework and need to be
-    // dispatched to the app.
-    android::Vector<android::KeyEvent*> mDispatchingKeys;
-
-    // Key events that are pending to be pre-dispatched to the IME.
-    android::Vector<in_flight_event> mPreDispatchingKeys;
-
-    // Event sequence numbers that we have finished pre-dispatching.
-    android::Vector<finish_pre_dispatch> mFinishPreDispatches;
-};
-
 #endif // _ANDROID_APP_NATIVEACTIVITY_H
diff --git a/include/android_runtime/android_view_InputQueue.h b/include/android_runtime/android_view_InputQueue.h
new file mode 100644
index 0000000..ba2d02d
--- /dev/null
+++ b/include/android_runtime/android_view_InputQueue.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _ANDROID_VIEW_INPUTQUEUE_H
+#define _ANDROID_VIEW_INPUTQUEUE_H
+
+#include <androidfw/Input.h>
+#include <utils/Looper.h>
+#include <utils/TypeHelpers.h>
+#include <utils/Vector.h>
+
+#include "JNIHelp.h"
+
+/*
+ * Declare a concrete type for the NDK's AInputQueue forward declaration
+ */
+struct AInputQueue{
+};
+
+namespace android {
+
+class InputQueue : public AInputQueue, public MessageHandler {
+public:
+    virtual ~InputQueue();
+
+    void attachLooper(Looper* looper, int ident, ALooper_callbackFunc callback, void* data);
+
+    void detachLooper();
+
+    bool hasEvents();
+
+    status_t getEvent(InputEvent** outEvent);
+
+    bool preDispatchEvent(InputEvent* event);
+
+    void finishEvent(InputEvent* event, bool handled);
+
+    KeyEvent* createKeyEvent();
+
+    MotionEvent* createMotionEvent();
+
+    void recycleInputEvent(InputEvent* event);
+
+    void enqueueEvent(InputEvent* event);
+
+    static InputQueue* createQueue(jobject inputQueueObj, const sp<Looper>& looper);
+
+protected:
+    virtual void handleMessage(const Message& message);
+
+private:
+    InputQueue(jobject inputQueueObj, const sp<Looper>& looper,
+            int readDispatchFd, int writeDispatchFd);
+
+    void detachLooperLocked();
+
+    jobject mInputQueueWeakGlobal;
+    int mDispatchReadFd;
+    int mDispatchWriteFd;
+    Vector<Looper*> mAppLoopers;
+    sp<Looper> mDispatchLooper;
+    sp<WeakMessageHandler> mHandler;
+    PooledInputEventFactory mPooledInputEventFactory;
+    // Guards the pending and finished event vectors
+    mutable Mutex mLock;
+    Vector<InputEvent*> mPendingEvents;
+    Vector<key_value_pair_t<InputEvent*, bool> > mFinishedEvents;
+};
+
+} // namespace android
+
+#endif