[Chromoting] TouchInputHandler now listens to events in DesktopView

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;
@@ skipping 194 matching lines @@
         // that intentional swipes are usually detected.
         float density = context.getResources().getDisplayMetrics().density;
         mSwipeThreshold = 40 * density;
 
         mEdgeSlopInPx = ViewConfiguration.get(context).getScaledEdgeSlop();
 
         mInputStrategy = new NullInputStrategy();
 
         mCursorAnimationJob = new CursorAnimationJob(context);
         mScrollAnimationJob = new ScrollAnimationJob(context);
+
+        attachViewEvents(viewer);
     }
 
     @Override
-    public boolean onTouchEvent(MotionEvent event) {
-        // Give the underlying input strategy a chance to observe the current motion event before
-        // passing it to the gesture detectors.  This allows the input strategy to react to the
-        // event or save the payload for use in recreating the gesture remotely.
-        mInputStrategy.onMotionEvent(event);
-
-        // Avoid short-circuit logic evaluation - ensure all gesture detectors see all events so
-        // that they generate correct notifications.
-        boolean handled = mScroller.onTouchEvent(event);
-        handled |= mZoomer.onTouchEvent(event);
-        handled |= mTapDetector.onTouchEvent(event);
-        mSwipePinchDetector.onTouchEvent(event);
-
-        switch (event.getActionMasked()) {
-            case MotionEvent.ACTION_DOWN:
-                mViewer.setAnimationEnabled(false);
-                mSuppressCursorMovement = false;
-                mSuppressFling = false;
-                mSwipeCompleted = false;
-                mIsDragging = false;
-                break;
-
-            case MotionEvent.ACTION_POINTER_DOWN:
-                mTotalMotionY = 0;
-                break;
-
-            default:
-                break;
-        }
-        return handled;
-    }
-
-    @Override
-    public void onClientSizeChanged(int width, int height) {
-        mPanGestureBounds = new Rect(
-                mEdgeSlopInPx, mEdgeSlopInPx, width - mEdgeSlopInPx, height - mEdgeSlopInPx);
-        mDesktopCanvas.repositionImageWithZoom(true);
-    }
-
-    @Override
-    public void onHostSizeChanged(int width, int height) {
-        moveViewport((float) width / 2, (float) height / 2);
-        mDesktopCanvas.resizeImageToFitScreen();
-    }
-
-    @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);
         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 attachViewEvents(DesktopViewInterface viewer) {
+        viewer.onTouch().add(new Event.ParameterRunnable<TouchEventParameter>() {
+            @Override
+            public void run(TouchEventParameter parameter) {
+                parameter.handled = handleTouchEvent(parameter.event);
+            }
+        });
+        viewer.onClientSizeChanged().add(new Event.ParameterRunnable<SizeChangedEventParameter>() {
+            @Override
+            public void run(SizeChangedEventParameter parameter) {
+                handleClientSizeChanged(parameter.width, parameter.height);
+            }
+        });
+        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) {
         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;
         }
@@ skipping 32 matching lines @@
                         mRenderData.screenWidth - parameter.right,
                         mRenderData.screenHeight - parameter.bottom);
             } else {
                 mDesktopCanvas.setInputMethodOffsetValues(0, 0);
             }
         }
 
         mDesktopCanvas.repositionImage(true);
     }
 
+    private boolean handleTouchEvent(MotionEvent event) {
+        // Give the underlying input strategy a chance to observe the current motion event before
+        // passing it to the gesture detectors.  This allows the input strategy to react to the
+        // event or save the payload for use in recreating the gesture remotely.
+        mInputStrategy.onMotionEvent(event);
+
+        // Avoid short-circuit logic evaluation - ensure all gesture detectors see all events so
+        // that they generate correct notifications.
+        boolean handled = mScroller.onTouchEvent(event);
+        handled |= mZoomer.onTouchEvent(event);
+        handled |= mTapDetector.onTouchEvent(event);
+        mSwipePinchDetector.onTouchEvent(event);
+
+        switch (event.getActionMasked()) {
+            case MotionEvent.ACTION_DOWN:
+                mViewer.setAnimationEnabled(false);
+                mSuppressCursorMovement = false;
+                mSuppressFling = false;
+                mSwipeCompleted = false;
+                mIsDragging = false;
+                break;
+
+            case MotionEvent.ACTION_POINTER_DOWN:
+                mTotalMotionY = 0;
+                break;
+
+            default:
+                break;
+        }
+        return handled;
+    }
+
+    private void handleClientSizeChanged(int width, int height) {
+        mPanGestureBounds = new Rect(
+                mEdgeSlopInPx, mEdgeSlopInPx, width - mEdgeSlopInPx, height - mEdgeSlopInPx);
+        mDesktopCanvas.repositionImageWithZoom(true);
+    }
+
+    private void handleHostSizeChanged(int width, int height) {
+        moveViewport((float) width / 2, (float) height / 2);
+        mDesktopCanvas.resizeImageToFitScreen();
+    }
+
     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) {
@@ skipping 273 matching lines @@
                 case 2:
                     return BUTTON_RIGHT;
                 case 3:
                     return BUTTON_MIDDLE;
                 default:
                     return BUTTON_UNDEFINED;
             }
         }
     }
 }