Multi-networking with Android L.

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 14 matching lines @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "talk/app/webrtc/java/jni/androidnetworkmonitor_jni.h"
 
 #include "webrtc/base/common.h"
 #include "talk/app/webrtc/java/jni/classreferenceholder.h"
 #include "talk/app/webrtc/java/jni/jni_helpers.h"
 
 namespace webrtc_jni {
+
 jobject AndroidNetworkMonitor::application_context_ = nullptr;
 
+static rtc::NetworkType GetNetworkTypeFromJava(
+    JNIEnv* jni, jobject j_network_type) {
+  std::string enum_name = GetJavaEnumName(
+      jni, "org/webrtc/NetworkMonitorAutoDetect$ConnectionType",
+      j_network_type);
+  if (enum_name == "CONNECTION_UNKNOWN") {
+    return rtc::NetworkType::NETWORK_UNKNOWN;
+  }
+  if (enum_name == "CONNECTION_ETHERNET") {
+    return rtc::NetworkType::NETWORK_ETHERNET;
+  }
+  if (enum_name == "CONNECTION_WIFI") {
+    return rtc::NetworkType::NETWORK_WIFI;
+  }
+  if (enum_name == "CONNECTION_4G") {
+    return rtc::NetworkType::NETWORK_4G;
+  }
+  if (enum_name == "CONNECTION_3G") {
+    return rtc::NetworkType::NETWORK_3G;
+  }
+  if (enum_name == "CONNECTION_2G") {
+    return rtc::NetworkType::NETWORK_2G;
+  }
+  if (enum_name == "CONNECTION_BLUETOOTH") {
+    return rtc::NetworkType::NETWORK_BLUETOOTH;
+  }
+  if (enum_name == "CONNECTION_NONE") {
+    return rtc::NetworkType::NETWORK_NONE;
+  }
+  return rtc::NetworkType::NETWORK_UNKNOWN;
+}
+
+static rtc::NetworkInformation GetNetworkInformationFromJava(
+    JNIEnv* jni, jobject j_network_info) {
+  rtc::NetworkInformation network_info;
+  jclass j_network_info_class = GetObjectClass(jni, j_network_info);
+  jfieldID j_interface_name_id =
+      GetFieldID(jni, j_network_info_class, "name", "Ljava/lang/String;");
+  jfieldID j_handle_id = GetFieldID(jni, j_network_info_class, "handle", "I");
+  jfieldID j_type_id =
+      GetFieldID(jni, j_network_info_class, "type",
+                 "Lorg/webrtc/NetworkMonitorAutoDetect$ConnectionType;");
+
+  network_info.interface_name = JavaToStdString(
+      jni, GetStringField(jni, j_network_info, j_interface_name_id));
+  network_info.handle = static_cast<uint32_t>(GetIntField(jni, j_network_info, j_handle_id));
+  network_info.type =
+      GetNetworkTypeFromJava(jni, GetObjectField(jni, j_network_info, j_type_id));
+  CHECK_EXCEPTION(jni) << "Error during NetworkMonitor.GetNetworkInfoFromJava";
+  return network_info;
+}
+
+
 // static
 void AndroidNetworkMonitor::SetAndroidContext(JNIEnv* jni, jobject context) {
   if (application_context_) {
     jni->DeleteGlobalRef(application_context_);
   }
   application_context_ = NewGlobalRef(jni, context);
 }
 
 AndroidNetworkMonitor::AndroidNetworkMonitor()
     : j_network_monitor_class_(jni(),
@@ skipping 21 matching lines @@
 }
 
 void AndroidNetworkMonitor::Stop() {
   RTC_CHECK(thread_checker_.CalledOnValidThread());
   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";
 }
 
+bool AndroidNetworkMonitor::GetAllNetworkInfos(
+    std::vector<rtc::NetworkInformation>* network_infos) {
+  RTC_CHECK(thread_checker_.CalledOnValidThread());
+  network_infos->clear();
+  jmethodID m = GetMethodID(jni(), *j_network_monitor_class_,
+                            "getAllNetworkInfos",
+                            "()[Lorg/webrtc/NetworkMonitorAutoDetect$NetworkInformation;");
+  jobjectArray j_network_infos = static_cast<jobjectArray>(
+      jni()->CallObjectMethod(*j_network_monitor_, m));
+  size_t num_infos = jni()->GetArrayLength(j_network_infos);
+  for (size_t i = 0; i < num_infos; ++i) {
+    jobject j_network_info = jni()->GetObjectArrayElement(j_network_infos, i);
+    network_infos->push_back(GetNetworkInformationFromJava(jni(), j_network_info));
+  }
+  return true;
+}
+
 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_nativeUpdateNetworkInformation)(
+    JNIEnv* jni, jobject j_monitor, jlong j_native_monitor, jobject j_network_info) {
+  rtc::NetworkMonitorInterface* network_monitor =
+      reinterpret_cast<rtc::NetworkMonitorInterface*>(j_native_monitor);
+  rtc::NetworkInformation network_info = GetNetworkInformationFromJava(jni, j_network_info);
+  network_monitor->OnNetworkAvailable(network_info);
+}
+
 }  // namespace webrtc_jni