[Remoting Android] Placeholder for DesktopView

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 android.content.Context;
+
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.annotations.SuppressFBWarnings;
+import org.chromium.chromoting.AbstractDesktopView;
 import org.chromium.chromoting.CapabilityManager;
+import org.chromium.chromoting.DesktopViewFactory;
 import org.chromium.chromoting.InputStub;
+import org.chromium.chromoting.Preconditions;
 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;
 
-    // Implementation-dependent display object used by the desktop view.
-    private Object mDisplay;
+    // The factory to create implementation-dependent desktop view.
+    private DesktopViewFactory mDesktopViewFactory;
 
     // 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();
     }
 
     /**
-     * Sets the display object. Called by the native code when the connection starts.
-     * @param display the implementation-dependent object used by the desktop view.
+     * Sets the desktop view factory. Called by the native code when the connection starts.
+     * @param factory The factory to create implementation-dependent desktop view.
      */
     @CalledByNative
-    private void setDisplay(Object display) {
-        mDisplay = display;
+    private void setDesktopViewFactory(DesktopViewFactory factory) {

[Hzj_jie, 2016/07/10 19:23:59]

Do we really need to have a DesktopViewFactory? It seems DesktopView would only
be created once. So you may be able to have a
private void setDesktopView(AbstractDesktopView view)
instead of
private void setDesktopViewFactory(DesktopViewFactory factory)

Is my understanding correctly?

[Yuwei, 2016/07/11 00:17:09]

Activity will be destroyed and recreated when you rotate the screen, in which
case the view will be created for multiple times.

Also it needs an activity context when creating the view, which doesn't exist
when creating the Display.

+        mDesktopViewFactory = factory;
     }
 
     /**
-     * Returns the display object. It will be null before calling connectToHost() or after calling
-     * disconnectFromHost().
-     * @return the display object.
+     * Creates an implementation specific desktop view.
      */
-    public Object getDisplay() {
-        return mDisplay;
+    public AbstractDesktopView createDesktopView(Context context) {
+        Preconditions.notNull(mDesktopViewFactory);
+        return mDesktopViewFactory.createDesktopView(context);
     }
 
     // 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 55 matching lines @@
     /** Same as disconnectFromHost() but without notifying the ConnectionListener. */
     private void disconnectFromHostWithoutNotification() {
         if (!mConnected) {
             return;
         }
 
         nativeDisconnect(mNativeJniClient);
         mConnectionListener = null;
         mConnected = false;
         mCapabilityManager.onHostDisconnect();
-
-        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 190 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);
 }