Fixing image canvas resize problems when showing/hiding system UI.

remoting/android/java/src/org/chromium/chromoting/TrackingInputHandler.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.PointF;
+import android.graphics.Rect;
+import android.graphics.RectF;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.ScaleGestureDetector;
 import android.widget.Scroller;
 
 /**
  * This class implements the cursor-tracking behavior and gestures.
  */
 public class TrackingInputHandler implements TouchInputHandler {
     /**
@@ skipping 52 matching lines @@
      * dragging whilst a button is held down.
      */
     private boolean mSuppressFling = false;
 
     /**
      * Set to true when 3-finger swipe gesture is complete, so that further movement doesn't
      * trigger more swipe actions.
      */
     private boolean mSwipeCompleted = false;
 
-    public TrackingInputHandler(DesktopViewInterface viewer, Context context,
-                                RenderData renderData) {
+    /**
+     * Represents the amount of vertical space in pixels used by the soft input device and
+     * accompanying 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;
+
+    public TrackingInputHandler(
+            DesktopViewInterface viewer, Context context, RenderData renderData) {
         mViewer = viewer;
         mRenderData = renderData;
 
         GestureListener listener = new GestureListener();
         mScroller = new GestureDetector(context, listener, null, false);
 
         // If long-press is enabled, the gesture-detector will not emit any further onScroll
         // notifications after the onLongPress notification. Since onScroll is being used for
         // moving the cursor, it means that the cursor would become stuck if the finger were held
         // down too long.
@@ skipping 29 matching lines @@
 
         mViewer.injectMouseEvent((int) newX, (int) newY, BUTTON_UNDEFINED, false);
     }
 
     /**
      * Repositions the image by translating it (without affecting the zoom level) to place the
      * cursor close to the center of the screen.
      */
     private void repositionImage() {
         synchronized (mRenderData) {
+            float adjustedScreenWidth = mRenderData.screenWidth - mInputMethodOffsetX;
+            float adjustedScreenHeight = mRenderData.screenHeight - mInputMethodOffsetY;
+
             // Get the current cursor position in screen coordinates.
             float[] cursorScreen = {mCursorPosition.x, mCursorPosition.y};
             mRenderData.transform.mapPoints(cursorScreen);
 
             // Translate so the cursor is displayed in the middle of the screen.
-            mRenderData.transform.postTranslate(
-                    (float) mRenderData.screenWidth / 2 - cursorScreen[0],
-                    (float) mRenderData.screenHeight / 2 - cursorScreen[1]);
+            mRenderData.transform.postTranslate((float) adjustedScreenWidth / 2 - cursorScreen[0],
+                    (float) adjustedScreenHeight / 2 - cursorScreen[1]);
 
             // Now the cursor is displayed in the middle of the screen, see if the image can be
             // panned so that more of it is visible. The primary goal is to show as much of the
             // image as possible. The secondary goal is to keep the cursor in the middle.
 
             // Get the coordinates of the desktop rectangle (top-left/bottom-right corners) in
             // screen coordinates. Order is: left, top, right, bottom.
-            float[] rectScreen = {0, 0, mRenderData.imageWidth, mRenderData.imageHeight};
-            mRenderData.transform.mapPoints(rectScreen);
+            RectF rectScreen = new RectF(0, 0, mRenderData.imageWidth, mRenderData.imageHeight);
+            mRenderData.transform.mapRect(rectScreen);
 
-            float leftDelta = rectScreen[0];
-            float rightDelta = rectScreen[2] - mRenderData.screenWidth;
-            float topDelta = rectScreen[1];
-            float bottomDelta = rectScreen[3] - mRenderData.screenHeight;
+            float leftDelta = rectScreen.left;
+            float rightDelta = rectScreen.right - mRenderData.screenWidth + mInputMethodOffsetX;
+            float topDelta = rectScreen.top;
+            float bottomDelta = rectScreen.bottom - mRenderData.screenHeight + mInputMethodOffsetY;
             float xAdjust = 0;
             float yAdjust = 0;
 
-            if (rectScreen[2] - rectScreen[0] < mRenderData.screenWidth) {
+            if (rectScreen.right - rectScreen.left < adjustedScreenWidth) {
                 // Image is narrower than the screen, so center it.
                 xAdjust = -(rightDelta + leftDelta) / 2;
             } else if (leftDelta > 0 && rightDelta > 0) {
                 // Panning the image left will show more of it.
                 xAdjust = -Math.min(leftDelta, rightDelta);
             } else if (leftDelta < 0 && rightDelta < 0) {
                 // Pan the image right.
                 xAdjust = Math.min(-leftDelta, -rightDelta);
             }
 
             // Apply similar logic for yAdjust.
-            if (rectScreen[3] - rectScreen[1] < mRenderData.screenHeight) {
+            if (rectScreen.bottom - rectScreen.top < adjustedScreenHeight) {
                 yAdjust = -(bottomDelta + topDelta) / 2;
             } else if (topDelta > 0 && bottomDelta > 0) {
                 yAdjust = -Math.min(topDelta, bottomDelta);
             } else if (topDelta < 0 && bottomDelta < 0) {
                 yAdjust = Math.min(-topDelta, -bottomDelta);
             }
 
             mRenderData.transform.postTranslate(xAdjust, yAdjust);
         }
         mViewer.transformationChanged();
@@ skipping 19 matching lines @@
             }
 
             // Get image size scaled to screen coordinates.
             float[] imageSize = {mRenderData.imageWidth, mRenderData.imageHeight};
             mRenderData.transform.mapVectors(imageSize);
 
             if (imageSize[0] < mRenderData.screenWidth && imageSize[1] < mRenderData.screenHeight) {
                 // Displayed image is too small in both directions, so apply the minimum zoom
                 // level needed to fit either the width or height.
                 float scale = Math.min((float) mRenderData.screenWidth / mRenderData.imageWidth,
-                                       (float) mRenderData.screenHeight / mRenderData.imageHeight);
+                        (float) mRenderData.screenHeight / mRenderData.imageHeight);
                 mRenderData.transform.setScale(scale, scale);
             }
 
             repositionImage();
         }
     }
 
     /** Injects a button event using the current cursor location. */
     private void injectButtonEvent(int button, boolean pressed) {
         mViewer.injectMouseEvent((int) mCursorPosition.x, (int) mCursorPosition.y, button, pressed);
@@ skipping 61 matching lines @@
         repositionImageWithZoom();
     }
 
     @Override
     public void onHostSizeChanged(int width, int height) {
         moveCursor((float) width / 2, (float) height / 2);
         repositionImageWithZoom();
     }
 
     @Override
+    public void onSoftInputMethodVisibilityChanged(boolean inputMethodVisible, Rect bounds) {
+        if (inputMethodVisible) {
+            mInputMethodOffsetY = mRenderData.screenHeight - bounds.bottom;
+            mInputMethodOffsetX = mRenderData.screenWidth - bounds.right;
+        } else {
+            mInputMethodOffsetY = 0;
+            mInputMethodOffsetX = 0;
+        }
+
+        repositionImageWithZoom();
+    }
+
+    @Override
     public void processAnimation() {
         int previousX = mFlingScroller.getCurrX();
         int previousY = mFlingScroller.getCurrY();
         if (!mFlingScroller.computeScrollOffset()) {
             mViewer.setAnimationEnabled(false);
             return;
         }
         int deltaX = mFlingScroller.getCurrX() - previousX;
         int deltaY = mFlingScroller.getCurrY() - previousY;
         float[] delta = {deltaX, deltaY};
@@ skipping 149 matching lines @@
         public void onLongPress(int pointerCount) {
             mHeldButton = mouseButtonFromPointerCount(pointerCount);
             if (mHeldButton != BUTTON_UNDEFINED) {
                 injectButtonEvent(mHeldButton, true);
                 mViewer.showLongPressFeedback();
                 mSuppressFling = true;
             }
         }
     }
 }