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

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

 // Copyright 2014 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;
 
 import android.app.Activity;
 import android.text.TextUtils;
 
 import org.chromium.base.Log;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 /**
  * A manager for the capabilities of the Android client. Based on the negotiated set of
  * capabilities, it creates the associated ClientExtensions, and enables their communication with
  * the Chromoting host by dispatching extension messages appropriately.
  *
  * The CapabilityManager mirrors how the Chromoting host handles extension messages. For each
  * incoming extension message, runs through a list of HostExtensionSession objects, giving each one
  * a chance to handle the message.
+ *
+ * The CapabilityManager is a singleton class so we can manage client extensions on an application
+ * level. The singleton object may be used from multiple Activities, thus allowing it to support
+ * different capabilities at different stages of the application.
  */
 public class CapabilityManager {
     /** Used to allow objects to receive notifications when the host capabilites are received. */
     public interface CapabilitiesChangedListener {
         void onCapabilitiesChanged(List<String> newCapabilities);
     }
 
     /** Tracks whether the remote host supports a capability. */
     public enum HostCapability {
         UNKNOWN,
         SUPPORTED,
         UNSUPPORTED;
 
         public boolean isSet() {
             return this != UNKNOWN;
         }
 
         public boolean isSupported() {
             assert isSet();
             return this == SUPPORTED;
         }
     }
 
     private static final String TAG = "Chromoting";
 
+    /** Lazily-initialized singleton object that can be used from different Activities. */
+    private static CapabilityManager sInstance;
+
+    /** Protects access to |sInstance|. */
+    private static final Object sInstanceLock = new Object();
+
     /** List of all capabilities that are supported by the application. */
     private List<String> mLocalCapabilities;
 
     /** List of negotiated capabilities received from the host. */
     private List<String> mNegotiatedCapabilities;
 
     /** List of extensions to the client based on capabilities negotiated with the host. */
     private List<ClientExtension> mClientExtensions;
 
     /** Maintains a list of listeners to notify when host capabilities are received. */
     private List<CapabilitiesChangedListener> mCapabilitiesChangedListeners;
 
-    public CapabilityManager() {
+    private CapabilityManager() {
         mLocalCapabilities = new ArrayList<String>();
         mClientExtensions = new ArrayList<ClientExtension>();
 
         mLocalCapabilities.add(Capabilities.CAST_CAPABILITY);
         mLocalCapabilities.add(Capabilities.TOUCH_CAPABILITY);
 
         mCapabilitiesChangedListeners = new ArrayList<CapabilitiesChangedListener>();
     }
 
     /**
+     * Returns the singleton object. Thread-safe.
+     */
+    public static CapabilityManager getInstance() {
+        synchronized (sInstanceLock) {
+            if (sInstance == null) {
+                sInstance = new CapabilityManager();
+            }
+            return sInstance;
+        }
+    }
+
+    /**
      * Cleans up host specific state when the connection has been terminated.
      */
     public void onHostDisconnect() {
         mNegotiatedCapabilities = null;
     }
 
     /**
      * Returns a space-separated list (required by host) of the capabilities supported by
      * this client.
      */
@@ skipping 110 matching lines @@
             return new DummyClientExtension();
         } catch (InstantiationException e) {
             Log.w(TAG, "Failed to create CastExtensionHandler.");
             return new DummyClientExtension();
         } catch (IllegalAccessException e) {
             Log.w(TAG, "Failed to create CastExtensionHandler.");
             return new DummyClientExtension();
         }
     }
 }