[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.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.ScaleGestureDetector;
 import android.view.ViewConfiguration;
 
 /**
  * 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 DesktopView mViewer;
     private final Context mContext;
     private final RenderData mRenderData;
-    private final DesktopCanvas mDesktopCanvas;
+    private DesktopCanvas mDesktopCanvas;

[Hzj_jie, 2016/09/08 21:37:33]

Once init function has been removed, these fields can be final.

[Yuwei, 2016/09/08 23:09:15]

Done. Made everything final-able final.

     private InputStrategyInterface mInputStrategy;
+    private RenderStub mRenderStub;
 
     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;
 
     // Used for processing cursor & scroller fling animations.
     // May consider using a List of AnimationJob if we have more than two animation jobs in
@@ skipping 47 matching lines @@
      * trigger more swipe actions.
      */
     private boolean mSwipeCompleted = false;
 
     /**
      * Set to true when a 1 finger pan gesture originates with a longpress.  This means the user
      * is performing a drag operation.
      */
     private boolean mIsDragging = false;
 
+    private boolean mValid = false;
+
     private Event.ParameterCallback<Boolean, Void> mProcessAnimationCallback;
 
     /**
      * This class implements fling animation for cursor
      */
     private class CursorAnimationJob extends FlingAnimationJob {
         public CursorAnimationJob(Context context) {
             super(context);
         }
 
@@ skipping 71 matching lines @@
         @Override
         public boolean isIndirectInputMode() {
             return false;
         }
     }
 
     public TouchInputHandler(DesktopView viewer, Context context) {
         mViewer = viewer;
         mContext = context;
         mRenderData = new 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.
         mScroller.setIsLongpressEnabled(false);
 
@@ skipping 13 matching lines @@
 
         mCursorAnimationJob = new CursorAnimationJob(context);
         mScrollAnimationJob = new ScrollAnimationJob(context);
 
         mProcessAnimationCallback = new Event.ParameterCallback<Boolean, Void>() {
             @Override
             public Boolean run(Void p) {
                 return processAnimation();
             }
         };
-
-        attachViewEvents(viewer);
     }
 
     /**
      * 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) {
+    public void init(Desktop desktop, RenderStub renderStub, final InputEventSender injector) {
         Preconditions.notNull(injector);
-        desktop.onInputModeChanged().add(
-                new Event.ParameterRunnable<InputModeChangedEventParameter>() {
+        Preconditions.notNull(renderStub);
+        mRenderStub = renderStub;
+        mDesktopCanvas = new DesktopCanvas(renderStub, mRenderData);
+
+        mValid = true;

[joedow, 2016/09/08 18:32:47]

Can't you just detach the event handlers / remove queued events when you want to
stop processing?  I think that would be cleaner than relying on a flag here.

[Yuwei, 2016/09/08 19:12:16]

The reason was that I didn't want to have a lot of private Objects for removing
events. I think I can avoid this by using a HashMap.

[Hzj_jie, 2016/09/08 21:37:33]

Emmm ... Seems you are writing more codes by using addSelfRemovable here.

[Yuwei, 2016/09/08 23:09:15]

s/HashMap/list of listener-event pairs/

[Yuwei, 2016/09/08 23:09:15]

Simplified.

+
+        mViewer.onTouch().addSelfRemovable(
+                new Event.ParameterCallback<Boolean, TouchEventParameter>() {
                     @Override
-                    public void run(InputModeChangedEventParameter parameter) {
-                        handleInputModeChanged(parameter, injector);
+                    public Boolean run(TouchEventParameter parameter) {
+                        if (!mValid) {
+                            return false;
+                        }
+                        parameter.handled = handleTouchEvent(parameter.event);
+                        return true;
                     }
                 });
 
-        desktop.onSystemUiVisibilityChanged().add(
-                new Event.ParameterRunnable<SystemUiVisibilityChangedEventParameter>() {
+        desktop.onInputModeChanged().addSelfRemovable(
+                new Event.ParameterCallback<Boolean, InputModeChangedEventParameter>() {
                     @Override
-                    public void run(SystemUiVisibilityChangedEventParameter parameter) {
+                    public Boolean run(InputModeChangedEventParameter parameter) {
+                        if (!mValid) {
+                            return false;
+                        }
+                        handleInputModeChanged(parameter, injector);
+                        return true;
+                    }
+                });
+
+        desktop.onSystemUiVisibilityChanged().addSelfRemovable(
+                new Event.ParameterCallback<Boolean, SystemUiVisibilityChangedEventParameter>() {
+                    @Override
+                    public Boolean run(SystemUiVisibilityChangedEventParameter parameter) {
+                        if (!mValid) {
+                            return false;
+                        }
                         handleSystemUiVisibilityChanged(parameter);
+                        return true;
+                    }
+                });
+
+        renderStub.onClientSizeChanged().addSelfRemovable(
+                new Event.ParameterCallback<Boolean, SizeChangedEventParameter>() {
+                    @Override
+                    public Boolean run(SizeChangedEventParameter parameter) {
+                        if (!mValid) {
+                            return false;
+                        }
+                        handleClientSizeChanged(parameter.width, parameter.height);
+                        return true;
+                    }
+                });
+
+        renderStub.onHostSizeChanged().addSelfRemovable(
+                new Event.ParameterCallback<Boolean, SizeChangedEventParameter>() {
+                    @Override
+                    public Boolean run(SizeChangedEventParameter parameter) {
+                        if (!mValid) {
+                            return false;
+                        }
+                        handleHostSizeChanged(parameter.width, parameter.height);
+                        return true;
                     }
                 });
     }
 
-    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);
-            }
-        });
+    public void invalidate() {
+        mValid = false;
     }
 
     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()) {
@@ skipping 13 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;
         }
     }
 }