Updating SystemUI visibility events in Adroid Client.

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

Index: remoting/android/java/src/org/chromium/chromoting/DesktopCanvas.java
diff --git a/remoting/android/java/src/org/chromium/chromoting/DesktopCanvas.java b/remoting/android/java/src/org/chromium/chromoting/DesktopCanvas.java
index 874697800986af858b459db23e285607a52b3cd1..bfc01a92b45989807b176f32a6c73fc23cc0ba2e 100644
--- a/remoting/android/java/src/org/chromium/chromoting/DesktopCanvas.java
+++ b/remoting/android/java/src/org/chromium/chromoting/DesktopCanvas.java
@@ -4,7 +4,9 @@
 
 package org.chromium.chromoting;
 
+import android.graphics.Matrix;
 import android.graphics.PointF;
+import android.graphics.Rect;
 import android.graphics.RectF;
 
 /**
@@ -28,16 +30,9 @@ public class DesktopCanvas {
     private PointF mViewportPosition = new PointF();
 
     /**
-     * Represents the amount of vertical space in pixels used by the soft input device and
-     * accompanying system UI.
+     * Represents the amount of space, in pixels, used by system UI.
      */
-    private int mInputMethodOffsetY = 0;
-
-    /**
-     * Represents the amount of horizontal space in pixels used by the soft input device and
-     * accompanying system UI.
-     */
-    private int mInputMethodOffsetX = 0;
+    private Rect mSystemUiOffsetPx = new Rect();

[Lambros, 2016/06/29 20:43:37]

Pixels instead of Px?

Is Rect the right choice here? These 4 offset values don't form a rectangle in
the usual way. Perhaps Rect might do something weird, like swap left/right to
keep width positive?

[joedow, 2016/06/30 16:03:26]

Updated the name.  Rect/RectF doesn't require the values to form a rectangle,
however some of its methods do (i.e. width() or height()).  As long as the data
is treated like a struct with nicely named accessors then it should be fine.

I can also add a private class which has the LTRB getters if you'd prefer.

 
     public DesktopCanvas(DesktopViewInterface viewer, RenderData renderData) {
         mViewer = viewer;
@@ -45,50 +40,89 @@ public class DesktopCanvas {
     }
 
     /**
-     * Returns the desired center position of the viewport.  Note that this may not represent the
-     * true center of the viewport as other calculations are done to maximize the viewable area.
+     * Shifts the viewport by the passed in deltas (in image coordinates).
      *
-     * @return A point representing the desired position of the viewport.
+     * @param useScreenCenter Determines whether to use the desired viewport position or the actual
+     *                        center of the screen for positioning.
+     * @param deltaX The distance (in image coordinates) to move the viewport along the x-axis.
+     * @param deltaY The distance (in image coordinates) to move the viewport along the y-axis.
+     * @return A point representing the desired center position of the viewport.
      */
-    public PointF getViewportPosition() {
-        return new PointF(mViewportPosition.x, mViewportPosition.y);
+    public PointF moveViewportCenter(boolean useScreenCenter, float deltaX, float deltaY) {
+        PointF viewportCenter;
+        synchronized (mRenderData) {
+            RectF bounds = new RectF(0, 0, mRenderData.imageWidth, mRenderData.imageHeight);
+            if (useScreenCenter) {
+                viewportCenter = getTrueViewportCenter();
+            } else {
+                viewportCenter = new PointF(mViewportPosition.x, mViewportPosition.y);
+            }
+
+            viewportCenter.set(viewportCenter.x + deltaX, viewportCenter.y + deltaY);

[Lambros, 2016/06/29 20:43:37]

viewportCenter.offset(deltaX, deltaY);

[joedow, 2016/06/30 16:03:26]

Good call.

+            if (viewportCenter.x < bounds.left) {
+                viewportCenter.x = bounds.left;
+            } else if (viewportCenter.x > bounds.right) {
+                viewportCenter.x = bounds.right;
+            }
+
+            if (viewportCenter.y < bounds.top) {
+                viewportCenter.y = bounds.top;
+            } else if (viewportCenter.y > bounds.bottom) {
+                viewportCenter.y = bounds.bottom;
+            }
+
+            mViewportPosition.set(viewportCenter);
+        }
+
+        return viewportCenter;
     }
 
     /**
-     * Sets the desired center position of the viewport.
+     * Returns the current size of the viewport.  This size includes the offset calculations for
+     * any visible system UI.
      *
-     * @param newX The new x coordinate value for the desired center position.
-     * @param newY The new y coordinate value for the desired center position.
+     * @return A point representing the current size of the viewport.
      */
-    public void setViewportPosition(float newX, float newY) {
-        mViewportPosition.set(newX, newY);
+    private PointF getViewportSize() {
+        float adjustedScreenWidth, adjustedScreenHeight;
+        synchronized (mRenderData) {
+            adjustedScreenWidth = mRenderData.screenWidth - mSystemUiOffsetPx.right;

[Lambros, 2016/06/29 20:43:36]

Need to subtract left as well as right?

[joedow, 2016/06/30 16:03:26]

Not for this CL.  I am not changing previous behavior yet, I just wanted to get
the plumbing done to reduce the size of the next CL where I will be changing
user-facing behavior.

+            adjustedScreenHeight = mRenderData.screenHeight - mSystemUiOffsetPx.bottom;

[Lambros, 2016/06/29 20:43:37]

top as well as bottom?

[joedow, 2016/06/30 16:03:26]

Next CL as needed.

+        }
+
+        return new PointF(adjustedScreenWidth, adjustedScreenHeight);
     }
 
     /**
-     * Sets the offset values used to calculate the space used by the current soft input method.
+     * Returns the true center position of the viewport (in image coordinates).
      *
-     * @param offsetX The space used by the soft input method UI on the right edge of the screen.
-     * @param offsetY The space used by the soft input method UI on the bottom edge of the screen.
+     * @return A point representing the true center position of the viewport.
      */
-    public void setInputMethodOffsetValues(int offsetX, int offsetY) {
-        mInputMethodOffsetX = offsetX;
-        mInputMethodOffsetY = offsetY;
+    private PointF getTrueViewportCenter() {
+        synchronized (mRenderData) {
+            PointF viewportSize = getViewportSize();
+            // Find the center point of the viewport on the screen.

[Lambros, 2016/06/29 20:43:36]

Please add blank line above comment.

[joedow, 2016/06/30 16:03:26]

Done.

+            float[] viewportPosition = {((float) viewportSize.x / 2), ((float) viewportSize.y / 2)};
+            // Convert the screen position to an image position.

[Lambros, 2016/06/29 20:43:37]

and here.

[joedow, 2016/06/30 16:03:26]

Done.

+            Matrix screenToImage = new Matrix();
+            mRenderData.transform.invert(screenToImage);
+            screenToImage.mapPoints(viewportPosition);
+            return new PointF(viewportPosition[0], viewportPosition[1]);
+        }
     }
 
     /**
-     * Returns the current size of the viewport.  This size includes the offset calculations for
-     * any visible Input Method UI.
+     * Sets the offset values used to calculate the space used by system UI.
      *
-     * @return A point representing the current size of the viewport.
+     * @param left The space used by system UI on the left edge of the screen.
+     * @param top The space used by system UI on the top edge of the screen.
+     * @param right The space used by system UI on the right edge of the screen.
+     * @param bottom The space used by system UI on the bottom edge of the screen.
      */
-    public PointF getViewportSize() {
-        float adjustedScreenWidth, adjustedScreenHeight;
+    public void setSystemUiOffsetValues(int left, int top, int right, int bottom) {
         synchronized (mRenderData) {
-            adjustedScreenWidth = mRenderData.screenWidth - mInputMethodOffsetX;
-            adjustedScreenHeight = mRenderData.screenHeight - mInputMethodOffsetY;
+            mSystemUiOffsetPx.set(left, top, right, bottom);
         }
-
-        return new PointF(adjustedScreenWidth, adjustedScreenHeight);
     }
 
     /** Repositions the image by zooming it such that the image is displayed without borders. */
@@ -120,7 +154,7 @@ public class DesktopCanvas {
      *                       center position before being adjusted to fit the screen boundaries.
      */
     public void repositionImage(boolean centerViewport) {
-        PointF adjustedViewportSize = getViewportSize();
+        PointF viewportSize = getViewportSize();
         synchronized (mRenderData) {
             // The goal of the code below is to position the viewport as close to the desired center
             // position as possible whilst keeping as much of the desktop in view as possible.
@@ -133,8 +167,8 @@ public class DesktopCanvas {
 
                 // Translate so the viewport is displayed in the middle of the screen.
                 mRenderData.transform.postTranslate(
-                        (float) adjustedViewportSize.x / 2 - viewportPosition[0],
-                        (float) adjustedViewportSize.y / 2 - viewportPosition[1]);
+                        ((float) viewportSize.x / 2) - viewportPosition[0],
+                        ((float) viewportSize.y / 2) - viewportPosition[1]);
             }
 
             // Get the coordinates of the desktop rectangle (top-left/bottom-right corners) in
@@ -143,13 +177,14 @@ public class DesktopCanvas {
             mRenderData.transform.mapRect(rectScreen);
 
             float leftDelta = rectScreen.left;
-            float rightDelta = rectScreen.right - mRenderData.screenWidth + mInputMethodOffsetX;
+            float rightDelta = rectScreen.right - mRenderData.screenWidth + mSystemUiOffsetPx.right;

[Lambros, 2016/06/29 20:43:37]

Same here? It looks like you never use mSystemUiOffsetPx.{left or top} anywhere.

[joedow, 2016/06/30 16:03:26]

Not yet, they are needed in the next CL.

             float topDelta = rectScreen.top;
-            float bottomDelta = rectScreen.bottom - mRenderData.screenHeight + mInputMethodOffsetY;
+            float bottomDelta =
+                    rectScreen.bottom - mRenderData.screenHeight + mSystemUiOffsetPx.bottom;
             float xAdjust = 0;
             float yAdjust = 0;
 
-            if (rectScreen.right - rectScreen.left < adjustedViewportSize.x) {
+            if (rectScreen.right - rectScreen.left < viewportSize.x) {
                 // Image is narrower than the screen, so center it.
                 xAdjust = -(rightDelta + leftDelta) / 2;
             } else if (leftDelta > 0 && rightDelta > 0) {
@@ -161,7 +196,7 @@ public class DesktopCanvas {
             }
 
             // Apply similar logic for yAdjust.
-            if (rectScreen.bottom - rectScreen.top < adjustedViewportSize.y) {
+            if (rectScreen.bottom - rectScreen.top < viewportSize.y) {
                 yAdjust = -(bottomDelta + topDelta) / 2;
             } else if (topDelta > 0 && bottomDelta > 0) {
                 yAdjust = -Math.min(topDelta, bottomDelta);