Updating SystemUI visibility events in Adroid Client.

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;
@@ skipping 91 matching lines @@
 
         @Override
         protected void processAction(float deltaX, float deltaY) {
             float[] delta = {deltaX, deltaY};
             synchronized (mRenderData) {
                 Matrix canvasToImage = new Matrix();
                 mRenderData.transform.invert(canvasToImage);
                 canvasToImage.mapVectors(delta);
             }
 
-            moveViewportWithOffset(-delta[0], -delta[1]);
+            moveViewportByOffset(-delta[0], -delta[1]);
         }
     }
 
     /**
      * This class implements fling animation for scrolling
      */
     private class ScrollAnimationJob extends FlingAnimationJob {
         public ScrollAnimationJob(Context context) {
             super(context);
         }
@@ skipping 103 matching lines @@
     public void init(Desktop desktop, final InputEventSender injector) {
         Preconditions.notNull(injector);
         desktop.onInputModeChanged().add(
                 new Event.ParameterRunnable<InputModeChangedEventParameter>() {
                     @Override
                     public void run(InputModeChangedEventParameter parameter) {
                         handleInputModeChanged(parameter, injector);
                     }
                 });
 
-        desktop.onSoftInputMethodVisibilityChanged().add(
-                new Event.ParameterRunnable<SoftInputMethodVisibilityChangedEventParameter>() {
+        desktop.onSystemUiVisibilityChanged().add(
+                new Event.ParameterRunnable<SystemUiVisibilityChangedEventParameter>() {
                     @Override
-                    public void run(SoftInputMethodVisibilityChangedEventParameter parameter) {
-                        handleSoftInputMethodVisibilityChanged(parameter);
+                    public void run(SystemUiVisibilityChangedEventParameter parameter) {
+                        handleSystemUiVisibilityChanged(parameter);
                     }
                 });
     }
 
     private void attachViewEvents(DesktopViewInterface viewer) {
         viewer.onTouch().add(new Event.ParameterRunnable<TouchEventParameter>() {
             @Override
             public void run(TouchEventParameter parameter) {
                 parameter.handled = handleTouchEvent(parameter.event);
             }
@@ skipping 39 matching lines @@
 
             default:
                 // Unreachable, but required by Google Java style and findbugs.
                 assert false : "Unreached";
         }
 
         // Ensure the cursor state is updated appropriately.
         mViewer.cursorVisibilityChanged();
     }
 
-    private void handleSoftInputMethodVisibilityChanged(
-            SoftInputMethodVisibilityChangedEventParameter parameter) {
+    private void handleSystemUiVisibilityChanged(
+            SystemUiVisibilityChangedEventParameter parameter) {
         synchronized (mRenderData) {
-            if (parameter.visible) {
-                mDesktopCanvas.setInputMethodOffsetValues(
+            if (parameter.softInputMethodVisible) {
+                mDesktopCanvas.setSystemUiOffsetValues(parameter.left, parameter.top,
                         mRenderData.screenWidth - parameter.right,
                         mRenderData.screenHeight - parameter.bottom);
             } else {
-                mDesktopCanvas.setInputMethodOffsetValues(0, 0);
+                mDesktopCanvas.setSystemUiOffsetValues(0, 0, 0, 0);
             }
         }
-
         mDesktopCanvas.repositionImage(true);
     }
 
     private boolean handleTouchEvent(MotionEvent event) {
         // Give the underlying input strategy a chance to observe the current motion event before
         // passing it to the gesture detectors.  This allows the input strategy to react to the
         // event or save the payload for use in recreating the gesture remotely.
         mInputStrategy.onMotionEvent(event);
 
         // Avoid short-circuit logic evaluation - ensure all gesture detectors see all events so
@@ skipping 45 matching lines @@
 
     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;
     }
 
     /** Moves the desired center of the viewport using the specified deltas. */
-    private void moveViewportWithOffset(float deltaX, float deltaY) {
+    private void moveViewportByOffset(float deltaX, float deltaY) {
         // If we are in an indirect mode or are in the middle of a drag operation, then we want to
         // invert the direction of the operation (i.e. follow the motion of the finger).
-        if (mInputStrategy.isIndirectInputMode() || mIsDragging) {
+        boolean followCursor = (mInputStrategy.isIndirectInputMode() || mIsDragging);
+        if (followCursor) {
             deltaX = -deltaX;
             deltaY = -deltaY;
         }
-
         // Determine the center point from which to apply the delta.
         // For indirect input modes (i.e. trackpad), the view generally follows the cursor.
         // For direct input modes (i.e. touch) the should track the user's motion.
         // If the user is dragging, then the viewport should always follow the user's finger.
-        PointF viewportPoint;
-        if (mInputStrategy.isIndirectInputMode() || mIsDragging) {
-            viewportPoint = mDesktopCanvas.getViewportPosition();
-        } else {
-            PointF adjustedViewportSize = mDesktopCanvas.getViewportSize();
-            synchronized (mRenderData) {
-                float[] viewportPosition = new float[] {(float) adjustedViewportSize.x / 2,
-                                                        (float) adjustedViewportSize.y / 2};
-                Matrix inverted = new Matrix();
-                mRenderData.transform.invert(inverted);
-                inverted.mapPoints(viewportPosition);
-                viewportPoint = new PointF(viewportPosition[0], viewportPosition[1]);
-            }
-        }
-
-        // Constrain the coordinates to the image area.
-        float newX = viewportPoint.x + deltaX;
-        float newY = viewportPoint.y + deltaY;
-        synchronized (mRenderData) {
-            // Constrain viewport position to the image area.
-            if (newX < 0) {
-                newX = 0;
-            } else if (newX > mRenderData.imageWidth) {
-                newX = mRenderData.imageWidth;
-            }
-
-            if (newY < 0) {
-                newY = 0;
-            } else if (newY > mRenderData.imageHeight) {
-                newY = mRenderData.imageHeight;
-            }
-        }
-
-        moveViewport(newX, newY);
-    }
-
-    /** Moves the desired center of the viewport to the specified position. */
-    private void moveViewport(float newX, float newY) {
-        mDesktopCanvas.setViewportPosition(newX, newY);
+        PointF newPos = mDesktopCanvas.moveViewportCenter(!followCursor, deltaX, deltaY);
 
         // If we are in an indirect mode or are in the middle of a drag operation, then we want to
         // keep the cursor centered, if possible, as the viewport moves.
-        if (mInputStrategy.isIndirectInputMode() || mIsDragging) {
-            moveCursor((int) newX, (int) newY);
+        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();
@@ skipping 77 matching lines @@
                 return false;
             }
 
             float[] delta = {distanceX, distanceY};
             synchronized (mRenderData) {
                 Matrix canvasToImage = new Matrix();
                 mRenderData.transform.invert(canvasToImage);
                 canvasToImage.mapVectors(delta);
             }
 
-            moveViewportWithOffset(delta[0], delta[1]);
+            moveViewportByOffset(delta[0], delta[1]);
             return true;
         }
 
         /**
          * Called when a fling gesture is recognized.
          */
         @Override
         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
             if (mSuppressFling) {
                 return false;
@@ skipping 111 matching lines @@
                 case 2:
                     return InputStub.BUTTON_RIGHT;
                 case 3:
                     return InputStub.BUTTON_MIDDLE;
                 default:
                     return InputStub.BUTTON_UNDEFINED;
             }
         }
     }
 }