Fixing a cursor position initialization problem

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 343 matching lines @@
         resizeImageToFitScreen();
     }
 
     private void resizeImageToFitScreen() {
         mDesktopCanvas.resizeImageToFitScreen();
         float screenCenterX;
         float screenCenterY;
         synchronized (mRenderData) {
             screenCenterX = (float) mRenderData.screenWidth / 2;
             screenCenterY = (float) mRenderData.screenHeight / 2;
+
+            float[] imagePoint = mapScreenPointToImagePoint(screenCenterX, screenCenterY);
+            mDesktopCanvas.setViewportPosition(imagePoint[0], imagePoint[1]);
         }
         moveCursorToScreenPoint(screenCenterX, screenCenterY);
+        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;
     }
 
@@ skipping 16 matching lines @@
         // keep the cursor centered, if possible, as the viewport moves.
         if (followCursor) {
             moveCursor((int) newPos.x, (int) newPos.y);
         }
 
         mDesktopCanvas.repositionImage(true);
     }
 
     /** Moves the cursor to the specified position on the screen. */
     private void moveCursorToScreenPoint(float screenX, float screenY) {
-        float[] mappedValues = {screenX, screenY};
-        synchronized (mRenderData) {
-            Matrix canvasToImage = new Matrix();
-            mRenderData.transform.invert(canvasToImage);
-            canvasToImage.mapPoints(mappedValues);
-        }
-        moveCursor((int) mappedValues[0], (int) mappedValues[1]);
+        float[] imagePoint = mapScreenPointToImagePoint(screenX, screenY);
+        moveCursor((int) imagePoint[0], (int) imagePoint[1]);
     }
 
     /** Moves the cursor to the specified position on the remote host. */
     private void moveCursor(int newX, int newY) {
         synchronized (mRenderData) {
             boolean cursorMoved = mRenderData.setCursorPosition(newX, newY);
             if (cursorMoved) {
                 mInputStrategy.injectCursorMoveEvent(newX, newY);
             }
         }
@@ skipping 11 matching lines @@
         } else {
             return false;
         }
 
         mSuppressCursorMovement = true;
         mSuppressFling = true;
         mSwipeCompleted = true;
         return true;
     }
 
+    /** Translates a point in screen coordinates to a location on the desktop image. */
+    private float[] mapScreenPointToImagePoint(float screenX, float screenY) {
+        float[] mappedPoints = {screenX, screenY};
+        Matrix screenToImage = new Matrix();
+        synchronized (mRenderData) {
+            mRenderData.transform.invert(screenToImage);
+        }
+        screenToImage.mapPoints(mappedPoints);
+
+        return mappedPoints;
+    }
+
     /** Responds to touch events filtered by the gesture detectors. */
     private class GestureListener extends GestureDetector.SimpleOnGestureListener
             implements ScaleGestureDetector.OnScaleGestureListener,
                        TapGestureDetector.OnTapListener {
         /**
          * Called when the user drags one or more fingers across the touchscreen.
          */
         @Override
         public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
             int pointerCount = e2.getPointerCount();
@@ skipping 113 matching lines @@
 
         /** Called when the user taps the screen with one or more fingers. */
         @Override
         public boolean onTap(int pointerCount, float x, float y) {
             int button = mouseButtonFromPointerCount(pointerCount);
             if (button == InputStub.BUTTON_UNDEFINED) {
                 return false;
             }
 
             if (!mInputStrategy.isIndirectInputMode()) {
-                if (!mapScreenPointToImage(x, y)) {
+                if (screenPointLiesOutsideImageBoundary(x, y)) {
                     return false;
                 }
                 moveCursorToScreenPoint(x, y);
             }
 
             if (mInputStrategy.onTap(button)) {
                 Point pos;
                 synchronized (mRenderData) {
                     pos = mRenderData.getCursorPosition();
                 }
                 mViewer.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 (!mapScreenPointToImage(x, y)) {
+                if (screenPointLiesOutsideImageBoundary(x, y)) {
                     return;
                 }
                 moveCursorToScreenPoint(x, y);
             }
 
             if (mInputStrategy.onPressAndHold(button)) {
                 Point pos;
                 synchronized (mRenderData) {
                     pos = mRenderData.getCursorPosition();
                 }
@@ skipping 10 matching lines @@
                     return InputStub.BUTTON_LEFT;
                 case 2:
                     return InputStub.BUTTON_RIGHT;
                 case 3:
                     return InputStub.BUTTON_MIDDLE;
                 default:
                     return InputStub.BUTTON_UNDEFINED;
             }
         }
 
-        /** Verifies the given point maps to a valid location within the desktop image. */
-        private boolean mapScreenPointToImage(float screenX, float screenY) {
-            float[] mappedPoints = {screenX, screenY};
+        /** Determines whether the given screen point lies outside the desktop image. */
+        private boolean screenPointLiesOutsideImageBoundary(float screenX, float screenY) {
+            float[] mappedPoints = mapScreenPointToImagePoint(screenX, screenY);
             int imageWidth;
             int imageHeight;
-            Matrix screenToImage = new Matrix();
             synchronized (mRenderData) {
-                mRenderData.transform.invert(screenToImage);
                 imageWidth = mRenderData.imageWidth;
                 imageHeight = mRenderData.imageHeight;
             }
-            screenToImage.mapPoints(mappedPoints);
 
-            return (mappedPoints[0] >= 0 && mappedPoints[0] <= imageWidth)
-                    && (mappedPoints[1] >= 0 && mappedPoints[1] <= imageHeight);
+            return (mappedPoints[0] < 0 && mappedPoints[0] > imageWidth)

[Lambros, 2016/07/14 21:11:08]

The '&&'s should be ||, and the parentheses are not needed.
Should be: x < 0 || x > width || y < 0 || y > height

Also, because of floating-point rounding errors, perhaps we should allow a
slight margin of error?
x < -epsilon || x > width + epsilon ...
where epsilon is some small number.
Guess it depends what this will be used for?

[joedow, 2016/07/14 21:47:36]

Oh geez, not sure why I didn't catch this in my testing.  Fixed now :)

I'm fine adding a small fudge factor to this as well.

+                    || (mappedPoints[1] < 0 && mappedPoints[1] > imageHeight);
         }
     }
 }