Refactor Chromoting JNI code to use jni/Client (Java changes only).

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.app.AlertDialog;
 import android.content.DialogInterface;
 import android.content.Intent;
@@ skipping 13 matching lines @@
 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;
 import org.chromium.chromoting.help.HelpContext;
 import org.chromium.chromoting.help.HelpSingleton;
-import org.chromium.chromoting.jni.JniInterface;
+import org.chromium.chromoting.jni.Client;
 
 import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;
 
 /**
  * A simple screen that does nothing except display a DesktopView and notify it of rotations.
  */
 public class Desktop
         extends AppCompatActivity implements View.OnSystemUiVisibilityChangeListener,
@@ skipping 17 matching lines @@
 
     /** 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 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;
 
     /** Indicates whether a Soft Input UI (such as a keyboard) is visible. */
     private boolean mSoftInputVisible = false;
@@ skipping 10 matching lines @@
     /** Indicates whether the remote host supports touch injection. */
     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.getClient();

[Sergey Ulanov, 2016/01/30 01:03:23]

Is it possible to pass the Client object from the Chromoting activity here
instead of calling Client.getClient()?

This would not work if we wanted to support multiple concurrent connections.

[Lambros, 2016/02/03 22:57:43]

This is the reason we need the singleton in the first place! Activities cannot
directly pass Java objects to other Activities. You're meant to
serialize/deserialize and communicate via Intents. However, we abuse the fact
that Android hosts the activities in the same VM instance, and use the global
singleton to "cheat". (A similar scheme is used to pass the screenshot bitmap to
the HelpActivity)

For multiple connections, we'd probably have a global mapping of ID->Client, and
pass the string ID to the new Desktop activity via an Intent. So this onCreate()
method would become something like:
Intent intent = getIntent();
String id = ... extract ID from intent ...
mClient = Client.getForId(id);

[Sergey Ulanov, 2016/02/08 22:05:16]

I see. I think the right way to fix this would be to create Desktop activity as
soon as user taps on a host and make the Desktop activity responsible for
connecting the client.

[Lambros, 2016/02/08 23:48:51]

That would work for the initial connection, but Android can restart the Desktop
activity (for example, when rotating the device or connecting a BT keyboard), so
you'd have to recreate the connection somehow. An Activity gets a chance to
save/restore its state, but I think [de]serialization is still required.

+
         mToolbar = (Toolbar) findViewById(R.id.toolbar);
         setSupportActionBar(mToolbar);
 
         mRemoteHostDesktop = (DesktopView) findViewById(R.id.desktop_view);
         mRemoteHostDesktop.setDesktop(this);
+        mRemoteHostDesktop.setClient(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
         // function below will set our preferred system UI flags which will adjust the layout
         // size of the canvas and we can avoid an initial resize event.
         showActionBar();
 
         View decorView = getWindow().getDecorView();
         decorView.setOnSystemUiVisibilityChangeListener(this);
 
-        mActivityLifecycleListener = CapabilityManager.getInstance().onActivityAcceptingListener(
+        mActivityLifecycleListener = mClient.getCapabilityManager().onActivityAcceptingListener(
                 this, Capabilities.CAST_CAPABILITY);
         mActivityLifecycleListener.onActivityCreated(this, savedInstanceState);
 
         mInputMode = getInitialInputModeValue();
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
             attachKeyboardVisibilityListener();
 
             // Only create an Autohide task if the system supports immersive fullscreen mode.  Older
             // versions of the OS benefit less from this functionality and we don't want to change
@@ skipping 18 matching lines @@
             });
         } else {
             mRemoteHostDesktop.setFitsSystemWindows(true);
         }
     }
 
     @Override
     protected void onStart() {
         super.onStart();
         mActivityLifecycleListener.onActivityStarted(this);
-        JniInterface.enableVideoChannel(true);
+        mClient.enableVideoChannel(true);
         mRemoteHostDesktop.attachRedrawCallback();
-        CapabilityManager.getInstance().addListener(this);
+        mClient.getCapabilityManager().addListener(this);
     }
 
     @Override
     protected void onPause() {
         if (isFinishing()) mActivityLifecycleListener.onActivityPaused(this);
         super.onPause();
         if (!mSwitchToCardboardDesktopActivity) {
-            JniInterface.enableVideoChannel(false);
+            mClient.enableVideoChannel(false);
         }
         stopActionBarAutoHideTimer();
     }
 
     @Override
     public void onResume() {
         super.onResume();
         mActivityLifecycleListener.onActivityResumed(this);
-        JniInterface.enableVideoChannel(true);
+        mClient.enableVideoChannel(true);
         startActionBarAutoHideTimer();
     }
 
     @Override
     protected void onStop() {
-        CapabilityManager.getInstance().removeListener(this);
+        mClient.getCapabilityManager().removeListener(this);
         mActivityLifecycleListener.onActivityStopped(this);
         super.onStop();
         if (mSwitchToCardboardDesktopActivity) {
             mSwitchToCardboardDesktopActivity = false;
         } else {
-            JniInterface.enableVideoChannel(false);
+            mClient.enableVideoChannel(false);
         }
     }
 
     /** Called to initialize the action bar. */
     @Override
     public boolean onCreateOptionsMenu(Menu menu) {
         getMenuInflater().inflate(R.menu.desktop_actionbar, menu);
 
         mActivityLifecycleListener.onActivityCreatedOptionsMenu(this, menu);
 
@@ skipping 266 matching lines @@
         }
         if (id == R.id.actionbar_keyboard) {
             ((InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)).toggleSoftInput(0, 0);
             return true;
         }
         if (id == R.id.actionbar_hide) {
             hideActionBar();
             return true;
         }
         if (id == R.id.actionbar_disconnect || id == android.R.id.home) {
-            JniInterface.disconnectFromHost();
+            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) {
-                JniInterface.sendKeyEvent(0, key, true);
+                mClient.sendKeyEvent(0, key, true);
             }
             for (int key : keys) {
-                JniInterface.sendKeyEvent(0, key, false);
+                mClient.sendKeyEvent(0, key, false);
             }
             return true;
         }
         if (id == R.id.actionbar_help) {
             HelpSingleton.getInstance().launchHelp(this, HelpContext.DESKTOP);
             return true;
         }
         return super.onOptionsItemSelected(item);
     }
 
@@ skipping 72 matching lines @@
      * 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) {
-            JniInterface.disconnectFromHost();
+            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 JniInterface.sendKeyEvent(event.getScanCode(), 0, pressed);
+            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) {
-            JniInterface.sendTextEvent(event.getCharacters());
+            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 };
-            JniInterface.sendTextEvent(new String(codePoints, 0, 1));
+            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:
-                JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
-                JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_2, pressed);
+                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
+                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_2, pressed);
                 return true;
 
             case KeyEvent.KEYCODE_POUND:
-                JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
-                JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_3, pressed);
+                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
+                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_3, pressed);
                 return true;
 
             case KeyEvent.KEYCODE_STAR:
-                JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
-                JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_8, pressed);
+                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
+                mClient.sendKeyEvent(0, KeyEvent.KEYCODE_8, pressed);
                 return true;
 
             case KeyEvent.KEYCODE_PLUS:
-                JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
-                JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_EQUALS, pressed);
+                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 JniInterface.sendKeyEvent(0, keyCode, pressed);
+                return mClient.sendKeyEvent(0, keyCode, pressed);
         }
     }
 }