[Chromoting] Add InputInjector and InputInjectorWrapper for easy unittesting

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.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;
 import android.view.MenuItem;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.View.OnLayoutChangeListener;
 import android.view.View.OnTouchListener;
 import android.view.inputmethod.InputMethodManager;
 
 import org.chromium.chromoting.cardboard.DesktopActivity;
@@ skipping 34 matching lines @@
     /** 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;
 
     private final Event.Raisable<SoftInputMethodVisibilityChangedEventParameter>
             mOnSoftInputMethodVisibilityChanged = new Event.Raisable<>();
 
     private final Event.Raisable<InputModeChangedEventParameter> mOnInputModeChanged =
             new Event.Raisable<>();
 
     private Client mClient;
+    private InputInjectorWrapper mInjector;
 
     /** Set of pressed keys for which we've sent TextEvent. */
     private Set<Integer> mPressedTextKeys = new TreeSet<Integer>();

[Lambros, 2016/06/17 23:00:09]

Remove this, it's not used.

[Hzj_jie, 2016/06/19 23:41:38]

Done.

 
     private ActivityLifecycleListener mActivityLifecycleListener;
 
     /** Flag to indicate whether the current activity is switching to Cardboard desktop activity. */
     private boolean mSwitchToCardboardDesktopActivity;
 
     /** Flag to indicate whether to manually hide the system UI when the OSK is dismissed. */
     private boolean mHideSystemUIOnSoftKeyboardDismiss = false;
 
     /** Indicates whether a Soft Input UI (such as a keyboard) is visible. */
@@ skipping 12 matching lines @@
     private CapabilityManager.HostCapability mHostTouchCapability =
             CapabilityManager.HostCapability.UNKNOWN;
 
     /** Called when the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.desktop);
 
         mClient = Client.getInstance();
+        mInjector = new InputInjectorWrapper(mClient);
 
         mToolbar = (Toolbar) findViewById(R.id.toolbar);
         setSupportActionBar(mToolbar);
 
         DesktopView remoteHostDesktop = (DesktopView) findViewById(R.id.desktop_view);
         remoteHostDesktop.init(this, mClient);
         mSwitchToCardboardDesktopActivity = false;
 
         getSupportActionBar().setDisplayShowTitleEnabled(false);
         getSupportActionBar().setDisplayHomeAsUpEnabled(true);
@@ skipping 384 matching lines @@
         }
         if (id == R.id.actionbar_hide) {
             hideActionBar();
             return true;
         }
         if (id == R.id.actionbar_disconnect || id == android.R.id.home) {
             mClient.destroy();
             return true;
         }
         if (id == R.id.actionbar_send_ctrl_alt_del) {
-            int[] keys = {
-                KeyEvent.KEYCODE_CTRL_LEFT,
-                KeyEvent.KEYCODE_ALT_LEFT,
-                KeyEvent.KEYCODE_FORWARD_DEL,
-            };
-            for (int key : keys) {
-                mClient.sendKeyEvent(0, key, true);
-            }
-            for (int key : keys) {
-                mClient.sendKeyEvent(0, key, false);
-            }
+            mInjector.sendCtrlAltDel();
             return true;
         }
         if (id == R.id.actionbar_help) {
             HelpSingleton.getInstance().launchHelp(this, HelpContext.DESKTOP);
             return true;
         }
         return super.onOptionsItemSelected(item);
     }
 
     private void attachKeyboardVisibilityListener() {
@@ skipping 82 matching lines @@
         startActivityForResult(intent, Chromoting.CARDBOARD_DESKTOP_ACTIVITY);
     }
 
     /**
      * Called once when a keyboard key is pressed, then again when that same key is released. This
      * is not guaranteed to be notified of all soft keyboard events: certian keyboards might not
      * call it at all, while others might skip it in certain situations (e.g. swipe input).
      */
     @Override
     public boolean dispatchKeyEvent(KeyEvent event) {
-        int keyCode = event.getKeyCode();
-
-        // Dispatch the back button to the system to handle navigation
-        if (keyCode == KeyEvent.KEYCODE_BACK) {
+        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
             mClient.destroy();
             return super.dispatchKeyEvent(event);
         }
 
-        boolean pressed = event.getAction() == KeyEvent.ACTION_DOWN;
-
-        // Physical keyboard must work as if it is connected to the remote host
-        // and so events coming from physical keyboard never generate text
-        // events. Also scan codes must be used instead of key code, so that
-        // the keyboard layout selected on the client doesn't affect the key
-        // codes sent to the host.
-        if (event.getDeviceId() != KeyCharacterMap.VIRTUAL_KEYBOARD) {
-            return mClient.sendKeyEvent(event.getScanCode(), 0, pressed);
-        }
-
-        // Events received from software keyboards generate TextEvent in two
-        // cases:
-        //   1. This is an ACTION_MULTIPLE event.
-        //   2. Ctrl, Alt and Meta are not pressed.
-        // This ensures that on-screen keyboard always injects input that
-        // correspond to what user sees on the screen, while physical keyboard
-        // acts as if it is connected to the remote host.
-        if (event.getAction() == KeyEvent.ACTION_MULTIPLE) {
-            mClient.sendTextEvent(event.getCharacters());
-            return true;
-        }
-
-        // For Enter getUnicodeChar() returns 10 (line feed), but we still
-        // want to send it as KeyEvent.
-        int unicode = keyCode != KeyEvent.KEYCODE_ENTER ? event.getUnicodeChar() : 0;
-
-        boolean no_modifiers = !event.isAltPressed()
-                && !event.isCtrlPressed() && !event.isMetaPressed();
-
-        if (pressed && unicode != 0 && no_modifiers) {
-            mPressedTextKeys.add(keyCode);
-            int[] codePoints = { unicode };
-            mClient.sendTextEvent(new String(codePoints, 0, 1));
-            return true;
-        }
-
-        if (!pressed && mPressedTextKeys.contains(keyCode)) {
-            mPressedTextKeys.remove(keyCode);
-            return true;
-        }
-
-        switch (keyCode) {
-            // KEYCODE_AT, KEYCODE_POUND, KEYCODE_STAR and KEYCODE_PLUS are
-            // deprecated, but they still need to be here for older devices and
-            // third-party keyboards that may still generate these events. See
-            // https://source.android.com/devices/input/keyboard-devices.html#legacy-unsupported-keys
-            case KeyEvent.KEYCODE_AT:
-                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
-                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_2, pressed);
-                return true;
-
-            case KeyEvent.KEYCODE_POUND:
-                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
-                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_3, pressed);
-                return true;
-
-            case KeyEvent.KEYCODE_STAR:
-                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
-                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_8, pressed);
-                return true;
-
-            case KeyEvent.KEYCODE_PLUS:
-                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);
-        }
+        return mInjector.sendKeyEvent(event);
     }
 }