Draw the mouse cursor in Chromoting Android client

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.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.graphics.Point;
 import android.os.Bundle;
 import android.os.Looper;
 import android.text.InputType;
 import android.util.Log;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.ScaleGestureDetector;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.inputmethod.EditorInfo;
@@ skipping 36 matching lines @@
 
     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 position, in image coordinates, at which the cursor image will be drawn.
+     * This will normally be at the location of the most recently injected motion event.
+     */
+    private Point mCursorPosition;
+
     /** Specifies the dimension by which the zoom level is being lower-bounded. */
     private Constraint mConstraint;
 
     /** Whether the dimension of constraint should be reckecked on the next aspect ratio change. */
     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. */
@@ skipping 11 matching lines @@
         mActionBar = context.getActionBar();
 
         getHolder().addCallback(this);
         DesktopListener listener = new DesktopListener();
         mScroller = new GestureDetector(context, listener, null, false);
         mZoomer = new ScaleGestureDetector(context, listener);
 
         mTransform = new Matrix();
         mScreenWidth = 0;
         mScreenHeight = 0;
+        mCursorPosition = new Point();
 
         mConstraint = Constraint.UNDEFINED;
         mRecheckConstraint = false;
 
         mRightUsedToBeOut = false;
         mBottomUsedToBeOut = false;
 
         mMouseButton = BUTTON_UNDEFINED;
         mMousePressed = false;
     }
@@ skipping 98 matching lines @@
                 }
 
                 mTransform.setValues(values);
             }
 
             canvas.setMatrix(mTransform);
         }
 
         canvas.drawColor(Color.BLACK);
         canvas.drawBitmap(image, 0, 0, new Paint());
+        Bitmap cursorBitmap = JniInterface.getCursorBitmap();
+        if (cursorBitmap != null) {
+            Point hotspot = JniInterface.getCursorHotspot();
+            int bitmapX, bitmapY;
+            synchronized (mCursorPosition) {
+                bitmapX = mCursorPosition.x - hotspot.x;
+                bitmapY = mCursorPosition.y - hotspot.y;
+            }
+            canvas.drawBitmap(cursorBitmap, bitmapX, bitmapY, new Paint());
+        }
         getHolder().unlockCanvasAndPost(canvas);
     }
 
     /**
      * 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).
      */
@@ skipping 13 matching lines @@
         synchronized (mTransform) {
             mScreenWidth = width;
             mScreenHeight = height;
 
             if (mRecheckConstraint) {
                 mConstraint = Constraint.UNDEFINED;
                 mRecheckConstraint = false;
             }
         }
 
+        synchronized (mCursorPosition) {
+            mCursorPosition.x = width / 2;
+            mCursorPosition.y = height / 2;
+        }
+
         if (!JniInterface.redrawGraphics()) {
             JniInterface.provideRedrawCallback(this);
         }
     }
 
     /** Called when the canvas is first created. */
     @Override
     public void surfaceCreated(SurfaceHolder holder) {
         Log.i("deskview", "DesktopView.surfaceCreated(...)");
     }
@@ skipping 27 matching lines @@
 
         return null;
     }
 
     /** Called when a mouse action is made. */
     private void handleMouseMovement(float x, float y, int button, boolean pressed) {
         float[] coordinates = {x, y};
 
         // Coordinates are relative to the canvas, but we need image coordinates.
         Matrix canvasToImage = new Matrix();
-        mTransform.invert(canvasToImage);
+        synchronized (mTransform) {
+            mTransform.invert(canvasToImage);
+        }
         canvasToImage.mapPoints(coordinates);
 
+        int imageX = (int)coordinates[0];
+        int imageY = (int)coordinates[1];
+
+        synchronized (mCursorPosition) {
+            mCursorPosition.x = imageX;
+            mCursorPosition.y = imageY;
+        }
+
         // Coordinates are now relative to the image, so transmit them to the host.
-        JniInterface.mouseAction((int)coordinates[0], (int)coordinates[1], button, pressed);
+        JniInterface.mouseAction(imageX, imageY, button, pressed);
+
+        // TODO(lambroslambrou): Optimize this to repaint only the areas covered by the old and new
+        // cursor positions.
+        JniInterface.redrawGraphics();
     }
 
     /**
      * 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();
@@ skipping 126 matching lines @@
                 handleMouseMovement(x, y, mMouseButton, false);
             }
 
             Log.i("mouse", "\tStarting right click");
             mMouseButton = BUTTON_RIGHT;
             mMousePressed = true;
             handleMouseMovement(x, y, mMouseButton, mMousePressed);
         }
     }
 }