Adjust viewport center when in trackpad input mode.

remoting/android/java/src/org/chromium/chromoting/DesktopCanvas.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.graphics.Matrix;
 import android.graphics.PointF;
 import android.graphics.Rect;
 import android.graphics.RectF;
@@ skipping 40 matching lines @@
     // TODO(joedow): Update usage of this member so it is a true Rect instead of a set of offsets.
     private Rect mSystemUiScreenSize = new Rect();
 
     /**
      * Represents the amount of padding, in screen pixels, added to each edge of the desktop image.
      * This extra space allows the user to reveal portions of the desktop image which are obscured
      * by System UI.
      */
     private RectF mVisibleImagePadding = new RectF();
 
+    /**
+     * Tracks whether to adjust the viewport to account for System UI. If false, the viewport
+     * center is the center of the screen.  If true, then System UI offsets will be used to
+     * adjust the position of the viewport to ensure the cursor is visible.
+     */
+    private boolean mAdjustViewportForSystemUi = false;
+
+    /**
+    * Represents the amount of space, in pixels, to adjust the cursor center along the y-axis.
+    */
+    private float mCursorOffsetScreenY = 0.0f;
+
     public DesktopCanvas(RenderStub renderStub, RenderData renderData) {
         mRenderStub = renderStub;
         mRenderData = renderData;
     }
 
     /**
      * Sets the desired center position of the viewport (a.k.a. the cursor position) and ensures
      * the viewport is updated to include the cursor within it.
      *
      * @param newX The new x coordinate value for the desired center position.
@@ skipping 44 matching lines @@
     /**
      * Sets the offset values used to calculate the space used by System UI.
      *
      * @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 void setSystemUiOffsetValues(int left, int top, int right, int bottom) {
         mSystemUiScreenSize.set(left, top, right, bottom);
+
+        if (mAdjustViewportForSystemUi) {
+            // Adjust the cursor position to ensure it's visible when large System UI (defined as
+            // 1/3 or more of the total screen size) is displayed.  This is typically the Soft
+            // Keyboard. Without this change, it is difficult for users to enter text into edit
+            // controls which are located bottom of the screen and may not be able to view their
+            // cursor at all.
+            if (bottom > (mRenderData.screenHeight / 3)) {
+                // Center the cursor within the viewable area (not obscured by System UI).
+                mCursorOffsetScreenY = (((float) mRenderData.screenHeight - bottom) / 2.0f);
+            } else {
+                mCursorOffsetScreenY = 0.0f;
+            }
+
+            // Apply the cursor offset.
+            setCursorPosition(mCursorPosition.x, mCursorPosition.y);
+        }
     }
 
     /** Called to indicate that no System UI is visible. */
     public void clearSystemUiOffsets() {
+        mCursorOffsetScreenY = 0.0f;
         mSystemUiScreenSize.setEmpty();
     }
 
+    public void adjustViewportForSystemUi(boolean adjustViewportForSystemUi) {
+        mAdjustViewportForSystemUi = adjustViewportForSystemUi;
+    }
+
     /** Resizes the image by zooming it such that the image is displayed without borders. */
     public void resizeImageToFitScreen() {
         // Protect against being called before the image has been initialized.
         if (mRenderData.imageWidth == 0 || mRenderData.imageHeight == 0) {
             return;
         }
 
         float widthRatio = (float) mRenderData.screenWidth / mRenderData.imageWidth;
         float heightRatio = (float) mRenderData.screenHeight / mRenderData.imageHeight;
         float screenToImageScale = Math.max(widthRatio, heightRatio);
@@ skipping 71 matching lines @@
 
     /**
      * Repositions the image by translating it (without affecting the zoom level).
      */
     private void repositionImage() {
         // Map the current viewport position to screen coordinates and adjust the image position.
         float[] viewportPosition = {mViewportPosition.x, mViewportPosition.y};
         mRenderData.transform.mapPoints(viewportPosition);
 
         float viewportTransX = ((float) mRenderData.screenWidth / 2) - viewportPosition[0];
-        float viewportTransY = ((float) mRenderData.screenHeight / 2) - viewportPosition[1];
+        float viewportTransY =
+                ((float) mRenderData.screenHeight / 2) - viewportPosition[1] - mCursorOffsetScreenY;
 
-        // Translate the image so the viewport center is displayed in the middle of the screen.
+        // Translate the image to move the viewport to the expected screen location.
         mRenderData.transform.postTranslate(viewportTransX, viewportTransY);
 
         updateVisibleImagePadding();
 
         mRenderStub.setTransformation(mRenderData.transform);
     }
 
     /**
      * Updates the given point such that it refers to a coordinate within the bounds provided.
      *
@@ skipping 20 matching lines @@
         // Padding is additional space added to the image which is the larger value of:
         //   - Potential overlap of the System UI and image content
         //   - Actual amount of padding already being used
         //
         // By expanding the area, we allow the user to move the cursor 'under' the System UI which
         // pulls the content out from under it and allows it to be visible.  Once the System UI has
         // been dismissed or changes size, we use the actual padding value instead which prevents
         // the desktop image from 'snapping' back to pre-System UI state.
         RectF systemUiOverlap = getSystemUiOverlap();
         float[] padding = {Math.max(mVisibleImagePadding.left, systemUiOverlap.left),
-                Math.max(mVisibleImagePadding.top, systemUiOverlap.top),
+                Math.max(mVisibleImagePadding.top + mCursorOffsetScreenY, systemUiOverlap.top),
                 Math.max(mVisibleImagePadding.right, systemUiOverlap.right),
-                Math.max(mVisibleImagePadding.bottom, systemUiOverlap.bottom)};
+                Math.max(mVisibleImagePadding.bottom - mCursorOffsetScreenY,
+                        systemUiOverlap.bottom)};
         Matrix screenToImage = new Matrix();
         mRenderData.transform.invert(screenToImage);
         screenToImage.mapVectors(padding);
 
         return new RectF(-padding[0], -padding[1], mRenderData.imageWidth + padding[2],
                 mRenderData.imageHeight + padding[3]);
     }
 
     /** Returns a region which defines the set of valid viewport center values in image space. */
     private RectF getViewportBounds() {
@@ skipping 39 matching lines @@
      * Returns the amount of System UI along each edge of the screen which could overlap the remote
      * desktop image below it.  This is the maximum amount that could overlap, not the actual value.
      */
     private RectF getSystemUiOverlap() {
         // letterBox padding represents the space added to the image to center it on the screen.
         // Since it does not contain any interactable UI, we ignore it when calculating the overlap
         // between the System UI and the remote desktop image.
         // Note: Ignore negative padding (clamp to 0) since that means no overlap exists.
         PointF letterboxPadding = getLetterboxPadding();
         return new RectF(Math.max(mSystemUiScreenSize.left - letterboxPadding.x, 0.0f),
-                Math.max(mSystemUiScreenSize.top - letterboxPadding.y, 0.0f),
+                Math.max(mSystemUiScreenSize.top - letterboxPadding.y + mCursorOffsetScreenY, 0.0f),
                 Math.max(mSystemUiScreenSize.right - letterboxPadding.x, 0.0f),
-                Math.max(mSystemUiScreenSize.bottom - letterboxPadding.y, 0.0f));
+                Math.max(mSystemUiScreenSize.bottom - letterboxPadding.y - mCursorOffsetScreenY,
+                        0.0f));
     }
 
     /**
      * Calculates the amount of padding visible on each edge of the desktop image.
      */
     private void updateVisibleImagePadding() {
         PointF letterboxPadding = getLetterboxPadding();
         float[] imagePoints = {0.0f, 0.0f, mRenderData.imageWidth, mRenderData.imageHeight};
         mRenderData.transform.mapPoints(imagePoints);
 
         mVisibleImagePadding.set(Math.max(imagePoints[0] - letterboxPadding.x, 0.0f),
                 Math.max(imagePoints[1] - letterboxPadding.y, 0.0f),
                 Math.max(mRenderData.screenWidth - imagePoints[2] - letterboxPadding.x, 0.0f),
                 Math.max(mRenderData.screenHeight - imagePoints[3] - letterboxPadding.y, 0.0f));
     }
 }