Implement basic point-and-touch mouse input for 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.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
@@ skipping 45 matching lines @@
 
     /** Specifies the dimension by which the zoom level is being lower-bounded. */
     private Constraint mConstraint;
 
     /** 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;
+
     /** Whether the device has just been rotated, necessitating a canvas redraw. */
     private boolean mJustRotated;
 
     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;
 
         mRightUsedToBeOut = false;
         mBottomUsedToBeOut = false;
 
+        mMouseButton = 0;
+
         mJustRotated = 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() {
@@ skipping 118 matching lines @@
         Log.i("deskview", "DesktopView.surfaceCreated(...)");
         JniInterface.provideRedrawCallback(this);
     }
 
     /** Called when the canvas is finally destroyed. */
     @Override
     public void surfaceDestroyed(SurfaceHolder holder) {
         Log.i("deskview", "DesktopView.surfaceDestroyed(...)");
     }
 
+    /** Called when a mouse action is made. */
+    private void handleMouseMovement(float[] coordinates, int button) {
+        // 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);
+    }
+
     /**
      * 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) {
-        return mScroller.onTouchEvent(event) || mZoomer.onTouchEvent(event);
+        boolean handled = mScroller.onTouchEvent(event) || mZoomer.onTouchEvent(event);
+
+        if (event.getPointerCount()==1) {
+            float[] coordinates = {event.getRawX(), event.getY()};
+
+            switch (event.getActionMasked()) {
+                case MotionEvent.ACTION_DOWN:
+                    Log.i("gesture", "Down...");
+                    mMouseButton = 0;
+                    break;
+
+                case MotionEvent.ACTION_MOVE:
+                    if (mMouseButton==0) {
+                        Log.i("gesture", "Moving 1");
+                        mMouseButton = 1;  // TODO Name me!

[solb, 2013/07/22 19:13:48]

Sorry; I had forgotten how rough this revision was! I shouldn't have sent it out
for review on Friday...

+                    }
+                    else Log.i("gesture", "Moving " + mMouseButton);
+                    break;
+
+                case MotionEvent.ACTION_UP:
+                    if (mMouseButton==0) {
+                        Log.i("gesture", "Releasing 1 (after press)");
+                        handleMouseMovement(coordinates, 1);  // TODO Name me!
+                        mMouseButton = -1;  // TODO Name me!
+                    }
+                    else if (mMouseButton > 0) {
+                        Log.i("gesture", "Releasing " + mMouseButton);
+                        mMouseButton *= -1;
+                    }
+                    else {
+                        Log.w("gesture", "Button already in released state before gesture ended");
+                    }
+                    break;
+
+                default:
+                    return handled;
+            }
+            handleMouseMovement(coordinates, mMouseButton);
+
+            return true;
+        }
+
+        return handled;
     }
 
     /** Responds to touch events filtered by the gesture detectors. */
     private class DesktopListener extends GestureDetector.SimpleOnGestureListener
             implements ScaleGestureDetector.OnScaleGestureListener {
         /**
          * Called when the user is scrolling. We refuse to accept or process the event unless it
          * is being performed with 2 or more touch points, in order to reserve single-point touch
          * events for emulating mouse input.
          */
@@ skipping 21 matching lines @@
 
             synchronized (mTransform) {
                 float scaleFactor = detector.getScaleFactor();
                 mTransform.postScale(
                         scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());
             }
             JniInterface.redrawGraphics();
             return true;
         }
 
+        /** Called whenever a gesture starts. Always accepts the gesture so it isn't ignored. */
+        @Override
+        public boolean onDown(MotionEvent e) {
+            return true;
+        }
+
         /**
          * Called when the user starts to zoom. Always accepts the zoom so that
          * onScale() can decide whether to respond to it.
          */
         @Override
         public boolean onScaleBegin(ScaleGestureDetector detector) {
             return true;
         }
 
         /**
          * Called when the user is done zooming. Defers to onScale()'s judgement.
          */
         @Override
         public void onScaleEnd(ScaleGestureDetector detector) {
             onScale(detector);
         }
+
+        @Override
+        public void onLongPress(MotionEvent e) {
+            float[] coordinates = new float[] {e.getRawX(), e.getY()};
+
+            if (mMouseButton > 0) {
+                Log.i("gesture", "Releasing " + mMouseButton);
+                handleMouseMovement(coordinates, -mMouseButton);
+            }
+
+            Log.i("gesture", "Pressing 3");
+            mMouseButton = 3;  // TODO Name me!
+            handleMouseMovement(coordinates, mMouseButton);
+        }
     }
 }