[Chromoting] Decouple DesktopView and TouchInputHandler

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 {
     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;
 
     /** Used to disambiguate a 2-finger gesture as a swipe or a pinch. */
     private SwipePinchDetector mSwipePinchDetector;
@@ skipping 139 matching lines @@
         }
 
         @Override
         public boolean isIndirectInputMode() {
             return false;
         }
     }
 
     public TouchInputHandler(DesktopViewInterface viewer, Context context, RenderData renderData) {
         mViewer = viewer;
+        mContext = context;
         mRenderData = renderData;
         mDesktopCanvas = new DesktopCanvas(mViewer, mRenderData);
 
         GestureListener listener = new GestureListener();
         mScroller = new GestureDetector(context, listener, null, false);
 
         // If long-press is enabled, the gesture-detector will not emit any further onScroll
         // notifications after the onLongPress notification. Since onScroll is being used for
         // moving the cursor, it means that the cursor would become stuck if the finger were held
         // down too long.
@@ skipping 57 matching lines @@
         mDesktopCanvas.repositionImageWithZoom(true);
     }
 
     @Override
     public void onHostSizeChanged(int width, int height) {
         moveViewport((float) width / 2, (float) height / 2);
         mDesktopCanvas.resizeImageToFitScreen();
     }
 
     @Override
-    public void onSoftInputMethodVisibilityChanged(boolean inputMethodVisible, Rect bounds) {
-        synchronized (mRenderData) {
-            if (inputMethodVisible) {
-                mDesktopCanvas.setInputMethodOffsetValues(mRenderData.screenWidth - bounds.right,
-                                                          mRenderData.screenHeight - bounds.bottom);
-            } else {
-                mDesktopCanvas.setInputMethodOffsetValues(0, 0);
-            }
-        }
-
-        mDesktopCanvas.repositionImage(true);
-    }
-
-    @Override
     public void processAnimation() {
         boolean active = mCursorAnimationJob.processAnimation();
         active |= mScrollAnimationJob.processAnimation();
 
         if (!active) {
             mViewer.setAnimationEnabled(false);
         }
     }
 
     @Override
-    public void setInputStrategy(InputStrategyInterface inputStrategy) {
+    public void init(Desktop desktop, final Client client) {
+        Preconditions.notNull(client);
+        desktop.onInputModeChanged().add(
+                new Event.ParameterRunnable<InputModeChangedEventParameter>() {
+                    @Override
+                    public void run(InputModeChangedEventParameter parameter) {
+                        handleInputModeChanged(parameter, client);
+                    }
+                });
+
+        desktop.onSoftInputMethodVisibilityChanged().add(
+                new Event.ParameterRunnable<SoftInputMethodVisibilityChangedEventParameter>() {
+                    @Override
+                    public void run(SoftInputMethodVisibilityChangedEventParameter parameter) {
+                        handleSoftInputMethodVisibilityChanged(parameter);
+                    }
+                });
+    }
+
+    private void handleInputModeChanged(InputModeChangedEventParameter parameter,
+                                        Client client) {
+        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));
+                break;
+
+            case TOUCH:
+                if (hostTouchCapability.isSupported()) {
+                    setInputStrategy(new TouchInputStrategy(mRenderData, client));
+                } else {
+                    setInputStrategy(new SimulatedTouchInputStrategy(
+                            mRenderData, client, 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.
+        if (mViewer instanceof DesktopView) {
+            ((DesktopView) mViewer).requestRepaint();
+        }
+    }
+
+    private void handleSoftInputMethodVisibilityChanged(
+            SoftInputMethodVisibilityChangedEventParameter parameter) {
+        synchronized (mRenderData) {
+            if (parameter.visible) {
+                mDesktopCanvas.setInputMethodOffsetValues(
+                        mRenderData.screenWidth - parameter.right,
+                        mRenderData.screenHeight - parameter.bottom);
+            } else {
+                mDesktopCanvas.setInputMethodOffsetValues(0, 0);
+            }
+        }
+
+        mDesktopCanvas.repositionImage(true);
+    }
+
+    private void setInputStrategy(InputStrategyInterface inputStrategy) {
         // Since the rules for flinging differ between input modes, we want to stop running the
         // current fling animation when the mode changes to prevent a wonky experience.
         mCursorAnimationJob.abortAnimation();
         mScrollAnimationJob.abortAnimation();
         mInputStrategy = inputStrategy;
     }
 
     /** Moves the desired center of the viewport using the specified deltas. */
     private void moveViewportWithOffset(float deltaX, float deltaY) {
         // If we are in an indirect mode or are in the middle of a drag operation, then we want to
@@ skipping 272 matching lines @@
                 case 2:
                     return BUTTON_RIGHT;
                 case 3:
                     return BUTTON_MIDDLE;
                 default:
                     return BUTTON_UNDEFINED;
             }
         }
     }
 }