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;
 import android.content.DialogInterface;
 import android.content.SharedPreferences;
 import android.graphics.Bitmap;
 import android.graphics.Point;
 import android.os.Looper;
 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.View;
 import android.widget.CheckBox;
 import android.widget.TextView;
 import android.widget.Toast;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.chromoting.R;
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
 /**
  * Initializes the Chromium remoting library, and provides JNI calls into it.
  * All interaction with the native code is centralized in this class.
  */
 @JNINamespace("remoting")
 public class JniInterface {
-    /** The status code indicating successful connection. */
-    private static final int SUCCESSFUL_CONNECTION = 3;
-
     /*
      * 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 {
+        /**
+         * These values must match the C++ enumeration remoting::protocol::ConnectionToHost::State.
+         */
+        int STATE_INITIALIZING = 0;

[Sergey Ulanov, 2014/01/08 20:30:45]

Can we use Java enums here? In the past it was recommended to avoid enums in
Android code because Dalvik wasn't good at handling them. AFAICT it's not the
case anymore. Neither perf tips nor style guide mention it (see
http://developer.android.com/training/articles/perf-tips.html and
http://source.android.com/source/code-style.html).

[Lambros, 2014/01/08 22:30:01]

Done.

+        int STATE_CONNECTING = 1;
+        int STATE_AUTHENTICATED = 2;
+        int STATE_CONNECTED = 3;
+        int STATE_FAILED = 4;
+        int STATE_CLOSED = 5;
+
+        /**
+         * These values must match the C++ enumeration remoting::protocol::ErrorCode.
+         */
+        int ERROR_OK = 0;
+        int ERROR_PEER_IS_OFFLINE = 1;
+        int ERROR_SESSION_REJECTED = 2;
+        int ERROR_INCOMPATIBLE_PROTOCOL = 3;
+        int ERROR_AUTHENTICATION_FAILED = 4;
+        int ERROR_CHANNEL_CONNECTION_ERROR = 5;
+        int ERROR_SIGNALING_ERROR = 6;
+        int ERROR_SIGNALING_TIMEOUT = 7;
+        int ERROR_HOST_OVERLOAD = 8;
+        int ERROR_UNKNOWN_ERROR = 9;
+
+        /**
+         * Notified on connection state change.
+         * @param state The new connection state.
+         * @param error The error code, if state is STATE_FAILED.
+         */
+        void onConnectionState(int state, int error);
+    }
+
     /*
      * 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;
-
-    /** 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();
+    /** Notified upon successful connection or disconnection. Accessed on the UI thread. */
+    private static ConnectionListener sConnectionListener = null;
 
     /**
      * Callback invoked on the graphics thread to repaint the desktop. Accessed on the UI and
      * graphics threads.
      */
     private static Runnable sRedrawCallback = null;
 
     /** Bitmap holding a copy of the latest video frame. Accessed on the UI and graphics threads. */
     private static Bitmap sFrameBitmap = null;
 
@@ skipping 27 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;
-            }
-        }
+        sConnectionListener.onConnectionState(ConnectionListener.STATE_CLOSED, 0);
 
         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.
-                            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();
-            } else {
-                Toast.makeText(sContext, sContext.getResources().getStringArray(
-                        R.array.protoc_states)[state] + (error == 0 ? "" : ": " +
-                        sContext.getResources().getStringArray(R.array.protoc_errors)[error]),
-                        Toast.LENGTH_LONG).show();
-            }
-        }
+        sConnectionListener.onConnectionState(state, error);
     }
 
     /** 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));
         pinPrompt.setIcon(android.R.drawable.ic_lock_lock);
 
@@ skipping 189 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; }
 }