Get the adapter type information from Android OS.

talk/app/webrtc/java/jni/androidnetworkmonitor_jni.cc

 /*
  * 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 53 matching lines @@
   if (enum_name == "CONNECTION_BLUETOOTH") {
     return NetworkType::NETWORK_BLUETOOTH;
   }
   if (enum_name == "CONNECTION_NONE") {
     return NetworkType::NETWORK_NONE;
   }
   ASSERT(false);
   return NetworkType::NETWORK_UNKNOWN;
 }
 
+static rtc::AdapterType AdapterTypeFromNetworkType(NetworkType network_type) {
+  switch (network_type) {
+    case NETWORK_UNKNOWN:
+      RTC_DCHECK(false) << "Unknown network type ";
+      return rtc::ADAPTER_TYPE_UNKNOWN;
+    case NETWORK_ETHERNET:
+      return rtc::ADAPTER_TYPE_ETHERNET;
+    case NETWORK_WIFI:
+      return rtc::ADAPTER_TYPE_WIFI;
+    case NETWORK_4G:
+    case NETWORK_3G:
+    case NETWORK_2G:
+      return rtc::ADAPTER_TYPE_CELLULAR;
+    case NETWORK_BLUETOOTH:
+      // There is no corresponding mapping for bluetooth networks.
+      // Map it to VPN for now.
+      return rtc::ADAPTER_TYPE_VPN;
+    default:
+      RTC_DCHECK(false) << "Invalid network type " << network_type;
+      return rtc::ADAPTER_TYPE_UNKNOWN;
+  }
+}
+
 static rtc::IPAddress GetIPAddressFromJava(JNIEnv* jni, jobject j_ip_address) {
   jclass j_ip_address_class = GetObjectClass(jni, j_ip_address);
   jfieldID j_address_id = GetFieldID(jni, j_ip_address_class, "address", "[B");
   jbyteArray j_addresses =
       static_cast<jbyteArray>(GetObjectField(jni, j_ip_address, j_address_id));
   size_t address_length = jni->GetArrayLength(j_addresses);
   jbyte* addr_array = jni->GetByteArrayElements(j_addresses, nullptr);
   CHECK_EXCEPTION(jni) << "Error during GetIPAddressFromJava";
   if (address_length == 4) {
     // IP4
@@ skipping 95 matching lines @@
   started_ = true;
 
   // This is kind of magic behavior, but doing this allows the SocketServer to
   // use this as a NetworkBinder to bind sockets on a particular network when
   // it creates sockets.
   worker_thread()->socketserver()->set_network_binder(this);
 
   jmethodID m =
       GetMethodID(jni(), *j_network_monitor_class_, "startMonitoring", "(J)V");
   jni()->CallVoidMethod(*j_network_monitor_, m, jlongFromPointer(this));
-  CHECK_EXCEPTION(jni()) << "Error during NetworkMonitor.startMonitoring";
+  CHECK_EXCEPTION(jni()) << "Error during CallVoidMethod";
 }
 
 void AndroidNetworkMonitor::Stop() {
   RTC_CHECK(thread_checker_.CalledOnValidThread());
   if (!started_) {
     return;
   }
   started_ = false;
 
   // Once the network monitor stops, it will clear all network information and
   // it won't find the network handle to bind anyway.
   if (worker_thread()->socketserver()->network_binder() == this) {
     worker_thread()->socketserver()->set_network_binder(nullptr);
   }
 
   jmethodID m =
       GetMethodID(jni(), *j_network_monitor_class_, "stopMonitoring", "(J)V");
   jni()->CallVoidMethod(*j_network_monitor_, m, jlongFromPointer(this));
   CHECK_EXCEPTION(jni()) << "Error during NetworkMonitor.stopMonitoring";
 
-  network_info_by_address_.clear();
+  network_info_by_handle_.clear();
+}
+
+NetworkInformation* AndroidNetworkMonitor::GetNetworkInfoFromAddress(
+    const rtc::IPAddress& address) {
+  // Network handles (IDs) are created by the Android OS in the increasing

[pthatcher1, 2016/01/30 02:22:07]

in the increasing order => in increasing order

[honghaiz3, 2016/02/02 04:07:42]

This is removed.

+  // order. By searching in the reverse direction, the one that was created most
+  // recently is found first in the (unlikely) case that two handles have the
+  // same IP address (e.g., caused by accidentally not deleting the old handle).
+  auto& networks = network_info_by_handle_;
+  auto it = std::find_if(
+      networks.rbegin(), networks.rend(),
+      [address](const std::pair<NetworkHandle, NetworkInformation>& pos) {

[pthatcher1, 2016/01/30 02:22:07]

"pos"?  Why not "it" or "kv"?

[honghaiz3, 2016/02/02 04:07:42]

This part is removed.

+        auto& addresses = pos.second.ip_addresses;
+        return std::find(addresses.begin(), addresses.end(), address) !=
+               addresses.end();
+      });

[pthatcher1, 2016/01/30 02:22:07]

Could we not have both a network_info_by_address_ and a network_info_by_handle_?
 It seems like it would be easy to update both when we add/remove, and it would
make this the address => info lookup a lot easier and faster. 

[honghaiz3, 2016/02/02 04:07:42]

Done.

[honghaiz3, 2016/02/02 17:44:13]

Note, I used network_handle_by_address instead of the whole network information
by address.

+  return (it != networks.rend()) ? &(it->second) : nullptr;
 }
 
 int AndroidNetworkMonitor::BindSocketToNetwork(int socket_fd,
                                                const rtc::IPAddress& address) {
   RTC_CHECK(thread_checker_.CalledOnValidThread());
-  auto it = network_info_by_address_.find(address);
-  if (it == network_info_by_address_.end()) {
+  // Android prior to Lollipop didn't have support for binding sockets to
+  // networks. However, in that case it should not have reached here because
+  // |network_info_by_handle_| should only be populated in Android Lollipop
+  // and above.
+  // TODO(honghaiz): Add a check for Android version here so that it won't try
+  // to look for handle if the Android version is before Lollipop.
+  NetworkInformation* network = GetNetworkInfoFromAddress(address);
+  if (network == nullptr) {
     return rtc::NETWORK_BIND_ADDRESS_NOT_FOUND;
   }
-  // Android prior to Lollipop didn't have support for binding sockets to
-  // networks. However, in that case it should not have reached here because
-  // |network_info_by_address_| should only be populated in Android Lollipop
-  // and above.
-  NetworkInformation network = it->second;
 
   // NOTE: This does rely on Android implementation details, but
   // these details are unlikely to change.
   typedef int (*SetNetworkForSocket)(unsigned netId, int socketFd);
   static SetNetworkForSocket setNetworkForSocket;
   // This is not threadsafe, but we are running this only on the worker thread.
   if (setNetworkForSocket == nullptr) {
     // Android's netd client library should always be loaded in our address
     // space as it shims libc functions like connect().
     const std::string net_library_path = "libnetd_client.so";
     void* lib = dlopen(net_library_path.c_str(), RTLD_LAZY);
     if (lib == nullptr) {
       LOG(LS_ERROR) << "Library " << net_library_path << " not found!";
       return rtc::NETWORK_BIND_NOT_IMPLEMENTED;
     }
     setNetworkForSocket = reinterpret_cast<SetNetworkForSocket>(
         dlsym(lib, "setNetworkForSocket"));
   }
   if (setNetworkForSocket == nullptr) {
     LOG(LS_ERROR) << "Symbol setNetworkForSocket not found ";
     return rtc::NETWORK_BIND_NOT_IMPLEMENTED;
   }
-  int rv = setNetworkForSocket(network.handle, socket_fd);
+  int rv = setNetworkForSocket(network->handle, socket_fd);
   // If |network| has since disconnected, |rv| will be ENONET.  Surface this as
   // ERR_NETWORK_CHANGED, rather than MapSystemError(ENONET) which gives back
   // the less descriptive ERR_FAILED.
   if (rv == 0) {
     return rtc::NETWORK_BIND_SUCCESS;
   }
   if (rv == ENONET) {
     return rtc::NETWORK_BIND_NETWORK_CHANGED;
   }
   return rtc::NETWORK_BIND_FAILURE;
 }
 
-void AndroidNetworkMonitor::OnNetworkAvailable(
+void AndroidNetworkMonitor::OnNetworkConnected(
     const NetworkInformation& network_info) {
+  LOG(LS_INFO) << "Network connected: " << network_info.ToString();
   worker_thread()->Invoke<void>(rtc::Bind(
-      &AndroidNetworkMonitor::OnNetworkAvailable_w, this, network_info));
+      &AndroidNetworkMonitor::OnNetworkConnected_w, this, network_info));
 }
 
-void AndroidNetworkMonitor::OnNetworkAvailable_w(
+void AndroidNetworkMonitor::OnNetworkConnected_w(
     const NetworkInformation& network_info) {
-  LOG(LS_INFO) << "Network available: " << network_info.ToString();
-  for (rtc::IPAddress address : network_info.ip_addresses) {
-    network_info_by_address_[address] = network_info;
+  network_info_by_handle_[network_info.handle] = network_info;
+  adapter_type_by_name_[network_info.interface_name] =
+      AdapterTypeFromNetworkType(network_info.type);
+}
+
+void AndroidNetworkMonitor::OnNetworkDisconnected(NetworkHandle handle) {
+  LOG(LS_INFO) << "Network disconnected for handle " << handle;
+  worker_thread()->Invoke<void>(
+      rtc::Bind(&AndroidNetworkMonitor::OnNetworkDisconnected_w, this, handle));
+}
+
+void AndroidNetworkMonitor::OnNetworkDisconnected_w(NetworkHandle handle) {
+  network_info_by_handle_.erase(handle);

[pthatcher1, 2016/01/30 02:22:07]

You'd just need to do:

iter = network_info_by_handle_.find(handle);
if (iter != newtork_info_by_handle_.end()) {
 for (rtc::IPAddress address : iter.second.ip_addresses) {
    network_info_by_address_.erase(address);
  }
}

[honghaiz3, 2016/02/02 04:07:42]

Done.

+}
+
+void AndroidNetworkMonitor::SetNetworkInfos(
+    const std::vector<NetworkInformation>& network_infos) {
+  RTC_CHECK(thread_checker_.CalledOnValidThread());
+  network_info_by_handle_.clear();
+  for (NetworkInformation network : network_infos) {
+    OnNetworkConnected_w(network);
   }
 }
 
+rtc::AdapterType AndroidNetworkMonitor::GetAdapterType(
+    const std::string& if_name) {
+  // If not found, the default type is 0 (ADAPTER_TYPE_UNKNOWN).
+  return adapter_type_by_name_[if_name];

[pthatcher1, 2016/01/30 02:22:07]

I think that's a little too subtle.  Doing something like:

iter = adapter_type_by_name_.find(if_name);
if (iter == .end()) {
  return ADAPTER_TYPE_UNKNOWN;
}
return iter.second;

[honghaiz3, 2016/02/02 04:07:42]

Done.

+}
+
 rtc::NetworkMonitorInterface*
 AndroidNetworkMonitorFactory::CreateNetworkMonitor() {
   return new AndroidNetworkMonitor();
 }
 
 JOW(void, NetworkMonitor_nativeNotifyConnectionTypeChanged)(
     JNIEnv* jni, jobject j_monitor, jlong j_native_monitor) {
   rtc::NetworkMonitorInterface* network_monitor =
       reinterpret_cast<rtc::NetworkMonitorInterface*>(j_native_monitor);
   network_monitor->OnNetworksChanged();
 }
 
+JOW(void, NetworkMonitor_nativeNotifyOfActiveNetworkList)(
+    JNIEnv* jni, jobject j_monitor, jlong j_native_monitor,
+    jobjectArray j_network_infos) {
+  AndroidNetworkMonitor* network_monitor =
+      reinterpret_cast<AndroidNetworkMonitor*>(j_native_monitor);
+  std::vector<NetworkInformation> network_infos;
+  size_t num_networks = jni->GetArrayLength(j_network_infos);
+  for (size_t i = 0; i < num_networks; ++i) {
+    jobject j_network_info = jni->GetObjectArrayElement(j_network_infos, i);
+    CHECK_EXCEPTION(jni) << "Error during GetObjectArrayElement";
+    network_infos.push_back(GetNetworkInformationFromJava(jni, j_network_info));
+  }
+  network_monitor->SetNetworkInfos(network_infos);
+}
+
 JOW(void, NetworkMonitor_nativeNotifyOfNetworkConnect)(
     JNIEnv* jni, jobject j_monitor, jlong j_native_monitor,
     jobject j_network_info) {
   AndroidNetworkMonitor* network_monitor =
       reinterpret_cast<AndroidNetworkMonitor*>(j_native_monitor);
   NetworkInformation network_info =
       GetNetworkInformationFromJava(jni, j_network_info);
-  network_monitor->OnNetworkAvailable(network_info);
+  network_monitor->OnNetworkConnected(network_info);
+}
+
+JOW(void, NetworkMonitor_nativeNotifyOfNetworkDisconnect)(
+    JNIEnv* jni, jobject j_monitor, jlong j_native_monitor,
+    jint network_handle) {
+  AndroidNetworkMonitor* network_monitor =
+      reinterpret_cast<AndroidNetworkMonitor*>(j_native_monitor);
+  network_monitor->OnNetworkDisconnected(
+      static_cast<NetworkHandle>(network_handle));
 }
 
 }  // namespace webrtc_jni