Bind a socket to a network if the network handle is set.

talk/app/webrtc/java/android/org/webrtc/NetworkMonitor.java

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 11 matching lines @@
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 package org.webrtc;
 
 import static org.webrtc.NetworkMonitorAutoDetect.ConnectionType;
 import static org.webrtc.NetworkMonitorAutoDetect.INVALID_NET_ID;
+import static org.webrtc.NetworkMonitorAutoDetect.NetworkInformation;
+
+import org.webrtc.Logging;
 
 import android.content.Context;
-import android.util.Log;
 
 import java.util.ArrayList;
 
 /**
  * Borrowed from Chromium's src/net/android/java/src/org/chromium/net/NetworkChangeNotifier.java
  *
  * Triggers updates to the underlying network state from OS networking events.
  *
  * WARNING: This class is not thread-safe.
  */
@@ skipping 65 matching lines @@
   }
 
   private static void assertIsTrue(boolean condition) {
     if (!condition) {
       throw new AssertionError("Expected to be true");
     }
   }
 
   // Called by the native code.
   private void startMonitoring(long nativeObserver) {
-    Log.d(TAG, "Start monitoring from native observer " + nativeObserver);
+    Logging.d(TAG, "Start monitoring from native observer " + nativeObserver);
     nativeNetworkObservers.add(nativeObserver);
     setAutoDetectConnectivityStateInternal(true);
   }
 
   // Called by the native code.
   private void stopMonitoring(long nativeObserver) {
-    Log.d(TAG, "Stop monitoring from native observer " + nativeObserver);
+    Logging.d(TAG, "Stop monitoring from native observer " + nativeObserver);
     setAutoDetectConnectivityStateInternal(false);
     nativeNetworkObservers.remove(nativeObserver);
   }
 
   private ConnectionType getCurrentConnectionType() {
     return currentConnectionType;
   }
 
   private int getCurrentDefaultNetId() {
     return autoDetector == null ? INVALID_NET_ID : autoDetector.getDefaultNetId();
@@ skipping 11 matching lines @@
       destroyAutoDetector();
       return;
     }
     if (autoDetector == null) {
       autoDetector = new NetworkMonitorAutoDetect(
         new NetworkMonitorAutoDetect.Observer() {
           @Override
           public void onConnectionTypeChanged(ConnectionType newConnectionType) {
             updateCurrentConnectionType(newConnectionType);
           }
+          @Override
+          public void onNetworkConnect(NetworkInformation networkInfo) {
+            updateNetworkInformation(networkInfo);
+          }
         },
         applicationContext);
       final NetworkMonitorAutoDetect.NetworkState networkState =
           autoDetector.getCurrentNetworkState();
-      updateCurrentConnectionType(autoDetector.getCurrentConnectionType(networkState));
+      updateCurrentConnectionType(autoDetector.getConnectionType(networkState));
     }
   }
 
   private void updateCurrentConnectionType(ConnectionType newConnectionType) {
     currentConnectionType = newConnectionType;
     notifyObserversOfConnectionTypeChange(newConnectionType);
   }
 
   /**
    * Alerts all observers of a connection change.
    */
   private void notifyObserversOfConnectionTypeChange(ConnectionType newConnectionType) {
     for (long nativeObserver : nativeNetworkObservers) {
       nativeNotifyConnectionTypeChanged(nativeObserver);
     }
     for (NetworkObserver observer : networkObservers) {
       observer.onConnectionTypeChanged(newConnectionType);
     }
   }
 
+  private void updateNetworkInformation(NetworkInformation networkInfo) {
+    for (long nativeObserver : nativeNetworkObservers) {
+      nativeNotifyOfNetworkConnect(nativeObserver, networkInfo);
+    }
+  }
+
   /**
    * Adds an observer for any connection type changes.
    */
   public static void addNetworkObserver(NetworkObserver observer) {
     getInstance().addNetworkObserverInternal(observer);
   }
 
   private void addNetworkObserverInternal(NetworkObserver observer) {
     networkObservers.add(observer);
   }
@@ skipping 15 matching lines @@
   public static boolean isOnline() {
     ConnectionType connectionType = getInstance().getCurrentConnectionType();
     return connectionType != ConnectionType.CONNECTION_UNKNOWN
         && connectionType != ConnectionType.CONNECTION_NONE;
   }
 
   private native long nativeCreateNetworkMonitor();
 
   private native void nativeNotifyConnectionTypeChanged(long nativePtr);
 
+  private native void nativeNotifyOfNetworkConnect(long nativePtr, NetworkInformation networkInfo);
+
   // For testing only.
   static void resetInstanceForTests(Context context) {
     instance = new NetworkMonitor(context);
   }
 
   // For testing only.
   public static NetworkMonitorAutoDetect getAutoDetectorForTest() {
     return getInstance().autoDetector;
   }
 }