[Chromoting] Add InputInjector and InputInjectorWrapper for easy unittesting

remoting/android/java/src/org/chromium/chromoting/TouchInputStrategy.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chromoting;
 
 import android.graphics.Matrix;
+import android.graphics.Point;
 import android.view.MotionEvent;
 
-import org.chromium.base.VisibleForTesting;
-import org.chromium.chromoting.jni.Client;
-import org.chromium.chromoting.jni.TouchEventData;
-
-import java.util.ArrayList;
 import java.util.LinkedList;
-import java.util.List;
 import java.util.Queue;
 
 /**
  * This class receives local touch input events and forwards them to the remote host.
  * A queue of MotionEvents is built up and then either transmitted to the remote host if one of its
  * remote gesture handler methods is called (such as onScroll) or it is cleared if the current
  * stream of events does not represent a remote gesture.
  * NOTE: Not all touch gestures are remoted.  Touch input and gestures outside the supported ones
  *       (which includes tapping and 2 finger panning) will either affect the local canvas or
  *       will be dropped/ignored.
  */
 public class TouchInputStrategy implements InputStrategyInterface {
     /**
-     * This interface abstracts the injection mechanism to allow for unit testing.
-     */
-    public interface RemoteInputInjector {
-        public void injectMouseEvent(int x, int y, int button, boolean buttonDown);
-        public void injectTouchEvent(TouchEventData.EventType eventType, TouchEventData[] data);
-    }
-
-    /**
-     * This class provides the default implementation for injecting remote events.
-     */
-    private class DefaultInputInjector implements RemoteInputInjector {
-        @Override
-        public void injectMouseEvent(int x, int y, int button, boolean buttonDown) {
-            mClient.sendMouseEvent(x, y, button, buttonDown);
-        }
-
-        @Override
-        public void injectTouchEvent(TouchEventData.EventType eventType, TouchEventData[] data) {
-            mClient.sendTouchEvent(eventType, data);
-        }
-    }
-
-    /**
      * Contains the maximum number of MotionEvents to store before cancelling the current gesture.
      * The size is ~3x the largest number of events seen during any remotable gesture sequence.
      */
     private static final int QUEUED_EVENT_THRESHOLD = 50;
 
     /**
      * Contains the set of MotionEvents received for the current gesture candidate.  If one of the
      * gesture handling methods is called, these queued events will be transmitted to the remote
      * host for injection.  The queue has a maximum size determined by |QUEUED_EVENT_THRESHOLD| to
      * prevent a live memory leak where the queue grows unbounded during a local gesture (such as
      * someone panning the local canvas continuously for several seconds/minutes).
      */
     private Queue<MotionEvent> mQueuedEvents;
 
     /**
      * Indicates that the events received should be treated as part of an active remote gesture.
      */
     private boolean mInRemoteGesture = false;
 
     /**
      * Indicates whether MotionEvents and gestures should be acted upon or ignored.  This flag is
      * set when we believe that the current sequence of events is not something we should remote.
      */
     private boolean mIgnoreTouchEvents = false;
 
     private final RenderData mRenderData;
+    private final InputEventSender mInjector;
 
-    private final Client mClient;
-
-    private RemoteInputInjector mRemoteInputInjector;
-
-    public TouchInputStrategy(RenderData renderData, Client client) {
+    public TouchInputStrategy(RenderData renderData, InputEventSender injector) {
+        Preconditions.notNull(injector);
         mRenderData = renderData;
-        mClient = client;
-        mRemoteInputInjector = new DefaultInputInjector();
+        mInjector = injector;
         mQueuedEvents = new LinkedList<MotionEvent>();
 
         synchronized (mRenderData) {
             mRenderData.drawCursor = false;
         }
     }
 
     @Override
     public boolean onTap(int button) {
         if (mQueuedEvents.isEmpty() || mIgnoreTouchEvents) {
             return false;
         }
 
         switch (button) {
-            case TouchInputHandlerInterface.BUTTON_LEFT:
+            case InputStub.BUTTON_LEFT:
                 injectQueuedEvents();
                 return true;
 
-            case TouchInputHandlerInterface.BUTTON_RIGHT:
+            case InputStub.BUTTON_RIGHT:
                 // Using the mouse for right-clicking is consistent across all host platforms.
                 // Right-click gestures are often platform specific and can be tricky to simulate.
 
                 // Grab the first queued event which should be the initial ACTION_DOWN event.
                 MotionEvent downEvent = mQueuedEvents.peek();
                 assert downEvent.getActionMasked() == MotionEvent.ACTION_DOWN;
 
-                int x = (int) downEvent.getX();
-                int y = (int) downEvent.getY();
-                mRemoteInputInjector.injectMouseEvent(
-                        x, y, TouchInputHandlerInterface.BUTTON_RIGHT, true);
-                mRemoteInputInjector.injectMouseEvent(
-                        x, y, TouchInputHandlerInterface.BUTTON_RIGHT, false);
+                mInjector.sendMouseClick(new Point((int) downEvent.getX(), (int) downEvent.getY()),
+                        InputStub.BUTTON_RIGHT);
                 clearQueuedEvents();
                 return true;
 
             default:
                 // Tap gestures for > 2 fingers are not supported.
                 return false;
         }
     }
 
     @Override
     public boolean onPressAndHold(int button) {
-        if (button != TouchInputHandlerInterface.BUTTON_LEFT || mQueuedEvents.isEmpty()
+        if (button != InputStub.BUTTON_LEFT || mQueuedEvents.isEmpty()
                 || mIgnoreTouchEvents) {
             return false;
         }
 
         mInRemoteGesture = true;
         injectQueuedEvents();
         return true;
     }
 
     @Override
@@ skipping 44 matching lines @@
                     mQueuedEvents.add(transformToRemoteCoordinates(event));
                 }
                 break;
 
             case MotionEvent.ACTION_CANCEL:
             case MotionEvent.ACTION_MOVE:
             case MotionEvent.ACTION_POINTER_UP:
             case MotionEvent.ACTION_UP:
                 event = transformToRemoteCoordinates(event);
                 if (mInRemoteGesture) {
-                    injectTouchEventData(event);
+                    mInjector.sendTouchEvent(event);
                     event.recycle();
                 } else {
                     mQueuedEvents.add(event);
                 }
                 break;
 
             default:
                 break;
         }
     }
 
     @Override
     public void injectCursorMoveEvent(int x, int y) {}
 
     @Override
     public DesktopView.InputFeedbackType getShortPressFeedbackType() {
         return DesktopView.InputFeedbackType.NONE;
     }
 
     @Override
     public DesktopView.InputFeedbackType getLongPressFeedbackType() {
         return DesktopView.InputFeedbackType.LARGE_ANIMATION;
     }
 
     @Override
     public boolean isIndirectInputMode() {
         return false;
     }
 
-    @VisibleForTesting
-    protected void setRemoteInputInjectorForTest(RemoteInputInjector injector) {
-        mRemoteInputInjector = injector;
-    }
-
-    /**
-     * Extracts the touch point data from a MotionEvent, converts each point into a marshallable
-     * object and passes the set of points to the JNI layer to be transmitted to the remote host.
-     *
-     * @param event The event to send to the remote host for injection.  NOTE: This object must be
-     *              updated to represent the remote machine's coordinate system before calling this
-     *              function.  This should be done via the transformToRemoteCoordinates() method.
-     */
-    private void injectTouchEventData(MotionEvent event) {
-        int action = event.getActionMasked();
-        TouchEventData.EventType touchEventType = TouchEventData.EventType.fromMaskedAction(action);
-        List<TouchEventData> touchEventList = new ArrayList<TouchEventData>();
-
-        if (action == MotionEvent.ACTION_MOVE) {
-            // In order to process all of the events associated with an ACTION_MOVE event, we need
-            // to walk the list of historical events in order and add each event to our list, then
-            // retrieve the current move event data.
-            int pointerCount = event.getPointerCount();
-            int historySize = event.getHistorySize();
-            for (int h = 0; h < historySize; ++h) {
-                for (int p = 0; p < pointerCount; ++p) {
-                    touchEventList.add(new TouchEventData(event.getPointerId(p),
-                            event.getHistoricalX(p, h), event.getHistoricalY(p, h),
-                            event.getHistoricalSize(p, h), event.getHistoricalSize(p, h),
-                            event.getHistoricalOrientation(p, h),
-                            event.getHistoricalPressure(p, h)));
-                }
-            }
-
-            for (int p = 0; p < pointerCount; p++) {
-                touchEventList.add(new TouchEventData(event.getPointerId(p), event.getX(p),
-                        event.getY(p), event.getSize(p), event.getSize(p), event.getOrientation(p),
-                        event.getPressure(p)));
-            }
-        } else {
-            // For all other events, we only want to grab the current/active pointer.  The event
-            // contains a list of every active pointer but passing all of of these to the host can
-            // cause confusion on the remote OS side and result in broken touch gestures.
-            int activePointerIndex = event.getActionIndex();
-            touchEventList.add(new TouchEventData(event.getPointerId(activePointerIndex),
-                    event.getX(activePointerIndex), event.getY(activePointerIndex),
-                    event.getSize(activePointerIndex), event.getSize(activePointerIndex),
-                    event.getOrientation(activePointerIndex),
-                    event.getPressure(activePointerIndex)));
-        }
-
-        if (!touchEventList.isEmpty()) {
-            TouchEventData[] touchEventArray = new TouchEventData[touchEventList.size()];
-            mRemoteInputInjector.injectTouchEvent(
-                    touchEventType, touchEventList.toArray(touchEventArray));
-        }
-    }
-
     private void injectQueuedEvents() {
         while (!mQueuedEvents.isEmpty()) {
             MotionEvent event = mQueuedEvents.remove();
-            injectTouchEventData(event);
+            mInjector.sendTouchEvent(event);
             event.recycle();
         }
     }
 
     private void clearQueuedEvents() {
         while (!mQueuedEvents.isEmpty()) {
             mQueuedEvents.remove().recycle();
         }
     }
 
@@ skipping 12 matching lines @@
 
         return event;
     }
 
     private void resetStateData() {
         clearQueuedEvents();
         mInRemoteGesture = false;
         mIgnoreTouchEvents = false;
     }
 }