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

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

Index: talk/app/webrtc/java/android/org/webrtc/NetworkMonitorAutoDetect.java
diff --git a/talk/app/webrtc/java/android/org/webrtc/NetworkMonitorAutoDetect.java b/talk/app/webrtc/java/android/org/webrtc/NetworkMonitorAutoDetect.java
index 950dcdfa445a25ce6ecae9c7055045692703546d..1cdd0b091105872bb7f468a505b77c3fe07bbf89 100644
--- a/talk/app/webrtc/java/android/org/webrtc/NetworkMonitorAutoDetect.java
+++ b/talk/app/webrtc/java/android/org/webrtc/NetworkMonitorAutoDetect.java
@@ -37,9 +37,13 @@ import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.net.ConnectivityManager;
+import android.net.ConnectivityManager.NetworkCallback;
+import android.net.LinkAddress;
+import android.net.LinkProperties;
 import android.net.Network;
 import android.net.NetworkCapabilities;
 import android.net.NetworkInfo;
+import android.net.NetworkRequest;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.os.Build;
@@ -66,6 +70,28 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
     CONNECTION_NONE
   }
 
+  public static class IPAddress {
+    public byte[] address;
+    public IPAddress (byte[] address) {
+      this.address = address;
+    }
+  }
+
+  /** Java version of NetworkMonitor.NetworkInformation */
+  public static class NetworkInformation{
+    public String name;
+    public ConnectionType type;
+    public int handle;
+    public IPAddress[] ipAddresses;
+    public NetworkInformation(String name, ConnectionType type, int handle,
+                              IPAddress[] addresses) {
+      this.name = name;
+      this.type = type;
+      this.handle = handle;
+      this.ipAddresses = addresses;
+    }
+  };
+
   static class NetworkState {
     private final boolean connected;
     // Defined from ConnectivityManager.TYPE_XXX for non-mobile; for mobile, it is
@@ -101,6 +127,7 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
      *  gracefully below.
      */
     private final ConnectivityManager connectivityManager;
+    private NetworkCallback networkCallback;
 
     ConnectivityManagerDelegate(Context context) {
       connectivityManager =
@@ -211,30 +238,77 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
           connectivityManager.getNetworkCapabilities(network);
       return capabilities != null && capabilities.hasCapability(NET_CAPABILITY_INTERNET);
     }
+
+    @SuppressLint("NewApi")
+    public void requestMobileNetwork(final Observer observer) {
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP ||
+          connectivityManager == null) {
+        return;
+      }
+      networkCallback = new NetworkCallback() {
+        @Override
+        public void onAvailable(Network network) {
+          super.onAvailable(network);
+          LinkProperties linkProperties = connectivityManager.getLinkProperties(network);
+          NetworkInformation networkInformation = new NetworkInformation(
+            linkProperties.getInterfaceName(),
+            getConnectionType(getNetworkState(network)),
+            networkToNetId(network),
+            getIPAddresses(linkProperties));
+          Log.i(TAG, "Cellular network " + networkInformation.name + " is connected ");
+          observer.onNetworkConnect(networkInformation);
+        }
+
+        @Override
+        public void onCapabilitiesChanged(Network network, NetworkCapabilities capabilities) {
+          super.onCapabilitiesChanged(network, capabilities);
+        }
+        @Override
+        public void onLinkPropertiesChanged(Network network, LinkProperties properties) {
+          super.onLinkPropertiesChanged(network, properties);
+        }

[pthatcher1, 2016/01/14 20:07:24]

Is it necessary to override these last two?  Doesn't the default call the
superclass?

[honghaiz3, 2016/01/15 01:00:38]

Done.

+      };
+      Log.i(TAG, "Requesting cellular network");
+      NetworkRequest.Builder builder = new NetworkRequest.Builder();
+      builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
+      builder.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);
+      connectivityManager.requestNetwork(builder.build(), networkCallback);
+    }
+
+    @SuppressLint("NewApi")
+    IPAddress[] getIPAddresses(LinkProperties linkProperties) {
+      LinkAddress[] linkAddresses =
+          new LinkAddress[linkProperties.getLinkAddresses().size()];
+      linkProperties.getLinkAddresses().toArray(linkAddresses);
+      IPAddress[] ipAddresses = new IPAddress[linkAddresses.length];
+      for (int i = 0; i < linkAddresses.length; ++i) {
+        ipAddresses[i] = new IPAddress(linkAddresses[i].getAddress().getAddress());
+      }
+      return ipAddresses;
+    }
+
+    @SuppressLint("NewApi")
+    public void releaseCallback() {
+      if (networkCallback != null) {
+        connectivityManager.unregisterNetworkCallback(networkCallback);
+        networkCallback = null;
+      }
+    }
+
   }
 
+
   /** Queries the WifiManager for SSID of the current Wifi connection. */
   static class WifiManagerDelegate {
     private final Context context;
-    private final WifiManager wifiManager;
-    private final boolean hasWifiPermission;
-
     WifiManagerDelegate(Context context) {
       this.context = context;
-
-      hasWifiPermission = context.getPackageManager().checkPermission(
-          permission.ACCESS_WIFI_STATE, context.getPackageName())
-          == PackageManager.PERMISSION_GRANTED;
-      wifiManager = hasWifiPermission
-          ? (WifiManager) context.getSystemService(Context.WIFI_SERVICE) : null;

[pthatcher1, 2016/01/14 20:07:23]

Did this work before Lollipop?  Will Kitkat and previous be adversely affected
by removing this?

[honghaiz3, 2016/01/15 01:00:37]

Those are not really used before. There used to be some methods that need these
variables and objects but all those methods have been removed. 

     }
 
     // For testing.
     WifiManagerDelegate() {
       // All the methods below should be overridden.
       context = null;
-      wifiManager = null;
-      hasWifiPermission = false;
     }
 
     String getWifiSSID() {
@@ -252,9 +326,6 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
       return "";
     }
 
-    boolean getHasWifiPermission() {
-      return hasWifiPermission;
-    }
   }
 
   static final int INVALID_NET_ID = -1;
@@ -280,6 +351,7 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
      * Called when default network changes.
      */
     public void onConnectionTypeChanged(ConnectionType newConnectionType);
+    public void onNetworkConnect(NetworkInformation networkInfo);
   }
 
   /**
@@ -292,8 +364,8 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
     wifiManagerDelegate = new WifiManagerDelegate(context);
 
     final NetworkState networkState = connectivityManagerDelegate.getNetworkState();
-    connectionType = getCurrentConnectionType(networkState);
-    wifiSSID = getCurrentWifiSSID(networkState);
+    connectionType = getConnectionType(networkState);
+    wifiSSID = getWifiSSID(networkState);
     intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
     registerReceiver();
   }
@@ -331,6 +403,7 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
     if (!isRegistered) {
       isRegistered = true;
       context.registerReceiver(this, intentFilter);
+      connectivityManagerDelegate.requestMobileNetwork(observer);
     }
   }
 
@@ -341,6 +414,7 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
     if (isRegistered) {
       isRegistered = false;
       context.unregisterReceiver(this);
+      connectivityManagerDelegate.releaseCallback();
     }
   }
 
@@ -361,7 +435,7 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
     return connectivityManagerDelegate.getDefaultNetId();
   }
 
-  public ConnectionType getCurrentConnectionType(NetworkState networkState) {
+  public static ConnectionType getConnectionType(NetworkState networkState) {
     if (!networkState.isConnected()) {
       return ConnectionType.CONNECTION_NONE;
     }
@@ -404,8 +478,8 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
     }
   }
 
-  private String getCurrentWifiSSID(NetworkState networkState) {
-    if (getCurrentConnectionType(networkState) != ConnectionType.CONNECTION_WIFI) return "";
+  private String getWifiSSID(NetworkState networkState) {
+    if (getConnectionType(networkState) != ConnectionType.CONNECTION_WIFI) return "";
     return wifiManagerDelegate.getWifiSSID();
   }
 
@@ -419,8 +493,8 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
   }
 
   private void connectionTypeChanged(NetworkState networkState) {
-    ConnectionType newConnectionType = getCurrentConnectionType(networkState);
-    String newWifiSSID = getCurrentWifiSSID(networkState);
+    ConnectionType newConnectionType = getConnectionType(networkState);
+    String newWifiSSID = getWifiSSID(networkState);
     if (newConnectionType == connectionType && newWifiSSID.equals(wifiSSID)) return;
 
     connectionType = newConnectionType;