[Remoting Android] Use floating point coords for rendering the cursor

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

 // Copyright 2015 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.Point;
+import android.graphics.PointF;
 import android.os.SystemClock;
 import android.view.MotionEvent;
 import android.view.ViewConfiguration;
 
 /**
  * This class receives local touch events and translates them into the appropriate mouse based
  * events for the remote host.  The net result is that the local input method feels like a touch
  * interface but the remote host will be given mouse events to inject.
  */
 public class SimulatedTouchInputStrategy implements InputStrategyInterface {
     /** Used to adjust the size of the region used for double tap detection. */
     private static final float DOUBLE_TAP_SLOP_SCALE_FACTOR = 0.25f;
 
     private final RenderData mRenderData;
     private final InputEventSender mInjector;
 
     /**
      * Stores the time of the most recent left button single tap processed.
      */
     private long mLastTapTimeInMs = 0;
 
     /**
      * Stores the position of the last left button single tap processed.
      */
-    private Point mLastTapPoint;
+    private PointF mLastTapPoint;
 
     /**
      * The maximum distance, in pixels, between two points in order for them to be considered a
      * double tap gesture.
      */
     private final int mDoubleTapSlopSquareInPx;
 
     /**
      * The interval, measured in milliseconds, in which two consecutive left button taps must
      * occur in order to be considered a double tap gesture.
@@ skipping 33 matching lines @@
         scaledDoubleTapSlopInPx *= DOUBLE_TAP_SLOP_SCALE_FACTOR;
         mDoubleTapSlopSquareInPx = scaledDoubleTapSlopInPx * scaledDoubleTapSlopInPx;
 
         synchronized (mRenderData) {
             mRenderData.drawCursor = false;
         }
     }
 
     @Override
     public boolean onTap(int button) {
-        Point currentTapPoint = getCursorPosition();
+        PointF currentTapPoint = getCursorPosition();
         if (button == InputStub.BUTTON_LEFT) {
             // Left clicks are handled a little differently than the events for other buttons.
             // This is needed because translating touch events to mouse events has a problem with
             // location consistency for double clicks.  If you take the center location of each tap
             // and inject them as mouse clicks, the distance between those two points will often
             // cause the remote OS to recognize the gesture as two distinct clicks instead of a
             // double click.  In order to increase the success rate of double taps/clicks, we
             // squirrel away the time and coordinates of each single tap and if we detect the user
             // attempting a double tap, we use the original event's location for that second tap.
             long tapInterval = SystemClock.uptimeMillis() - mLastTapTimeInMs;
             if (isDoubleTap(currentTapPoint.x, currentTapPoint.y, tapInterval)) {
-                currentTapPoint = new Point(mLastTapPoint);
+                currentTapPoint = new PointF(mLastTapPoint.x, mLastTapPoint.y);
                 mLastTapPoint = null;
                 mLastTapTimeInMs = 0;
             } else {
                 mLastTapPoint = currentTapPoint;
                 mLastTapTimeInMs = SystemClock.uptimeMillis();
             }
         } else {
             mLastTapPoint = null;
             mLastTapTimeInMs = 0;
         }
@@ skipping 36 matching lines @@
     @Override
     public AbstractDesktopView.InputFeedbackType getLongPressFeedbackType() {
         return AbstractDesktopView.InputFeedbackType.LARGE_ANIMATION;
     }
 
     @Override
     public boolean isIndirectInputMode() {
         return false;
     }
 
-    private Point getCursorPosition() {
+    private PointF getCursorPosition() {
         synchronized (mRenderData) {
             return mRenderData.getCursorPosition();
         }
     }
 
-    private boolean isDoubleTap(int currentX, int currentY, long tapInterval) {
+    private boolean isDoubleTap(float currentX, float currentY, long tapInterval) {
         if (tapInterval > mDoubleTapDurationInMs || mLastTapPoint == null) {
             return false;
         }
 
         // Convert the image based coordinates back to screen coordinates so the user experiences
         // consistent double tap behavior regardless of zoom level.
         //
         float[] currentValues = {currentX, currentY};
         float[] previousValues = {mLastTapPoint.x, mLastTapPoint.y};
         synchronized (mRenderData) {
             mRenderData.transform.mapPoints(currentValues);
             mRenderData.transform.mapPoints(previousValues);
         }
 
         int deltaX = (int) (currentValues[0] - previousValues[0]);
         int deltaY = (int) (currentValues[1] - previousValues[1]);
         return ((deltaX * deltaX + deltaY * deltaY) <= mDoubleTapSlopSquareInPx);
     }
 }