[Chromoting] Decouple DesktopView and TouchInputHandler

remoting/android/java/src/org/chromium/chromoting/Desktop.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.annotation.SuppressLint;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
-import android.graphics.Rect;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Handler;
 import android.support.v7.app.ActionBar.OnMenuVisibilityListener;
 import android.support.v7.app.AlertDialog;
 import android.support.v7.app.AppCompatActivity;
 import android.support.v7.widget.Toolbar;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.Menu;
@@ skipping 35 matching lines @@
      * Cardboard function.
      */
     private static final String PREFERENCE_CARDBOARD_DIALOG_SEEN = "cardboard_dialog_seen";
 
     /** Preference used to track the last input mode selected by the user. */
     private static final String PREFERENCE_INPUT_MODE = "input_mode";
 
     /** The amount of time to wait to hide the Actionbar after user input is seen. */
     private static final int ACTIONBAR_AUTO_HIDE_DELAY_MS = 3000;
 
-    /** The surface that displays the remote host's desktop feed. */
-    private DesktopView mRemoteHostDesktop;
+    private final Event.Raisable<SoftInputMethodVisibilityChangedEventParameter>
+            mOnSoftInputMethodVisibilityChanged = new Event.Raisable<>();
+
+    private final Event.Raisable<InputModeChangedEventParameter> mOnInputModeChanged =
+            new Event.Raisable<>();
 
     private Client mClient;
 
     /** Set of pressed keys for which we've sent TextEvent. */
     private Set<Integer> mPressedTextKeys = new TreeSet<Integer>();
 
     private ActivityLifecycleListener mActivityLifecycleListener;
 
     /** Flag to indicate whether the current activity is switching to Cardboard desktop activity. */
     private boolean mSwitchToCardboardDesktopActivity;
@@ skipping 21 matching lines @@
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.desktop);
 
         mClient = Client.getInstance();
 
         mToolbar = (Toolbar) findViewById(R.id.toolbar);
         setSupportActionBar(mToolbar);
 
-        mRemoteHostDesktop = (DesktopView) findViewById(R.id.desktop_view);
-        mRemoteHostDesktop.setDesktop(this);
-        mRemoteHostDesktop.setClient(mClient);
+        DesktopView remoteHostDesktop = (DesktopView) findViewById(R.id.desktop_view);
+        remoteHostDesktop.init(this, mClient);
         mSwitchToCardboardDesktopActivity = false;
 
         getSupportActionBar().setDisplayShowTitleEnabled(false);
         getSupportActionBar().setDisplayHomeAsUpEnabled(true);
 
         // For this Activity, the home button in the action bar acts as a Disconnect button, so
         // set the description for accessibility/screen readers.
         getSupportActionBar().setHomeActionContentDescription(R.string.disconnect_myself_button);
 
         // The action bar is already shown when the activity is started however calling the
@@ skipping 28 matching lines @@
             getSupportActionBar().addOnMenuVisibilityListener(new OnMenuVisibilityListener() {
                 public void onMenuVisibilityChanged(boolean isVisible) {
                     if (isVisible) {
                         stopActionBarAutoHideTimer();
                     } else {
                         startActionBarAutoHideTimer();
                     }
                 }
             });
         } else {
-            mRemoteHostDesktop.setFitsSystemWindows(true);
+            remoteHostDesktop.setFitsSystemWindows(true);
         }
     }
 
     @Override
     protected void onStart() {
         super.onStart();
         mActivityLifecycleListener.onActivityStarted(this);
         mClient.enableVideoChannel(true);
-        mRemoteHostDesktop.attachRedrawCallback();
+        DesktopView desktopView = (DesktopView) findViewById(R.id.desktop_view);
+        desktopView.attachRedrawCallback();
         mClient.getCapabilityManager().addListener(this);
     }
 
     @Override
     protected void onPause() {
         if (isFinishing()) mActivityLifecycleListener.onActivityPaused(this);
         super.onPause();
         if (!mSwitchToCardboardDesktopActivity) {
             mClient.enableVideoChannel(false);
         }
@@ skipping 68 matching lines @@
         }
 
         ChromotingUtil.tintMenuIcons(this, menu);
 
         // Wait to set the input mode until after the default tinting has been applied.
         setInputMode(mInputMode);
 
         return super.onCreateOptionsMenu(menu);
     }
 
+    public Event<SoftInputMethodVisibilityChangedEventParameter>
+            onSoftInputMethodVisibilityChanged() {
+        return mOnSoftInputMethodVisibilityChanged;
+    }
+
+    public Event<InputModeChangedEventParameter> onInputModeChanged() {
+        return mOnInputModeChanged;
+    }
+
     private InputMode getInitialInputModeValue() {
         // Load the previously-selected input mode from Preferences.
         // TODO(joedow): Evaluate and determine if we should use a different input mode based on
         //               a device characteristic such as screen size.
         InputMode inputMode = InputMode.TRACKPAD;
         String previousInputMode =
                 getPreferences(MODE_PRIVATE)
                         .getString(PREFERENCE_INPUT_MODE, inputMode.name());
 
         try {
@@ skipping 19 matching lines @@
             assert false : "Unreached";
             return;
         }
 
         mInputMode = inputMode;
         getPreferences(MODE_PRIVATE)
                 .edit()
                 .putString(PREFERENCE_INPUT_MODE, mInputMode.name())
                 .apply();
 
-        mRemoteHostDesktop.changeInputMode(mInputMode, mHostTouchCapability);
+        mOnInputModeChanged.raise(
+                new InputModeChangedEventParameter(mInputMode, mHostTouchCapability));
     }
 
     @Override
     public void onCapabilitiesChanged(List<String> newCapabilities) {
         if (newCapabilities.contains(Capabilities.TOUCH_CAPABILITY)) {
             mHostTouchCapability = CapabilityManager.HostCapability.SUPPORTED;
         } else {
             mHostTouchCapability = CapabilityManager.HostCapability.UNSUPPORTED;
         }
 
-        mRemoteHostDesktop.changeInputMode(mInputMode, mHostTouchCapability);
+        mOnInputModeChanged.raise(
+                new InputModeChangedEventParameter(mInputMode, mHostTouchCapability));
     }
 
     // Any time an onTouchListener is attached, a lint warning about filtering touch events is
     // generated.  Since the function below is only used to listen to, not intercept, the events,
     // the lint warning can be safely suppressed.
     @SuppressLint("ClickableViewAccessibility")
     private void attachToolbarInteractionListenerToView(View view) {
         view.setOnTouchListener(new OnTouchListener() {
             @Override
             public boolean onTouch(View view, MotionEvent event) {
@@ skipping 219 matching lines @@
                     mMaxBottomValue = bottom;
                     return;
                 }
 
                 // If the delta between lowest bound we have seen (should be a systemUI such as
                 // the navigation bar) and the current bound does not match, then we have a form
                 // of soft input displayed.  Note that the size of a soft input device can change
                 // when the input method is changed so we want to send updates to the image canvas
                 // whenever they occur.
                 mSoftInputVisible = (bottom < mMaxBottomValue);
-                mRemoteHostDesktop.onSoftInputMethodVisibilityChanged(
-                        mSoftInputVisible, new Rect(left, top, right, bottom));
+                mOnSoftInputMethodVisibilityChanged.raise(
+                        new SoftInputMethodVisibilityChangedEventParameter(
+                                mSoftInputVisible, left, top, right, bottom));
 
                 if (!mSoftInputVisible && mHideSystemUIOnSoftKeyboardDismiss) {
                     // Queue a task which will run after the current action (OSK dismiss) has
                     // completed, otherwise the hide request will not take effect.
                     new Handler().post(new Runnable() {
                         @Override
                         public void run() {
                             if (mHideSystemUIOnSoftKeyboardDismiss) {
                                 mHideSystemUIOnSoftKeyboardDismiss = false;
                                 hideActionBar();
@@ skipping 121 matching lines @@
                 mClient.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
                 mClient.sendKeyEvent(0, KeyEvent.KEYCODE_EQUALS, pressed);
                 return true;
 
             default:
                 // We try to send all other key codes to the host directly.
                 return mClient.sendKeyEvent(0, keyCode, pressed);
         }
     }
 }