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

remoting/android/java/src/org/chromium/chromoting/Desktop.java

Index: remoting/android/java/src/org/chromium/chromoting/Desktop.java
diff --git a/remoting/android/java/src/org/chromium/chromoting/Desktop.java b/remoting/android/java/src/org/chromium/chromoting/Desktop.java
index 887d16b9c9de48c2bec201aa7d6c6d6b2c264c88..e32fff2cd9417ca99b6c5875c390c943cc0c827f 100644
--- a/remoting/android/java/src/org/chromium/chromoting/Desktop.java
+++ b/remoting/android/java/src/org/chromium/chromoting/Desktop.java
@@ -31,7 +31,7 @@ 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;
@@ -69,6 +69,8 @@ public class Desktop
     /** 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>();
 
@@ -99,11 +101,14 @@ public class Desktop
         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);
@@ -121,7 +126,7 @@ public class Desktop
         View decorView = getWindow().getDecorView();
         decorView.setOnSystemUiVisibilityChangeListener(this);
 
-        mActivityLifecycleListener = CapabilityManager.getInstance().onActivityAcceptingListener(
+        mActivityLifecycleListener = mClient.getCapabilityManager().onActivityAcceptingListener(
                 this, Capabilities.CAST_CAPABILITY);
         mActivityLifecycleListener.onActivityCreated(this, savedInstanceState);
 
@@ -160,9 +165,9 @@ public class Desktop
     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
@@ -170,7 +175,7 @@ public class Desktop
         if (isFinishing()) mActivityLifecycleListener.onActivityPaused(this);
         super.onPause();
         if (!mSwitchToCardboardDesktopActivity) {
-            JniInterface.enableVideoChannel(false);
+            mClient.enableVideoChannel(false);
         }
         stopActionBarAutoHideTimer();
     }
@@ -179,19 +184,19 @@ public class Desktop
     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);
         }
     }
 
@@ -478,7 +483,7 @@ public class Desktop
             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) {
@@ -488,10 +493,10 @@ public class Desktop
                 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;
         }
@@ -584,7 +589,7 @@ public class Desktop
 
         // Dispatch the back button to the system to handle navigation
         if (keyCode == KeyEvent.KEYCODE_BACK) {
-            JniInterface.disconnectFromHost();
+            mClient.destroy();
             return super.dispatchKeyEvent(event);
         }
 
@@ -596,7 +601,7 @@ public class Desktop
         // 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
@@ -607,7 +612,7 @@ public class Desktop
         // 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;
         }
 
@@ -621,7 +626,7 @@ public class Desktop
         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;
         }
 
@@ -636,28 +641,28 @@ public class Desktop
             // 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);
         }
     }
 }