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;
 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 AbstractDesktopView 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;
 
@@ skipping 321 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};
-            int imageWidth;
-            int imageHeight;
-            Matrix screenToImage = new Matrix();
+        /** Determines whether the given screen point lies outside the desktop image. */
+        private boolean screenPointLiesOutsideImageBoundary(float screenX, float screenY) {
+            float[] mappedPoints = mapScreenPointToImagePoint(screenX, screenY);
+            float imageWidth;
+            float imageHeight;
             synchronized (mRenderData) {
-                mRenderData.transform.invert(screenToImage);
-                imageWidth = mRenderData.imageWidth;
-                imageHeight = mRenderData.imageHeight;
+                imageWidth = (float) mRenderData.imageWidth + EPSILON;
+                imageHeight = (float) mRenderData.imageHeight + EPSILON;
             }
-            screenToImage.mapPoints(mappedPoints);
 
-            return (mappedPoints[0] >= 0 && mappedPoints[0] <= imageWidth)
-                    && (mappedPoints[1] >= 0 && mappedPoints[1] <= imageHeight);
+            return mappedPoints[0] < -EPSILON || mappedPoints[0] > imageWidth
+                    || mappedPoints[1] < -EPSILON || mappedPoints[1] > imageHeight;
         }
     }
 }