Add Android Chromoting client keyboard input

remoting/android/java/src/org/chromium/chromoting/DesktopView.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.app.ActionBar;
+import android.app.Activity;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.os.Bundle;
 import android.os.Looper;
 import android.util.Log;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
@@ skipping 27 matching lines @@
      */
     private static final int BUTTON_UNDEFINED = 0;
     private static final int BUTTON_LEFT = 1;
     private static final int BUTTON_RIGHT = 3;
 
     /** Specifies one dimension of an image. */
     private static enum Constraint {
         UNDEFINED, WIDTH, HEIGHT
     }
 
+    private ActionBar mActionBar;
+
     private GestureDetector mScroller;
     private ScaleGestureDetector mZoomer;
 
     /** Stores pan and zoom configuration and converts image coordinates to screen coordinates. */
     private Matrix mTransform;
 
     private int mScreenWidth;
     private int mScreenHeight;
 
     /** Specifies the dimension by which the zoom level is being lower-bounded. */
     private Constraint mConstraint;
 
+    /** Why the screen dimensions are changing. */

[garykac, 2013/07/30 17:45:26]

I don't understand this comment. What does TRUE mean for this?

[solb, 2013/07/30 18:17:39]

Oops! That was left over from a more complicated intermediate implementation.

+    private boolean mRecheckConstraint;
+
     /** Whether the right edge of the image was visible on-screen during the last render. */
     private boolean mRightUsedToBeOut;
 
     /** Whether the bottom edge of the image was visible on-screen during the last render. */
     private boolean mBottomUsedToBeOut;
 
     private int mMouseButton;
     private boolean mMousePressed;
 
-    /** Whether the canvas needs to be redrawn. The update occurs when its size is next updated. */
-    private boolean mCanvasNeedsRedraw;
+    public DesktopView(Activity context) {
+        super(context);
+        mActionBar = context.getActionBar();
 
-    public DesktopView(Context context) {
-        super(context);
         getHolder().addCallback(this);
         DesktopListener listener = new DesktopListener();
         mScroller = new GestureDetector(context, listener);
         mZoomer = new ScaleGestureDetector(context, listener);
 
         mTransform = new Matrix();
         mScreenWidth = 0;
         mScreenHeight = 0;
+
         mConstraint = Constraint.UNDEFINED;
+        mRecheckConstraint = false;
 
         mRightUsedToBeOut = false;
         mBottomUsedToBeOut = false;
 
         mMouseButton = BUTTON_UNDEFINED;
         mMousePressed = false;
-
-        mCanvasNeedsRedraw = false;
     }
 
     /**
      * Redraws the canvas. This should be done on a non-UI thread or it could
      * cause the UI to lag. Specifically, it is currently invoked on the native
      * graphics thread using a JNI.
      */
     @Override
     public void run() {
         if (Looper.myLooper() == Looper.getMainLooper()) {
@@ skipping 12 matching lines @@
             // Screen coordinates of two defining points of the image.
             float[] topleft = {0, 0};
             mTransform.mapPoints(topleft);
             float[] bottomright = {image.getWidth(), image.getHeight()};
             mTransform.mapPoints(bottomright);
 
             // Whether to rescale and recenter the view.
             boolean recenter = false;
 
             if (mConstraint == Constraint.UNDEFINED) {
-                mConstraint = image.getWidth()/image.getHeight() > mScreenWidth/mScreenHeight ?
-                        Constraint.WIDTH : Constraint.HEIGHT;
+                mConstraint = (double)image.getWidth()/image.getHeight() >
+                        (double)mScreenWidth/mScreenHeight ? Constraint.WIDTH : Constraint.HEIGHT;
                 recenter = true;  // We always rescale and recenter after a rotation.
             }
 
             if (mConstraint == Constraint.WIDTH &&
                     ((int)(bottomright[0] - topleft[0] + 0.5) < mScreenWidth || recenter)) {
                 // The vertical edges of the image are flush against the device's screen edges
                 // when the entire host screen is visible, and the user has zoomed out too far.
                 float imageMiddle = (float)image.getHeight() / 2;
                 float screenMiddle = (float)mScreenHeight / 2;
                 mTransform.setPolyToPoly(
@@ skipping 60 matching lines @@
             }
 
             canvas.setMatrix(mTransform);
         }
 
         canvas.drawColor(Color.BLACK);
         canvas.drawBitmap(image, 0, 0, new Paint());
         getHolder().unlockCanvasAndPost(canvas);
     }
 
-    /** Causes the canvas to be redrawn the next time our surface changes. */
-    public void requestCanvasRedraw() {
-        mCanvasNeedsRedraw = true;
+    /**
+     * Causes the next canvas redraw to perform a check for which screen dimension more tightly
+     * constrains the view of the image. This should be called between the time that a screen size
+     * change is requested and the time it actually occurs. If it is not called in such a case, the
+     * screen will not be rearranged as aggressively (which is desirable when the software keyboard
+     * appears in order to allow it to cover the image without forcing a resize).
+     */
+    public void requestRecheckConstrainingDimension() {
+        mRecheckConstraint = true;
     }
 
     /**
      * Called after the canvas is initially created, then after every
      * subsequent resize, as when the display is rotated.
      */
     @Override
     public void surfaceChanged(
             SurfaceHolder holder, int format, int width, int height) {
+        mActionBar.hide();
+
         synchronized (mTransform) {
             mScreenWidth = width;
             mScreenHeight = height;
-            mConstraint = Constraint.UNDEFINED;
+
+            if (mRecheckConstraint) {
+                mConstraint = Constraint.UNDEFINED;
+                mRecheckConstraint = false;
+            }
         }
 
-        if (mCanvasNeedsRedraw) {
-            JniInterface.redrawGraphics();
-            mCanvasNeedsRedraw = false;
+        if (!JniInterface.redrawGraphics()) {
+            JniInterface.provideRedrawCallback(this);
         }
     }
 
     /** Called when the canvas is first created. */
     @Override
     public void surfaceCreated(SurfaceHolder holder) {
         Log.i("deskview", "DesktopView.surfaceCreated(...)");
-        JniInterface.provideRedrawCallback(this);
     }
 
     /**
      * Called when the canvas is finally destroyed. Marks the canvas as needing a redraw so that it
      * will not be blank if the user later switches back to our window.
      */
     @Override
     public void surfaceDestroyed(SurfaceHolder holder) {
         Log.i("deskview", "DesktopView.surfaceDestroyed(...)");
+
+        // Stop this canvas from being redrawn.
         JniInterface.provideRedrawCallback(null);
-
-        // Redraw the desktop as soon as the user switches back to this window.
-        mCanvasNeedsRedraw = true;
     }
 
     /** Called when a mouse action is made. */
     private void handleMouseMovement(float[] coordinates, int button, boolean pressed) {
         // Coordinates are relative to the canvas, but we need image coordinates.
         Matrix canvasToImage = new Matrix();
         mTransform.invert(canvasToImage);
         canvasToImage.mapPoints(coordinates);
 
         // Coordinates are now relative to the image, so transmit them to the host.
         JniInterface.mouseAction((int)coordinates[0], (int)coordinates[1], button, pressed);
     }
 
     /**
      * Called whenever the user attempts to touch the canvas. Forwards such
      * events to the appropriate gesture detector until one accepts them.
      */
     @Override
     public boolean onTouchEvent(MotionEvent event) {
+        if (event.getPointerCount() == 3) {
+            mActionBar.show();
+        }
+
         boolean handled = mScroller.onTouchEvent(event) || mZoomer.onTouchEvent(event);
 
-        if (event.getPointerCount()==1) {
+        if (event.getPointerCount() == 1) {
             float[] coordinates = {event.getRawX(), event.getY()};
 
             switch (event.getActionMasked()) {
                 case MotionEvent.ACTION_DOWN:
                     Log.i("mouse", "Found a finger");
                     mMouseButton = BUTTON_UNDEFINED;
                     mMousePressed = false;
                     break;
 
                 case MotionEvent.ACTION_MOVE:
@@ skipping 109 matching lines @@
                 handleMouseMovement(coordinates, mMouseButton, false);
             }
 
             Log.i("mouse", "\tStarting right click");
             mMouseButton = BUTTON_RIGHT;
             mMousePressed = true;
             handleMouseMovement(coordinates, mMouseButton, mMousePressed);
         }
     }
 }