Add interface for os/firmware to affect ICE selection.

This patch adds an interface for os/firmware to set a network
preference NOT_PREFERRED / NEUTRAL that can be picked up by
an IceController and used when selection ice candidate pair.

The patch exposes this using an Android Intent based interface.

BUG: webrtc:11825
Change-Id: Ic12b6bf704fde7f9c912020dd7bc79ccae4613ab
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/180883
Commit-Queue: Jonas Oreland <jonaso@webrtc.org>
Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31877}

sdk/android/src/jni/android_network_monitor.cc

@@ -21,7 +21,7 @@
 #include "rtc_base/ip_address.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/strings/string_builder.h"
-#include "sdk/android/generated_base_jni/NetworkMonitorAutoDetect_jni.h"
+#include "sdk/android/generated_base_jni/NetworkChangeDetector_jni.h"
 #include "sdk/android/generated_base_jni/NetworkMonitor_jni.h"
 #include "sdk/android/native_api/jni/java_types.h"
 #include "sdk/android/src/jni/jni_helpers.h"
@@ -413,6 +413,17 @@ void AndroidNetworkMonitor::OnNetworkDisconnected_w(NetworkHandle handle) {
   }
 }
 
+void AndroidNetworkMonitor::OnNetworkPreference(
+    NetworkType type,
+    rtc::NetworkPreference preference) {
+  worker_thread()->Invoke<void>(RTC_FROM_HERE, [&] {
+    auto adapter_type =
+        AdapterTypeFromNetworkType(type, surface_cellular_types_);
+    network_preference_by_adapter_type_[adapter_type] = preference;
+  });
+  OnNetworksChanged();
+}
+
 void AndroidNetworkMonitor::SetNetworkInfos(
     const std::vector<NetworkInformation>& network_infos) {
   RTC_CHECK(thread_checker_.IsCurrent());
@@ -446,6 +457,29 @@ rtc::AdapterType AndroidNetworkMonitor::GetVpnUnderlyingAdapterType(
   return type;
 }
 
+rtc::NetworkPreference AndroidNetworkMonitor::GetNetworkPreference(
+    const std::string& if_name) {
+  auto iter = adapter_type_by_name_.find(if_name);
+  if (iter == adapter_type_by_name_.end()) {
+    return rtc::NetworkPreference::NEUTRAL;
+  }
+
+  rtc::AdapterType adapter_type = iter->second;
+  if (adapter_type == rtc::ADAPTER_TYPE_VPN) {
+    auto iter2 = vpn_underlying_adapter_type_by_name_.find(if_name);
+    if (iter2 != vpn_underlying_adapter_type_by_name_.end()) {
+      adapter_type = iter2->second;
+    }
+  }
+
+  auto preference_iter = network_preference_by_adapter_type_.find(adapter_type);
+  if (preference_iter == network_preference_by_adapter_type_.end()) {
+    return rtc::NetworkPreference::NEUTRAL;
+  }
+
+  return preference_iter->second;
+}
+
 AndroidNetworkMonitorFactory::AndroidNetworkMonitorFactory()
     : j_application_context_(nullptr) {}
 
@@ -494,5 +528,16 @@ void AndroidNetworkMonitor::NotifyOfNetworkDisconnect(
   OnNetworkDisconnected(static_cast<NetworkHandle>(network_handle));
 }
 
+void AndroidNetworkMonitor::NotifyOfNetworkPreference(
+    JNIEnv* env,
+    const JavaRef<jobject>& j_caller,
+    const JavaRef<jobject>& j_connection_type,
+    jint jpreference) {
+  NetworkType type = GetNetworkTypeFromJava(env, j_connection_type);
+  rtc::NetworkPreference preference =
+      static_cast<rtc::NetworkPreference>(jpreference);
+  OnNetworkPreference(type, preference);
+}
+
 }  // namespace jni
 }  // namespace webrtc

sdk/android/src/jni/android_network_monitor.h

@@ -27,7 +27,7 @@ namespace jni {
 
 typedef int64_t NetworkHandle;
 
-// c++ equivalent of java NetworkMonitorAutoDetect.ConnectionType.
+// c++ equivalent of java NetworkChangeDetector.ConnectionType.
 enum NetworkType {
   NETWORK_UNKNOWN,
   NETWORK_ETHERNET,
@@ -80,8 +80,13 @@ class AndroidNetworkMonitor : public rtc::NetworkMonitorBase,
   rtc::AdapterType GetAdapterType(const std::string& if_name) override;
   rtc::AdapterType GetVpnUnderlyingAdapterType(
       const std::string& if_name) override;
+  rtc::NetworkPreference GetNetworkPreference(
+      const std::string& if_name) override;
+
   void OnNetworkConnected(const NetworkInformation& network_info);
   void OnNetworkDisconnected(NetworkHandle network_handle);
+  void OnNetworkPreference(NetworkType type, rtc::NetworkPreference preference);
+
   // Always expected to be called on the network thread.
   void SetNetworkInfos(const std::vector<NetworkInformation>& network_infos);
 
@@ -96,6 +101,10 @@ class AndroidNetworkMonitor : public rtc::NetworkMonitorBase,
   void NotifyOfActiveNetworkList(JNIEnv* env,
                                  const JavaRef<jobject>& j_caller,
                                  const JavaRef<jobjectArray>& j_network_infos);
+  void NotifyOfNetworkPreference(JNIEnv* env,
+                                 const JavaRef<jobject>& j_caller,
+                                 const JavaRef<jobject>& j_connection_type,
+                                 jint preference);
 
   // Visible for testing.
   absl::optional<NetworkHandle> FindNetworkHandleFromAddress(
@@ -114,6 +123,8 @@ class AndroidNetworkMonitor : public rtc::NetworkMonitorBase,
   std::map<std::string, rtc::AdapterType> vpn_underlying_adapter_type_by_name_;
   std::map<rtc::IPAddress, NetworkHandle> network_handle_by_address_;
   std::map<NetworkHandle, NetworkInformation> network_info_by_handle_;
+  std::map<rtc::AdapterType, rtc::NetworkPreference>
+      network_preference_by_adapter_type_;
   bool find_network_handle_without_ipv6_temporary_part_;
   bool surface_cellular_types_;
 };