[Remoting Android] Refactor GlDesktopView

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.PointF;
 import android.graphics.Rect;
+import android.util.Pair;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.ScaleGestureDetector;
 import android.view.ViewConfiguration;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * 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 {
     private static final float EPSILON = 0.001f;
 
+    private final List<Pair<Object, Event<?>>> mAttachedEvents = new ArrayList<>();
     private final DesktopView 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;
+    private final RenderStub mRenderStub;
+    private final GestureDetector mScroller;
+    private final ScaleGestureDetector mZoomer;
+    private final TapGestureDetector mTapDetector;
 
     /** Used to disambiguate a 2-finger gesture as a swipe or a pinch. */
-    private SwipePinchDetector mSwipePinchDetector;
+    private final SwipePinchDetector mSwipePinchDetector;
 
     // Used for processing cursor & scroller fling animations.
     // May consider using a List of AnimationJob if we have more than two animation jobs in
     // the future.
-    private FlingAnimationJob mCursorAnimationJob,  mScrollAnimationJob;
+    private final FlingAnimationJob mCursorAnimationJob;
+    private final FlingAnimationJob mScrollAnimationJob;
+
+    private InputStrategyInterface mInputStrategy;
 
     /**
      * Used for tracking swipe gestures. Only the Y-direction is needed for responding to swipe-up
      * or swipe-down.
      */
     private float mTotalMotionY = 0;
 
     /**
      * Distance in pixels beyond which a motion gesture is considered to be a swipe. This is
      * initialized using the Context passed into the ctor.
@@ skipping 122 matching lines @@
         public RenderStub.InputFeedbackType getLongPressFeedbackType() {
             return RenderStub.InputFeedbackType.NONE;
         }
 
         @Override
         public boolean isIndirectInputMode() {
             return false;
         }
     }
 
-    public TouchInputHandler(DesktopView viewer, Context context) {
+    public TouchInputHandler(DesktopView viewer, Desktop desktop, RenderStub renderStub,
+                             final InputEventSender injector) {
+        Preconditions.notNull(injector);
+        Preconditions.notNull(renderStub);

[joedow, 2016/09/13 00:08:51]

Why only check if the last two params are non-null?

[Yuwei, 2016/09/13 01:42:26]

Added checks for the first two.

Probably because they were first added in the init() function which was later
merged into the ctor.

+
         mViewer = viewer;
-        mContext = context;
+        mContext = desktop;
+        mRenderStub = renderStub;
         mRenderData = new RenderData();
-        mDesktopCanvas = new DesktopCanvas(mViewer, mRenderData);
+        mDesktopCanvas = new DesktopCanvas(renderStub, mRenderData);
 
         GestureListener listener = new GestureListener();
-        mScroller = new GestureDetector(context, listener, null, false);
+        mScroller = new GestureDetector(desktop, 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.
         mScroller.setIsLongpressEnabled(false);
 
-        mZoomer = new ScaleGestureDetector(context, listener);
-        mTapDetector = new TapGestureDetector(context, listener);
-        mSwipePinchDetector = new SwipePinchDetector(context);
+        mZoomer = new ScaleGestureDetector(desktop, listener);
+        mTapDetector = new TapGestureDetector(desktop, listener);
+        mSwipePinchDetector = new SwipePinchDetector(desktop);
 
         // The threshold needs to be bigger than the ScaledTouchSlop used by the gesture-detectors,
         // so that a gesture cannot be both a tap and a swipe. It also needs to be small enough so
         // that intentional swipes are usually detected.
-        float density = context.getResources().getDisplayMetrics().density;
+        float density = desktop.getResources().getDisplayMetrics().density;
         mSwipeThreshold = 40 * density;
 
-        mEdgeSlopInPx = ViewConfiguration.get(context).getScaledEdgeSlop();
+        mEdgeSlopInPx = ViewConfiguration.get(desktop).getScaledEdgeSlop();
 
         mInputStrategy = new NullInputStrategy();
 
-        mCursorAnimationJob = new CursorAnimationJob(context);
-        mScrollAnimationJob = new ScrollAnimationJob(context);
+        mCursorAnimationJob = new CursorAnimationJob(desktop);
+        mScrollAnimationJob = new ScrollAnimationJob(desktop);
 
         mProcessAnimationCallback = new Event.ParameterCallback<Boolean, Void>() {
             @Override
             public Boolean run(Void p) {
                 return processAnimation();
             }
         };
 
-        attachViewEvents(viewer);
+        attachEvent(mViewer.onTouch(), new Event.ParameterRunnable<TouchEventParameter>() {
+            @Override
+            public void run(TouchEventParameter parameter) {
+                parameter.handled = handleTouchEvent(parameter.event);
+            }
+        });
+
+        attachEvent(desktop.onInputModeChanged(),
+                new Event.ParameterRunnable<InputModeChangedEventParameter>() {
+                    @Override
+                    public void run(InputModeChangedEventParameter parameter) {
+                        handleInputModeChanged(parameter, injector);
+                    }
+                });
+
+        attachEvent(desktop.onSystemUiVisibilityChanged(),
+                new Event.ParameterRunnable<SystemUiVisibilityChangedEventParameter>() {
+                    @Override
+                    public void run(SystemUiVisibilityChangedEventParameter parameter) {
+                        handleSystemUiVisibilityChanged(parameter);
+                    }
+                });
+
+        attachEvent(renderStub.onClientSizeChanged(),
+                new Event.ParameterRunnable<SizeChangedEventParameter>() {
+                    @Override
+                    public void run(SizeChangedEventParameter parameter) {
+                        handleClientSizeChanged(parameter.width, parameter.height);
+                    }
+                });
+
+        attachEvent(renderStub.onHostSizeChanged(),
+                new Event.ParameterRunnable<SizeChangedEventParameter>() {
+                    @Override
+                    public void run(SizeChangedEventParameter parameter) {
+                        handleHostSizeChanged(parameter.width, parameter.height);
+                    }
+                });
+    }
+
+    private <ParamT> void attachEvent(Event<ParamT> event,
+                                      Event.ParameterRunnable<ParamT> runnable) {
+        mAttachedEvents.add(new Pair<Object, Event<?>>(event.add(runnable), event));
     }
 
     /**
+     * Detaches all registered event listeners.
+     */
+    public void detachEventListeners() {
+        abortAnimation();
+        for (Pair<Object, Event<?>> pair : mAttachedEvents) {
+            pair.second.remove(pair.first);
+        }
+        mAttachedEvents.clear();
+    }
+
+    /**
      * Steps forward the animation.
      * @return true if the animation is not finished yet.
      */
     private boolean processAnimation() {
         return mCursorAnimationJob.processAnimation() || mScrollAnimationJob.processAnimation();
     }
 
     /**
      * Start stepping animation when onCanvasRendered is triggered.
      */
     private void startAnimation() {
-        mViewer.onCanvasRendered().addSelfRemovable(mProcessAnimationCallback);
+        mRenderStub.onCanvasRendered().addSelfRemovable(mProcessAnimationCallback);
     }
 
     /**
      * Abort all animations.
      */
     private void abortAnimation() {
         mCursorAnimationJob.abortAnimation();
         mScrollAnimationJob.abortAnimation();
     }
 
-    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, injector);
-                    }
-                });
-
-        desktop.onSystemUiVisibilityChanged().add(
-                new Event.ParameterRunnable<SystemUiVisibilityChangedEventParameter>() {
-                    @Override
-                    public void run(SystemUiVisibilityChangedEventParameter parameter) {
-                        handleSystemUiVisibilityChanged(parameter);
-                    }
-                });
-    }
-
-    private void attachViewEvents(DesktopView 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, 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;
         }
@@ skipping 11 matching lines @@
                             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.
-        mViewer.cursorVisibilityChanged(mRenderData.drawCursor);
+        mRenderStub.setCursorVisibility(mRenderData.drawCursor);
     }
 
     private void handleSystemUiVisibilityChanged(
             SystemUiVisibilityChangedEventParameter parameter) {
         if (parameter.softInputMethodVisible) {
             mDesktopCanvas.setSystemUiOffsetValues(parameter.left, parameter.top,
                     mRenderData.screenWidth - parameter.right,
                     mRenderData.screenHeight - parameter.bottom);
         } else {
             mDesktopCanvas.setSystemUiOffsetValues(0, 0, 0, 0);
@@ skipping 100 matching lines @@
         moveCursor(imagePoint[0], imagePoint[1]);
     }
 
     /** Moves the cursor to the specified position on the remote host. */
     private void moveCursor(float newX, float newY) {
         boolean cursorMoved = mRenderData.setCursorPosition(newX, newY);
         if (cursorMoved) {
             mInputStrategy.injectCursorMoveEvent((int) newX, (int) newY);
         }
 
-        mViewer.cursorMoved(mRenderData.getCursorPosition());
+        mRenderStub.moveCursor(mRenderData.getCursorPosition());
     }
 
     /** Processes a (multi-finger) swipe gesture. */
     private boolean onSwipe() {
         if (mTotalMotionY > mSwipeThreshold) {
             // Swipe down occurred.
             mViewer.showActionBar();
         } else if (mTotalMotionY < -mSwipeThreshold) {
             // Swipe up occurred.
             mViewer.showKeyboard();
@@ skipping 158 matching lines @@
             if (!mInputStrategy.isIndirectInputMode()) {
                 if (screenPointLiesOutsideImageBoundary(x, y)) {
                     return false;
                 }
                 moveCursorToScreenPoint(x, y);
             }
 
             if (mInputStrategy.onTap(button)) {
                 PointF pos = mRenderData.getCursorPosition();
 
-                mViewer.showInputFeedback(mInputStrategy.getShortPressFeedbackType(), pos);
+                mRenderStub.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 == InputStub.BUTTON_UNDEFINED) {
                 return;
             }
 
             if (!mInputStrategy.isIndirectInputMode()) {
                 if (screenPointLiesOutsideImageBoundary(x, y)) {
                     return;
                 }
                 moveCursorToScreenPoint(x, y);
             }
 
             if (mInputStrategy.onPressAndHold(button)) {
                 PointF pos = mRenderData.getCursorPosition();
 
-                mViewer.showInputFeedback(mInputStrategy.getLongPressFeedbackType(), pos);
+                mRenderStub.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 InputStub.BUTTON_LEFT;
@@ skipping 11 matching lines @@
             float[] mappedPoints = mapScreenPointToImagePoint(screenX, screenY);
 
             float imageWidth = (float) mRenderData.imageWidth + EPSILON;
             float imageHeight = (float) mRenderData.imageHeight + EPSILON;
 
             return mappedPoints[0] < -EPSILON || mappedPoints[0] > imageWidth
                     || mappedPoints[1] < -EPSILON || mappedPoints[1] > imageHeight;
         }
     }
 }