Multi-networking with Android L.

webrtc/base/network.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 111 matching lines @@
     case ADAPTER_TYPE_VPN:
       return "VPN";
     case ADAPTER_TYPE_LOOPBACK:
       return "Loopback";
     default:
       RTC_DCHECK(false) << "Invalid type " << type;
       return std::string();
   }
 }
 
+AdapterType FromNetworkType(NetworkType network_type) {
+  switch (network_type) {
+    case NETWORK_UNKNOWN:
+      return ADAPTER_TYPE_UNKNOWN;
+    case NETWORK_ETHERNET:
+      return ADAPTER_TYPE_ETHERNET;
+    case NETWORK_WIFI:
+      return ADAPTER_TYPE_WIFI;
+    case NETWORK_4G:
+    case NETWORK_3G:
+    case NETWORK_2G:
+      return ADAPTER_TYPE_CELLULAR;
+    case NETWORK_BLUETOOTH:
+    case NETWORK_NONE:
+      return ADAPTER_TYPE_LOOPBACK;
+    default:
+      RTC_DCHECK(false) << "Invalid network type " << network_type;
+      return ADAPTER_TYPE_UNKNOWN;
+  }
+}
+
 bool IsIgnoredIPv6(const IPAddress& ip) {
   if (ip.family() != AF_INET6) {
     return false;
   }
 
   // Link-local addresses require scope id to be bound successfully.
   // However, our IPAddress structure doesn't carry that so the
   // information is lost and causes binding failure.
   if (IPIsLinkLocal(ip)) {
     return true;
@@ skipping 206 matching lines @@
   if (family == AF_INET && !default_local_ipv4_address_.IsNil()) {
     *ipaddr = default_local_ipv4_address_;
     return true;
   } else if (family == AF_INET6 && !default_local_ipv6_address_.IsNil()) {
     *ipaddr = default_local_ipv6_address_;
     return true;
   }
   return false;
 }
 
+void BasicNetworkManager::GetAndUpdateNetworkInfos() {
+  std::vector<NetworkInformation> network_infos;
+  LOG(LS_INFO) << "start to get network info";
+  if (network_monitor_->GetAllNetworkInfos(&network_infos)) {
+    LOG(LS_INFO) << "done to get network info";
+    network_infos_.clear();
+    for (NetworkInformation& network_info : network_infos) {
+      network_infos_[network_info.interface_name] = network_info;
+    }
+    for (auto kv : networks_map()) {
+      UpdateNetworkInfo(kv.second);
+    }
+    LOG(LS_INFO) << "done to update network info";
+  }
+}
+
+void BasicNetworkManager::UpdateNetworkInfo(Network* network) const {
+  auto it = network_infos_.find(network->name());
+  if (it != network_infos_.end()) {
+    const NetworkInformation& network_info = it->second;
+    network->set_handle(network_info.handle);
+    network->set_type(FromNetworkType(network_info.type));
+    LOG(LS_INFO) << "Set network " << network->ToString()
+                 << " handle " << network->handle()
+                 << " type " << network->type();
+  }
+}
+
+
 BasicNetworkManager::BasicNetworkManager()
     : thread_(NULL), sent_first_update_(false), start_count_(0),
       network_ignore_mask_(kDefaultNetworkIgnoreMask),
       ignore_non_default_routes_(false) {
 }
 
 BasicNetworkManager::~BasicNetworkManager() {
 }
 
 void BasicNetworkManager::OnNetworksChanged() {
   LOG(LS_VERBOSE) << "Network change was observed at the network manager";
+  std::vector<NetworkInformation> network_infos;
+
   UpdateNetworksOnce();
 }
 
+void BasicNetworkManager::OnNetworkAvailable(const NetworkInformation& network_info) {
+  LOG(LS_VERBOSE) << "Network available at network manager: " << network_info.interface_name;
+  ASSERT(Thread::Current() == thread_);
+  network_infos_[network_info.interface_name] = network_info;
+  // Only need to update one.
+  for (auto kv : networks_map()) {
+    UpdateNetworkInfo(kv.second);
+  }
+}
+
 #if defined(__native_client__)
 
 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
                                          NetworkList* networks) const {
   ASSERT(false);
   LOG(LS_WARNING) << "BasicNetworkManager doesn't work on NaCl yet";
   return false;
 }
 
 #elif defined(WEBRTC_POSIX)
@@ skipping 60 matching lines @@
       }
 #endif
       // TODO(phoglund): Need to recognize other types as well.
       scoped_ptr<Network> network(new Network(cursor->ifa_name,
                                               cursor->ifa_name, prefix,
                                               prefix_length, adapter_type));
       network->set_default_local_address_provider(this);
       network->set_scope_id(scope_id);
       network->AddIP(ip);
       network->set_ignored(IsIgnoredNetwork(*network));
+      UpdateNetworkInfo(network.get());
       if (include_ignored || !network->ignored()) {
         networks->push_back(network.release());
       }
     } else {
       (*existing_network).second->AddIP(ip);
     }
   }
 }
 
 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
@@ skipping 258 matching lines @@
 
 void BasicNetworkManager::StartNetworkMonitor() {
   NetworkMonitorFactory* factory = NetworkMonitorFactory::GetFactory();
   if (factory == nullptr) {
     return;
   }
   network_monitor_.reset(factory->CreateNetworkMonitor());
   if (!network_monitor_) {
     return;
   }
+
   network_monitor_->SignalNetworksChanged.connect(
       this, &BasicNetworkManager::OnNetworksChanged);
+  network_monitor_->SignalNetworkAvailable.connect(
+      this, &BasicNetworkManager::OnNetworkAvailable);
   network_monitor_->Start();
+
+  GetAndUpdateNetworkInfos();
 }
 
 void BasicNetworkManager::StopNetworkMonitor() {
   if (!network_monitor_) {
     return;
   }
   network_monitor_->Stop();
   network_monitor_.reset();
 }
 
+
 void BasicNetworkManager::OnMessage(Message* msg) {
   switch (msg->message_id) {
     case kUpdateNetworksMessage: {
       UpdateNetworksContinually();
       break;
     }
     case kSignalNetworksMessage:  {
       SignalNetworksChanged();
       break;
     }
@@ skipping 158 matching lines @@
   std::stringstream ss;
   // Print out the first space-terminated token of the network desc, plus
   // the IP address.
   ss << "Net[" << description_.substr(0, description_.find(' '))
      << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
      << ":" << AdapterTypeToString(type_) << "]";
   return ss.str();
 }
 
 }  // namespace rtc