[Chromoting] TouchInputHandler now listens to events in DesktopView

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 40 matching lines @@
     // be dropped if this is already set to true. This is used by the main thread and the painting
     // thread, so the access should be synchronized on |mRenderData|.
     private boolean mRepaintPending;
 
     // Flag used to ensure that the SurfaceView is only painted between calls to surfaceCreated()
     // and surfaceDestroyed(). Accessed on main thread and display thread, so this should be
     // synchronized on |mRenderData|.
     private boolean mSurfaceCreated = false;
 
     private final Event.Raisable<PaintEventParameter> mOnPaint = new Event.Raisable<>();
+    private final Event.Raisable<SizeChangedEventParameter> mOnClientSizeChanged =
+            new Event.Raisable<>();
+    private final Event.Raisable<SizeChangedEventParameter> mOnHostSizeChanged =
+            new Event.Raisable<>();
+    private final Event.Raisable<TouchEventParameter> mOnTouch = new Event.Raisable<>();
 
     // Variables to control animation by the TouchInputHandler.
 
     /** Protects mInputAnimationRunning. */
     private final Object mAnimationLock = new Object();
 
     /** Whether the TouchInputHandler has requested animation to be performed. */
     private boolean mInputAnimationRunning = false;
 
     public DesktopView(Context context, AttributeSet attributes) {
@@ skipping 18 matching lines @@
         Preconditions.notNull(client);
         mDesktop = desktop;
         mClient = client;
         mInputHandler.init(desktop, client);
     }
 
     public Event<PaintEventParameter> onPaint() {
         return mOnPaint;
     }
 
+    public Event<SizeChangedEventParameter> onClientSizeChanged() {
+        return mOnClientSizeChanged;
+    }
+
+    public Event<SizeChangedEventParameter> onHostSizeChanged() {
+        return mOnHostSizeChanged;
+    }
+
+    public Event<TouchEventParameter> onTouch() {
+        return mOnTouch;
+    }
+
     /** Request repainting of the desktop view. */
     void requestRepaint() {
         synchronized (mRenderData) {
             if (mRepaintPending) {
                 return;
             }
             mRepaintPending = true;
         }
         mClient.getDisplay().redrawGraphics();
     }
@@ skipping 24 matching lines @@
             if (mRenderData.imageWidth != width || mRenderData.imageHeight != height) {
                 // TODO(lambroslambrou): Move this code into a sizeChanged() callback, to be
                 // triggered from native code (on the display thread) when the remote screen size
                 // changes.
                 mRenderData.imageWidth = width;
                 mRenderData.imageHeight = height;
                 sizeChanged = true;
             }
         }
         if (sizeChanged) {
-            mInputHandler.onHostSizeChanged(width, height);
+            mOnHostSizeChanged.raise(new SizeChangedEventParameter(width, height));
         }
 
         Canvas canvas;
         Point cursorPosition;
         boolean drawCursor;
         synchronized (mRenderData) {
             mRepaintPending = false;
             // Don't try to lock the canvas before it is ready, as the implementation of
             // lockCanvas() may throttle these calls to a slow rate in order to avoid consuming CPU.
             // Note that a successful call to lockCanvas() will prevent the framework from
@@ skipping 62 matching lines @@
      * the display is rotated.
      */
     @Override
     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
         synchronized (mRenderData) {
             mRenderData.screenWidth = width;
             mRenderData.screenHeight = height;
         }
 
         attachRedrawCallback();
-        mInputHandler.onClientSizeChanged(width, height);
+        mOnClientSizeChanged.raise(new SizeChangedEventParameter(width, height));
         requestRepaint();
     }
 
     public void attachRedrawCallback() {
         mClient.getDisplay().provideRedrawCallback(new Runnable() {
             @Override
             public void run() {
                 paint();
             }
         });
@@ skipping 32 matching lines @@
 
         // Stops software keyboards from closing as soon as the enter key is pressed.
         outAttrs.imeOptions |= EditorInfo.IME_MASK_ACTION | EditorInfo.IME_FLAG_NO_ENTER_ACTION;
 
         return null;
     }
 
     /** Called whenever the user attempts to touch the canvas. */
     @Override
     public boolean onTouchEvent(MotionEvent event) {
-        return mInputHandler.onTouchEvent(event);
+        TouchEventParameter parameter = new TouchEventParameter(event);
+        mOnTouch.raise(parameter);
+        return parameter.handled;
     }
 
     @Override
     public void showInputFeedback(InputFeedbackType feedbackToShow, Point pos) {
         if (feedbackToShow != InputFeedbackType.NONE) {
             FeedbackAnimator.startAnimation(this, pos, feedbackToShow);
             requestRepaint();
         }
     }
 
@@ skipping 17 matching lines @@
     @Override
     public void setAnimationEnabled(boolean enabled) {
         synchronized (mAnimationLock) {
             if (enabled && !mInputAnimationRunning) {
                 requestRepaint();
             }
             mInputAnimationRunning = enabled;
         }
     }
 }