Refactor InputQueue as InputEventReceiver.

This change simplifies the code associated with receiving input
events from input channels and makes it more robust.  It also
does a better job of ensuring that input events are properly
recycled (sometimes we dropped them on the floor).

This change also adds a sequence number to all events, which is
handy for determining whether we are looking at the same event or a
new one, particularly when events are recycled.

Change-Id: I4ebd88f73b5f77f3e150778cd550e7f91956aac2

1 files changed, 0 insertions, 124 deletions

diff --git a/core/java/android/view/InputQueue.java b/core/java/android/view/InputQueue.java
index 1206518..909a3b2 100644
--- a/core/java/android/view/InputQueue.java
+++ b/core/java/android/view/InputQueue.java
@@ -16,18 +16,11 @@
 
 package android.view;
 
-import android.os.MessageQueue;
-import android.util.Slog;
-
 /**
  * An input queue provides a mechanism for an application to receive incoming
  * input events.  Currently only usable from native code.
  */
 public final class InputQueue {
-    private static final String TAG = "InputQueue";
-    
-    private static final boolean DEBUG = false;
-    
     /**
      * Interface to receive notification of when an InputQueue is associated
      * and dissociated with a thread.
@@ -48,13 +41,6 @@ public final class InputQueue {
 
     final InputChannel mChannel;
     
-    private static final Object sLock = new Object();
-    
-    private static native void nativeRegisterInputChannel(InputChannel inputChannel,
-            InputHandler inputHandler, MessageQueue messageQueue);
-    private static native void nativeUnregisterInputChannel(InputChannel inputChannel);
-    private static native void nativeFinished(long finishedToken, boolean handled);
-    
     /** @hide */
     public InputQueue(InputChannel channel) {
         mChannel = channel;
@@ -64,114 +50,4 @@ public final class InputQueue {
     public InputChannel getInputChannel() {
         return mChannel;
     }
-    
-    /**
-     * Registers an input channel and handler.
-     * @param inputChannel The input channel to register.
-     * @param inputHandler The input handler to input events send to the target.
-     * @param messageQueue The message queue on whose thread the handler should be invoked.
-     * @hide
-     */
-    public static void registerInputChannel(InputChannel inputChannel, InputHandler inputHandler,
-            MessageQueue messageQueue) {
-        if (inputChannel == null) {
-            throw new IllegalArgumentException("inputChannel must not be null");
-        }
-        if (inputHandler == null) {
-            throw new IllegalArgumentException("inputHandler must not be null");
-        }
-        if (messageQueue == null) {
-            throw new IllegalArgumentException("messageQueue must not be null");
-        }
-        
-        synchronized (sLock) {
-            if (DEBUG) {
-                Slog.d(TAG, "Registering input channel '" + inputChannel + "'");
-            }
-            
-            nativeRegisterInputChannel(inputChannel, inputHandler, messageQueue);
-        }
-    }
-    
-    /**
-     * Unregisters an input channel.
-     * Does nothing if the channel is not currently registered.
-     * @param inputChannel The input channel to unregister.
-     * @hide
-     */
-    public static void unregisterInputChannel(InputChannel inputChannel) {
-        if (inputChannel == null) {
-            throw new IllegalArgumentException("inputChannel must not be null");
-        }
-
-        synchronized (sLock) {
-            if (DEBUG) {
-                Slog.d(TAG, "Unregistering input channel '" + inputChannel + "'");
-            }
-            
-            nativeUnregisterInputChannel(inputChannel);
-        }
-    }
-    
-    @SuppressWarnings("unused")
-    private static void dispatchInputEvent(InputHandler inputHandler,
-            InputEvent event, long finishedToken) {
-        FinishedCallback finishedCallback = FinishedCallback.obtain(finishedToken);
-        inputHandler.handleInputEvent(event, finishedCallback);
-    }
-
-    /**
-     * A callback that must be invoked to when finished processing an event.
-     * @hide
-     */
-    public static final class FinishedCallback {
-        private static final boolean DEBUG_RECYCLING = false;
-        
-        private static final int RECYCLE_MAX_COUNT = 4;
-        
-        private static FinishedCallback sRecycleHead;
-        private static int sRecycleCount;
-        
-        private FinishedCallback mRecycleNext;
-        private long mFinishedToken;
-        
-        private FinishedCallback() {
-        }
-        
-        public static FinishedCallback obtain(long finishedToken) {
-            synchronized (sLock) {
-                FinishedCallback callback = sRecycleHead;
-                if (callback != null) {
-                    sRecycleHead = callback.mRecycleNext;
-                    sRecycleCount -= 1;
-                    callback.mRecycleNext = null;
-                } else {
-                    callback = new FinishedCallback();
-                }
-                callback.mFinishedToken = finishedToken;
-                return callback;
-            }
-        }
-        
-        public void finished(boolean handled) {
-            synchronized (sLock) {
-                if (mFinishedToken == -1) {
-                    throw new IllegalStateException("Event finished callback already invoked.");
-                }
-                
-                nativeFinished(mFinishedToken, handled);
-                mFinishedToken = -1;
-
-                if (sRecycleCount < RECYCLE_MAX_COUNT) {
-                    mRecycleNext = sRecycleHead;
-                    sRecycleHead = this;
-                    sRecycleCount += 1;
-                    
-                    if (DEBUG_RECYCLING) {
-                        Slog.d(TAG, "Recycled finished callbacks: " + sRecycleCount);
-                    }
-                }
-            }
-        }
-    }
 }