Android Chromoting - Close the Desktop view on disconnection

remoting/android/java/src/org/chromium/chromoting/jni/JniInterface.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.jni;
 
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.ProgressDialog;
 import android.content.Context;
@@ skipping 27 matching lines @@
 
     /*
      * Library-loading state machine.
      */
     /** Whether the library has been loaded. Accessed on the UI thread. */
     private static boolean sLoaded = false;
 
     /** The application context. Accessed on the UI thread. */
     private static Activity sContext = null;
 
+    /** Interface used for connection state notifications. */
+    public interface ConnectionListener {
+        /** Notified on successful connection. */
+        void onConnected();
+
+        /**
+         * Notified when the connection is disconnected due to host or network error. This is not
+         * called if disconnection is initiated by the client.
+         */
+        void onDisconnected();

[Sergey Ulanov, 2013/12/28 02:51:49]

I think it's not enough to have just these two methods. At very least we want to
pass an error code the the UI layer. I think it's better to replace it with a
single method OnStateChanged(state, error), so that the listener is notified
about all connection state changes.

[Lambros, 2013/12/31 00:05:05]

Done.

+    }
+
     /*
      * Connection-initiating state machine.
      */
     /** Whether the native code is attempting a connection. Accessed on the UI thread. */
     private static boolean sConnected = false;
 
-    /** Callback to signal upon successful connection. Accessed on the UI thread. */
-    private static Runnable sSuccessCallback = null;
+    /** Notified upon successful connection or disconnection. Accessed on the UI thread. */
+    private static ConnectionListener sConnectionListener = null;
 
     /** Dialog for reporting connection progress. Accessed on the UI thread. */
     private static ProgressDialog sProgressIndicator = null;
 
     // Protects access to |sProgressIndicator|. Used only to silence FindBugs warnings - the
     // variable it protects is only accessed on a single thread.
     // TODO(lambroslambrou): Refactor the ProgressIndicator into a separate class.
     private static Object sProgressIndicatorLock = new Object();
 
     /**
@@ skipping 35 matching lines @@
 
     /*
      * API/OAuth2 keys access.
      */
     public static native String nativeGetApiKey();
     public static native String nativeGetClientId();
     public static native String nativeGetClientSecret();
 
     /** Attempts to form a connection to the user-selected host. Called on the UI thread. */
     public static void connectToHost(String username, String authToken,
-            String hostJid, String hostId, String hostPubkey, Runnable successCallback) {
+            String hostJid, String hostId, String hostPubkey, ConnectionListener listener) {
         disconnectFromHost();
 
-        sSuccessCallback = successCallback;
+        sConnectionListener = listener;
         SharedPreferences prefs = sContext.getPreferences(Activity.MODE_PRIVATE);
         nativeConnect(username, authToken, hostJid, hostId, hostPubkey,
                 prefs.getString(hostId + "_id", ""), prefs.getString(hostId + "_secret", ""));
         sConnected = true;
     }
 
     /** Performs the native portion of the connection. */
     private static native void nativeConnect(String username, String authToken, String hostJid,
             String hostId, String hostPubkey, String pairId, String pairSecret);
 
     /** Severs the connection and cleans up. Called on the UI thread. */
     public static void disconnectFromHost() {
         if (!sConnected) return;
 
         synchronized (sProgressIndicatorLock) {
             if (sProgressIndicator != null) {
                 sProgressIndicator.dismiss();
                 sProgressIndicator = null;
             }
         }
 
         nativeDisconnect();
-        sSuccessCallback = null;
+        sConnectionListener = null;
         sConnected = false;
 
         // Drop the reference to free the Bitmap for GC.
         synchronized (sFrameLock) {
             sFrameBitmap = null;
         }
     }
 
     /** Performs the native portion of the cleanup. */
     private static native void nativeDisconnect();
 
     /** Reports whenever the connection status changes. Called on the UI thread. */
     @CalledByNative
     private static void reportConnectionStatus(int state, int error) {
         if (state < SUCCESSFUL_CONNECTION && error == 0) {
             // The connection is still being established, so we'll report the current progress.
             synchronized (sProgressIndicatorLock) {
                 if (sProgressIndicator == null) {
                     sProgressIndicator = ProgressDialog.show(sContext, sContext.

[Sergey Ulanov, 2013/12/28 02:51:49]

It's not right that the JNI layer handles UI. I think we want to pass state to
the ConnectionListener and then handle the state there.

[Lambros, 2013/12/31 00:05:05]

Done.

                             getString(R.string.progress_title), sContext.getResources().
                             getStringArray(R.array.protoc_states)[state], true, true,
                             new DialogInterface.OnCancelListener() {
                                 @Override
                                 public void onCancel(DialogInterface dialog) {
                                     Log.i("jniiface", "User canceled connection initiation");
                                     disconnectFromHost();
                                 }
                             });
                 } else {
                     sProgressIndicator.setMessage(
                             sContext.getResources().getStringArray(R.array.protoc_states)[state]);
                 }
             }
         } else {
             // The connection is complete or has failed, so we can lose the progress indicator.
             synchronized (sProgressIndicatorLock) {
                 if (sProgressIndicator != null) {
                     sProgressIndicator.dismiss();
                     sProgressIndicator = null;
                 }
             }
 
             if (state == SUCCESSFUL_CONNECTION) {
                 Toast.makeText(sContext, sContext.getResources().
                         getStringArray(R.array.protoc_states)[state], Toast.LENGTH_SHORT).show();
 
                 // Actually display the remote desktop.
-                sSuccessCallback.run();
+                sConnectionListener.onConnected();
             } else {
                 Toast.makeText(sContext, sContext.getResources().getStringArray(

[Sergey Ulanov, 2013/12/28 02:51:49]

Same here. JNI layer shouldn't handle UI. Let's move it out of here.

[Lambros, 2013/12/31 00:05:05]

Done.

                         R.array.protoc_states)[state] + (error == 0 ? "" : ": " +
                         sContext.getResources().getStringArray(R.array.protoc_errors)[error]),
                         Toast.LENGTH_LONG).show();
+                sConnectionListener.onDisconnected();
             }
         }
     }
 
     /** Prompts the user to enter a PIN. Called on the UI thread. */
     @CalledByNative
     private static void displayAuthenticationPrompt(boolean pairingSupported) {
         AlertDialog.Builder pinPrompt = new AlertDialog.Builder(sContext);
         pinPrompt.setTitle(sContext.getString(R.string.pin_entry_title));
         pinPrompt.setMessage(sContext.getString(R.string.pin_entry_message));
@@ skipping 191 matching lines @@
         buffer.asIntBuffer().get(data, 0, data.length);
         sCursorBitmap = Bitmap.createBitmap(data, width, height, Bitmap.Config.ARGB_8888);
     }
 
     /** Position of cursor hotspot within cursor image. Called on the graphics thread. */
     public static Point getCursorHotspot() { return sCursorHotspot; }
 
     /** Returns the current cursor shape. Called on the graphics thread. */
     public static Bitmap getCursorBitmap() { return sCursorBitmap; }
 }