Fix issues with NetworkMonitor singleton when used by multiple clients.

webrtc/sdk/android/api/org/webrtc/NetworkMonitor.java

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 52 matching lines @@
   /**
    * Returns the singleton instance.
    */
   public static NetworkMonitor getInstance() {
     if (instance == null) {
       instance = new NetworkMonitor();
     }
     return instance;
   }
 
-  /**
-   * Enables auto detection of the current network state based on notifications from the system.
-   * Note that passing true here requires the embedding app have the platform ACCESS_NETWORK_STATE
-   * permission.
-   *
-   * @param shouldAutoDetect true if the NetworkMonitor should listen for system changes in
-   *  network connectivity.
-   */
-  public static void setAutoDetectConnectivityState(boolean shouldAutoDetect) {
-    getInstance().setAutoDetectConnectivityStateInternal(shouldAutoDetect);
-  }

[Taylor Brandstetter, 2017/07/26 02:39:07]

This method is only called by tests, and *should* only ever be called by tests,
so I turned it into "createAutoDetectorForTest()".

-
   private static void assertIsTrue(boolean condition) {
     if (!condition) {
       throw new AssertionError("Expected to be true");
     }
   }
 
-  // Called by the native code.
+  /**
+   * Called by the native code.
+   *
+   * Enables auto detection of the current network state based on notifications
+   * from the system. Note that this requires the embedding app have the
+   * platform ACCESS_NETWORK_STATE permission.
+   */
   private void startMonitoring(long nativeObserver) {
     Logging.d(TAG, "Start monitoring from native observer " + nativeObserver);
     nativeNetworkObservers.add(nativeObserver);
-    setAutoDetectConnectivityStateInternal(true);
+    if (autoDetector == null) {
+      createAutoDetector();
+    }
+    // The observers expect a network list update after they call startMonitoring.
+    final NetworkMonitorAutoDetect.NetworkState networkState =
+        autoDetector.getCurrentNetworkState();
+    updateCurrentConnectionType(NetworkMonitorAutoDetect.getConnectionType(networkState));
+    updateObserverActiveNetworkList(nativeObserver);
   }
 
   // Called by the native code.
   private void stopMonitoring(long nativeObserver) {
     Logging.d(TAG, "Stop monitoring from native observer " + nativeObserver);
-    setAutoDetectConnectivityStateInternal(false);
     nativeNetworkObservers.remove(nativeObserver);
+    if (nativeNetworkObservers.isEmpty()) {
+      autoDetector.destroy();
+      autoDetector = null;
+    }
   }
 
   // Called by the native code to determine if network binding is supported
   // on this platform.
   private boolean networkBindingSupported() {
     return autoDetector != null && autoDetector.supportNetworkCallback();
   }
 
   // Called by the native code to get the Android SDK version.
   private static int androidSdkInt() {
     return Build.VERSION.SDK_INT;
   }
 
   private ConnectionType getCurrentConnectionType() {
     return currentConnectionType;
   }
 
   private long getCurrentDefaultNetId() {
     return autoDetector == null ? INVALID_NET_ID : autoDetector.getDefaultNetId();
   }
 
-  private void destroyAutoDetector() {
-    if (autoDetector != null) {
-      autoDetector.destroy();
-      autoDetector = null;
-    }
-  }
+  private void createAutoDetector() {
+    autoDetector = new NetworkMonitorAutoDetect(new NetworkMonitorAutoDetect.Observer() {
 
-  private void setAutoDetectConnectivityStateInternal(boolean shouldAutoDetect) {
-    if (!shouldAutoDetect) {
-      destroyAutoDetector();
-      return;
-    }
-    if (autoDetector == null) {
-      autoDetector = new NetworkMonitorAutoDetect(new NetworkMonitorAutoDetect.Observer() {
+      @Override
+      public void onConnectionTypeChanged(ConnectionType newConnectionType) {
+        updateCurrentConnectionType(newConnectionType);
+      }
 
-        @Override
-        public void onConnectionTypeChanged(ConnectionType newConnectionType) {
-          updateCurrentConnectionType(newConnectionType);
-        }
+      @Override
+      public void onNetworkConnect(NetworkInformation networkInfo) {
+        notifyObserversOfNetworkConnect(networkInfo);
+      }
 
-        @Override
-        public void onNetworkConnect(NetworkInformation networkInfo) {
-          notifyObserversOfNetworkConnect(networkInfo);
-        }
-
-        @Override
-        public void onNetworkDisconnect(long networkHandle) {
-          notifyObserversOfNetworkDisconnect(networkHandle);
-        }
-      }, ContextUtils.getApplicationContext());
-      final NetworkMonitorAutoDetect.NetworkState networkState =
-          autoDetector.getCurrentNetworkState();
-      updateCurrentConnectionType(NetworkMonitorAutoDetect.getConnectionType(networkState));
-      updateActiveNetworkList();
-    }
+      @Override
+      public void onNetworkDisconnect(long networkHandle) {
+        notifyObserversOfNetworkDisconnect(networkHandle);
+      }
+    }, ContextUtils.getApplicationContext());
   }
 
   private void updateCurrentConnectionType(ConnectionType newConnectionType) {
     currentConnectionType = newConnectionType;
     notifyObserversOfConnectionTypeChange(newConnectionType);
   }
 
   /**
    * Alerts all observers of a connection change.
    */
@@ skipping 11 matching lines @@
       nativeNotifyOfNetworkConnect(nativeObserver, networkInfo);
     }
   }
 
   private void notifyObserversOfNetworkDisconnect(long networkHandle) {
     for (long nativeObserver : nativeNetworkObservers) {
       nativeNotifyOfNetworkDisconnect(nativeObserver, networkHandle);
     }
   }
 
-  private void updateActiveNetworkList() {
+  private void updateObserverActiveNetworkList(long nativeObserver) {
     List<NetworkInformation> networkInfoList = autoDetector.getActiveNetworkList();
     if (networkInfoList == null || networkInfoList.size() == 0) {
       return;
     }
 
     NetworkInformation[] networkInfos = new NetworkInformation[networkInfoList.size()];
     networkInfos = networkInfoList.toArray(networkInfos);
-    for (long nativeObserver : nativeNetworkObservers) {
-      nativeNotifyOfActiveNetworkList(nativeObserver, networkInfos);
-    }
+    nativeNotifyOfActiveNetworkList(nativeObserver, networkInfos);
   }
 
   /**
    * Adds an observer for any connection type changes.
    */
   public static void addNetworkObserver(NetworkObserver observer) {
     getInstance().addNetworkObserverInternal(observer);
   }
 
   private void addNetworkObserverInternal(NetworkObserver observer) {
@@ skipping 24 matching lines @@
   private native void nativeNotifyOfNetworkDisconnect(long nativePtr, long networkHandle);
   private native void nativeNotifyOfActiveNetworkList(
       long nativePtr, NetworkInformation[] networkInfos);
 
   // For testing only.
   static void resetInstanceForTests() {
     instance = new NetworkMonitor();
   }
 
   // For testing only.
-  public static NetworkMonitorAutoDetect getAutoDetectorForTest() {
+  static void createAutoDetectorForTest() {
+    getInstance().createAutoDetector();
+  }
+
+  // For testing only.
+  static NetworkMonitorAutoDetect getAutoDetectorForTest() {
     return getInstance().autoDetector;
   }
 }