[Chromoting] Add InputInjector and InputInjectorWrapper for easy unittesting

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

 // Copyright 2013 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.content.Context;
 import android.graphics.Matrix;
 import android.graphics.Point;
 import android.graphics.PointF;
 import android.graphics.Rect;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.ScaleGestureDetector;
 import android.view.ViewConfiguration;
 
-import org.chromium.chromoting.jni.Client;
-
 /**
  * This class is responsible for handling Touch input from the user.  Touch events which manipulate
  * the local canvas are handled in this class and any input which should be sent to the remote host
  * are passed to the InputStrategyInterface implementation set by the DesktopView.
  */
-public class TouchInputHandler implements TouchInputHandlerInterface {
+public class TouchInputHandler {
     private final DesktopViewInterface mViewer;
     private final Context mContext;
     private final RenderData mRenderData;
     private final DesktopCanvas mDesktopCanvas;
     private InputStrategyInterface mInputStrategy;
 
     private GestureDetector mScroller;
     private ScaleGestureDetector mZoomer;
     private TapGestureDetector mTapDetector;
 
@@ skipping 174 matching lines @@
         mEdgeSlopInPx = ViewConfiguration.get(context).getScaledEdgeSlop();
 
         mInputStrategy = new NullInputStrategy();
 
         mCursorAnimationJob = new CursorAnimationJob(context);
         mScrollAnimationJob = new ScrollAnimationJob(context);
 
         attachViewEvents(viewer);
     }
 
-    @Override
     public void processAnimation() {
         boolean active = mCursorAnimationJob.processAnimation();
         active |= mScrollAnimationJob.processAnimation();
 
         if (!active) {
             mViewer.setAnimationEnabled(false);
         }
     }
 
-    @Override
-    public void init(Desktop desktop, final Client client) {
-        Preconditions.notNull(client);
+    public void init(Desktop desktop, final InputEventSender injector) {
+        Preconditions.notNull(injector);
         desktop.onInputModeChanged().add(
                 new Event.ParameterRunnable<InputModeChangedEventParameter>() {
                     @Override
                     public void run(InputModeChangedEventParameter parameter) {
-                        handleInputModeChanged(parameter, client);
+                        handleInputModeChanged(parameter, injector);
                     }
                 });
 
         desktop.onSoftInputMethodVisibilityChanged().add(
                 new Event.ParameterRunnable<SoftInputMethodVisibilityChangedEventParameter>() {
                     @Override
                     public void run(SoftInputMethodVisibilityChangedEventParameter parameter) {
                         handleSoftInputMethodVisibilityChanged(parameter);
                     }
                 });
@@ skipping 13 matching lines @@
             }
         });
         viewer.onHostSizeChanged().add(new Event.ParameterRunnable<SizeChangedEventParameter>() {
             @Override
             public void run(SizeChangedEventParameter parameter) {
                 handleHostSizeChanged(parameter.width, parameter.height);
             }
         });
     }
 
-    private void handleInputModeChanged(InputModeChangedEventParameter parameter,
-                                        Client client) {
+    private void handleInputModeChanged(
+            InputModeChangedEventParameter parameter, InputEventSender injector) {
         final Desktop.InputMode inputMode = parameter.inputMode;
         final CapabilityManager.HostCapability hostTouchCapability =
                 parameter.hostCapability;
         // We need both input mode and host input capabilities to select the input
         // strategy.
         if (!inputMode.isSet() || !hostTouchCapability.isSet()) {
             return;
         }
 
         switch (inputMode) {
             case TRACKPAD:
-                setInputStrategy(new TrackpadInputStrategy(mRenderData, client));
+                setInputStrategy(new TrackpadInputStrategy(mRenderData, injector));
                 break;
 
             case TOUCH:
                 if (hostTouchCapability.isSupported()) {
-                    setInputStrategy(new TouchInputStrategy(mRenderData, client));
+                    setInputStrategy(new TouchInputStrategy(mRenderData, injector));
                 } else {
-                    setInputStrategy(new SimulatedTouchInputStrategy(
-                            mRenderData, client, mContext));
+                    setInputStrategy(
+                            new SimulatedTouchInputStrategy(mRenderData, injector, mContext));
                 }
                 break;
 
             default:
                 // Unreachable, but required by Google Java style and findbugs.
                 assert false : "Unreached";
         }
 
         // Ensure the cursor state is updated appropriately.
         // TODO (zijiehe): Move repaint control out of DesktopView.
@@ skipping 290 matching lines @@
         /** Called when the user is done zooming. Defers to onScale()'s judgement. */
         @Override
         public void onScaleEnd(ScaleGestureDetector detector) {
             onScale(detector);
         }
 
         /** Called when the user taps the screen with one or more fingers. */
         @Override
         public boolean onTap(int pointerCount, float x, float y) {
             int button = mouseButtonFromPointerCount(pointerCount);
-            if (button == BUTTON_UNDEFINED) {
+            if (button == InputStub.BUTTON_UNDEFINED) {
                 return false;
             }
 
             if (!mInputStrategy.isIndirectInputMode()) {
                 moveCursorToScreenPoint(x, y);
             }
 
             if (mInputStrategy.onTap(button)) {
                 Point pos;
                 synchronized (mRenderData) {
                     pos = mRenderData.getCursorPosition();
                 }
                 mViewer.showInputFeedback(mInputStrategy.getShortPressFeedbackType(), pos);
             }
             return true;
         }
 
         /** Called when a long-press is triggered for one or more fingers. */
         @Override
         public void onLongPress(int pointerCount, float x, float y) {
             int button = mouseButtonFromPointerCount(pointerCount);
-            if (button == BUTTON_UNDEFINED) {
+            if (button == InputStub.BUTTON_UNDEFINED) {
                 return;
             }
 
             if (!mInputStrategy.isIndirectInputMode()) {
                 moveCursorToScreenPoint(x, y);
             }
 
             if (mInputStrategy.onPressAndHold(button)) {
                 Point pos;
                 synchronized (mRenderData) {
                     pos = mRenderData.getCursorPosition();
                 }
                 mViewer.showInputFeedback(mInputStrategy.getLongPressFeedbackType(), pos);
                 mSuppressFling = true;
                 mIsDragging = true;
             }
         }
 
         /** Maps the number of fingers in a tap or long-press gesture to a mouse-button. */
         private int mouseButtonFromPointerCount(int pointerCount) {
             switch (pointerCount) {
                 case 1:
-                    return BUTTON_LEFT;
+                    return InputStub.BUTTON_LEFT;
                 case 2:
-                    return BUTTON_RIGHT;
+                    return InputStub.BUTTON_RIGHT;
                 case 3:
-                    return BUTTON_MIDDLE;
+                    return InputStub.BUTTON_MIDDLE;
                 default:
-                    return BUTTON_UNDEFINED;
+                    return InputStub.BUTTON_UNDEFINED;
             }
         }
     }
 }