[Remoting Android] Make JniClient own JniDisplayHandler

remoting/android/java/src/org/chromium/chromoting/jni/Client.java

 // Copyright 2015 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 org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.chromoting.CapabilityManager;
 import org.chromium.chromoting.InputStub;
 import org.chromium.chromoting.SessionAuthenticator;
 
 /**
  * Class to manage a client connection to the host. This class controls the lifetime of the
  * corresponding C++ object which implements the connection. A new object should be created for
  * each connection to the host, so that notifications from a connection are always sent to the
  * right object.
  * This class is used entirely on the UI thread.
  */
 @JNINamespace("remoting")
 public class Client implements InputStub {
     // Pointer to the C++ object, cast to a |long|.
     private long mNativeJniClient;
 
-    // Reference has to be kept until the lifecycle of Client ends. Code are currently using
-    // getDisplay() without doing a null check.
-    private Display mDisplay;
+    // Implementation-dependent display object used by the desktop view.
+    private Object mDisplay;
 
     // The global Client instance (may be null). This needs to be a global singleton so that the
     // Client can be passed between Activities.
     private static Client sClient;
 
     public Client() {
         if (sClient != null) {
             throw new RuntimeException("Client instance already created.");
         }
 
         sClient = this;
         mNativeJniClient = nativeInit();
     }
 
     /**
-     * Returns the display object. It will be null before calling connectToHost() but won't be null
-     *          after calling disconnectFromHost().
+     * Sets the display object. Called by the native code when the connection starts.
+     * @param display the implementation-dependent object used by the desktop view.
+     */
+    @CalledByNative
+    private void setDisplay(Object display) {
+        mDisplay = display;
+    }
+
+    /**
+     * Returns the display object. It will be null before calling connectToHost() or after calling
+     * disconnectFromHost().
      * @return the display object.
      */
-    public Display getDisplay() {
+    public Object getDisplay() {
         return mDisplay;
     }
 
     // Suppress FindBugs warning, since |sClient| is only used on the UI thread.
     @SuppressFBWarnings("LI_LAZY_INIT_STATIC")
     public void destroy() {
         if (sClient != null) {
             disconnectFromHost();
             nativeDestroy(mNativeJniClient);
             sClient = null;
@@ skipping 27 matching lines @@
     }
 
     /** Attempts to form a connection to the user-selected host. */
     public void connectToHost(String username, String authToken, String hostJid,
             String hostId, String hostPubkey, SessionAuthenticator authenticator, String flags,
             ConnectionListener listener) {
         disconnectFromHost();
 
         mConnectionListener = listener;
         mAuthenticator = authenticator;
-        mDisplay = new Display();
-        nativeConnect(mNativeJniClient, mDisplay.getNativePointer(), username, authToken, hostJid,
+        nativeConnect(mNativeJniClient, username, authToken, hostJid,
                 hostId, hostPubkey, mAuthenticator.getPairingId(hostId),
                 mAuthenticator.getPairingSecret(hostId), mCapabilityManager.getLocalCapabilities(),
                 flags);
         mConnected = true;
     }
 
     /** Severs the connection and cleans up. */
     public void disconnectFromHost() {
         if (!mConnected) {
             return;
         }
 
         mConnectionListener.onConnectionState(
                 ConnectionListener.State.CLOSED, ConnectionListener.Error.OK);
 
         disconnectFromHostWithoutNotification();
     }
 
     /** Same as disconnectFromHost() but without notifying the ConnectionListener. */
     private void disconnectFromHostWithoutNotification() {
         if (!mConnected) {
             return;
         }
 
         nativeDisconnect(mNativeJniClient);
         mConnectionListener = null;
         mConnected = false;
         mCapabilityManager.onHostDisconnect();
 
-        mDisplay.destroy();
+        mDisplay = null;
     }
 
     /** Called whenever the connection status changes. */
     @CalledByNative
     void onConnectionState(int stateCode, int errorCode) {
         ConnectionListener.State state = ConnectionListener.State.fromValue(stateCode);
         ConnectionListener.Error error = ConnectionListener.Error.fromValue(errorCode);
         mConnectionListener.onConnectionState(state, error);
         if (state == ConnectionListener.State.FAILED || state == ConnectionListener.State.CLOSED) {
             // Disconnect from the host here, otherwise the next time connectToHost() is called,
@@ skipping 151 matching lines @@
         }
 
         nativeSendExtensionMessage(mNativeJniClient, type, data);
     }
 
     private native long nativeInit();
 
     private native void nativeDestroy(long nativeJniClient);
 
     /** Performs the native portion of the connection. */
-    private native void nativeConnect(long nativeJniClient, long nativeJniDisplayHandler,
+    private native void nativeConnect(long nativeJniClient,
             String username, String authToken, String hostJid, String hostId, String hostPubkey,
             String pairId, String pairSecret, String capabilities, String flags);
 
     /** Native implementation of Client.handleAuthenticationResponse(). */
     private native void nativeAuthenticationResponse(
             long nativeJniClient, String pin, boolean createPair, String deviceName);
 
     /** Performs the native portion of the cleanup. */
     private native void nativeDisconnect(long nativeJniClient);
 
@@ skipping 18 matching lines @@
     /** Passes touch event information to the native handling code. */
     private native void nativeSendTouchEvent(
             long nativeJniClient, int eventType, TouchEventData[] data);
 
     /** Native implementation of Client.enableVideoChannel() */
     private native void nativeEnableVideoChannel(long nativeJniClient, boolean enable);
 
     /** Passes extension message to the native code. */
     private native void nativeSendExtensionMessage(long nativeJniClient, String type, String data);
 }