[Remoting Android] Refactor GlDesktopView

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

Index: remoting/android/java/src/org/chromium/chromoting/TouchInputHandler.java
diff --git a/remoting/android/java/src/org/chromium/chromoting/TouchInputHandler.java b/remoting/android/java/src/org/chromium/chromoting/TouchInputHandler.java
index 8800e568d2c5106b270b0853a6e85bc35dd8a48e..c1866fcf15fa7265f7ab90b57b277b596423c8a0 100644
--- a/remoting/android/java/src/org/chromium/chromoting/TouchInputHandler.java
+++ b/remoting/android/java/src/org/chromium/chromoting/TouchInputHandler.java
@@ -24,8 +24,9 @@ public class TouchInputHandler {
     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;
@@ -93,6 +94,8 @@ public class TouchInputHandler {
      */
     private boolean mIsDragging = false;
 
+    private boolean mValid = false;
+
     private Event.ParameterCallback<Boolean, Void> mProcessAnimationCallback;
 
     /**
@@ -184,7 +187,6 @@ public class TouchInputHandler {
         mViewer = viewer;
         mContext = context;
         mRenderData = new RenderData();
-        mDesktopCanvas = new DesktopCanvas(mViewer, mRenderData);
 
         GestureListener listener = new GestureListener();
         mScroller = new GestureDetector(context, listener, null, false);
@@ -218,8 +220,6 @@ public class TouchInputHandler {
                 return processAnimation();
             }
         };
-
-        attachViewEvents(viewer);
     }
 
     /**
@@ -234,7 +234,7 @@ public class TouchInputHandler {
      * Start stepping animation when onCanvasRendered is triggered.
      */
     private void startAnimation() {
-        mViewer.onCanvasRendered().addSelfRemovable(mProcessAnimationCallback);
+        mRenderStub.onCanvasRendered().addSelfRemovable(mProcessAnimationCallback);
     }
 
     /**
@@ -245,44 +245,77 @@ public class TouchInputHandler {
         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) {
+                    public Boolean run(TouchEventParameter parameter) {
+                        if (!mValid) {
+                            return false;
+                        }
+                        parameter.handled = handleTouchEvent(parameter.event);
+                        return true;
+                    }
+                });
+
+        desktop.onInputModeChanged().addSelfRemovable(
+                new Event.ParameterCallback<Boolean, InputModeChangedEventParameter>() {
+                    @Override
+                    public Boolean run(InputModeChangedEventParameter parameter) {
+                        if (!mValid) {
+                            return false;
+                        }
                         handleInputModeChanged(parameter, injector);
+                        return true;
                     }
                 });
 
-        desktop.onSystemUiVisibilityChanged().add(
-                new Event.ParameterRunnable<SystemUiVisibilityChangedEventParameter>() {
+        desktop.onSystemUiVisibilityChanged().addSelfRemovable(
+                new Event.ParameterCallback<Boolean, SystemUiVisibilityChangedEventParameter>() {
                     @Override
-                    public void run(SystemUiVisibilityChangedEventParameter parameter) {
+                    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(
@@ -316,7 +349,7 @@ public class TouchInputHandler {
         }
 
         // Ensure the cursor state is updated appropriately.
-        mViewer.cursorVisibilityChanged(mRenderData.drawCursor);
+        mRenderStub.setCursorVisibility(mRenderData.drawCursor);
     }
 
     private void handleSystemUiVisibilityChanged(
@@ -437,7 +470,7 @@ public class TouchInputHandler {
             mInputStrategy.injectCursorMoveEvent((int) newX, (int) newY);
         }
 
-        mViewer.cursorMoved(mRenderData.getCursorPosition());
+        mRenderStub.moveCursor(mRenderData.getCursorPosition());
     }
 
     /** Processes a (multi-finger) swipe gesture. */
@@ -616,7 +649,7 @@ public class TouchInputHandler {
             if (mInputStrategy.onTap(button)) {
                 PointF pos = mRenderData.getCursorPosition();
 
-                mViewer.showInputFeedback(mInputStrategy.getShortPressFeedbackType(), pos);
+                mRenderStub.showInputFeedback(mInputStrategy.getShortPressFeedbackType(), pos);
             }
             return true;
         }
@@ -639,7 +672,7 @@ public class TouchInputHandler {
             if (mInputStrategy.onPressAndHold(button)) {
                 PointF pos = mRenderData.getCursorPosition();
 
-                mViewer.showInputFeedback(mInputStrategy.getLongPressFeedbackType(), pos);
+                mRenderStub.showInputFeedback(mInputStrategy.getLongPressFeedbackType(), pos);
                 mSuppressFling = true;
                 mIsDragging = true;
             }