Move /webrtc/api/android files to /webrtc/sdk/android

webrtc/api/android/java/src/org/webrtc/NetworkMonitorAutoDetect.java

Index: webrtc/api/android/java/src/org/webrtc/NetworkMonitorAutoDetect.java
diff --git a/webrtc/api/android/java/src/org/webrtc/NetworkMonitorAutoDetect.java b/webrtc/api/android/java/src/org/webrtc/NetworkMonitorAutoDetect.java
deleted file mode 100644
index 3046ab20c550f17829e679d595754ea06860a73f..0000000000000000000000000000000000000000
--- a/webrtc/api/android/java/src/org/webrtc/NetworkMonitorAutoDetect.java
+++ /dev/null
@@ -1,626 +0,0 @@
-/*
- *  Copyright 2015 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.
- */
-
-package org.webrtc;
-
-import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET;
-import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
-
-import android.Manifest.permission;
-import android.annotation.SuppressLint;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
-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;
-import android.telephony.TelephonyManager;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Borrowed from Chromium's
- * src/net/android/java/src/org/chromium/net/NetworkChangeNotifierAutoDetect.java
- *
- * Used by the NetworkMonitor to listen to platform changes in connectivity.
- * Note that use of this class requires that the app have the platform
- * ACCESS_NETWORK_STATE permission.
- */
-public class NetworkMonitorAutoDetect extends BroadcastReceiver {
-  public static enum ConnectionType {
-    CONNECTION_UNKNOWN,
-    CONNECTION_ETHERNET,
-    CONNECTION_WIFI,
-    CONNECTION_4G,
-    CONNECTION_3G,
-    CONNECTION_2G,
-    CONNECTION_UNKNOWN_CELLULAR,
-    CONNECTION_BLUETOOTH,
-    CONNECTION_NONE
-  }
-
-  public static class IPAddress {
-    public final byte[] address;
-    public IPAddress(byte[] address) {
-      this.address = address;
-    }
-  }
-
-  /** Java version of NetworkMonitor.NetworkInformation */
-  public static class NetworkInformation {
-    public final String name;
-    public final ConnectionType type;
-    public final long handle;
-    public final IPAddress[] ipAddresses;
-    public NetworkInformation(
-        String name, ConnectionType type, long 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
-    // further divided into 2G, 3G, or 4G from the subtype.
-    private final int type;
-    // Defined from NetworkInfo.subtype, which is one of the TelephonyManager.NETWORK_TYPE_XXXs.
-    // Will be useful to find the maximum bandwidth.
-    private final int subtype;
-
-    public NetworkState(boolean connected, int type, int subtype) {
-      this.connected = connected;
-      this.type = type;
-      this.subtype = subtype;
-    }
-
-    public boolean isConnected() {
-      return connected;
-    }
-
-    public int getNetworkType() {
-      return type;
-    }
-
-    public int getNetworkSubType() {
-      return subtype;
-    }
-  }
-  /**
-   * The methods in this class get called when the network changes if the callback
-   * is registered with a proper network request. It is only available in Android Lollipop
-   * and above.
-   */
-  @SuppressLint("NewApi")
-  private class SimpleNetworkCallback extends NetworkCallback {
-    @Override
-    public void onAvailable(Network network) {
-      Logging.d(TAG, "Network becomes available: " + network.toString());
-      onNetworkChanged(network);
-    }
-
-    @Override
-    public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
-      // A capabilities change may indicate the ConnectionType has changed,
-      // so forward the new NetworkInformation along to the observer.
-      Logging.d(TAG, "capabilities changed: " + networkCapabilities.toString());
-      onNetworkChanged(network);
-    }
-
-    @Override
-    public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
-      // A link property change may indicate the IP address changes.
-      // so forward the new NetworkInformation to the observer.
-      Logging.d(TAG, "link properties changed: " + linkProperties.toString());
-      onNetworkChanged(network);
-    }
-
-    @Override
-    public void onLosing(Network network, int maxMsToLive) {
-      // Tell the network is going to lose in MaxMsToLive milliseconds.
-      // We may use this signal later.
-      Logging.d(
-          TAG, "Network " + network.toString() + " is about to lose in " + maxMsToLive + "ms");
-    }
-
-    @Override
-    public void onLost(Network network) {
-      Logging.d(TAG, "Network " + network.toString() + " is disconnected");
-      observer.onNetworkDisconnect(networkToNetId(network));
-    }
-
-    private void onNetworkChanged(Network network) {
-      NetworkInformation networkInformation = connectivityManagerDelegate.networkToInfo(network);
-      if (networkInformation != null) {
-        observer.onNetworkConnect(networkInformation);
-      }
-    }
-  }
-
-  /** Queries the ConnectivityManager for information about the current connection. */
-  static class ConnectivityManagerDelegate {
-    /**
-     *  Note: In some rare Android systems connectivityManager is null.  We handle that
-     *  gracefully below.
-     */
-    private final ConnectivityManager connectivityManager;
-
-    ConnectivityManagerDelegate(Context context) {
-      connectivityManager =
-          (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
-    }
-
-    // For testing.
-    ConnectivityManagerDelegate() {
-      // All the methods below should be overridden.
-      connectivityManager = null;
-    }
-
-    /**
-     * Returns connection type and status information about the current
-     * default network.
-     */
-    NetworkState getNetworkState() {
-      if (connectivityManager == null) {
-        return new NetworkState(false, -1, -1);
-      }
-      return getNetworkState(connectivityManager.getActiveNetworkInfo());
-    }
-
-    /**
-     * Returns connection type and status information about |network|.
-     * Only callable on Lollipop and newer releases.
-     */
-    @SuppressLint("NewApi")
-    NetworkState getNetworkState(Network network) {
-      if (connectivityManager == null) {
-        return new NetworkState(false, -1, -1);
-      }
-      return getNetworkState(connectivityManager.getNetworkInfo(network));
-    }
-
-    /**
-     * Returns connection type and status information gleaned from networkInfo.
-     */
-    NetworkState getNetworkState(NetworkInfo networkInfo) {
-      if (networkInfo == null || !networkInfo.isConnected()) {
-        return new NetworkState(false, -1, -1);
-      }
-      return new NetworkState(true, networkInfo.getType(), networkInfo.getSubtype());
-    }
-
-    /**
-     * Returns all connected networks.
-     * Only callable on Lollipop and newer releases.
-     */
-    @SuppressLint("NewApi")
-    Network[] getAllNetworks() {
-      if (connectivityManager == null) {
-        return new Network[0];
-      }
-      return connectivityManager.getAllNetworks();
-    }
-
-    List<NetworkInformation> getActiveNetworkList() {
-      if (!supportNetworkCallback()) {
-        return null;
-      }
-      ArrayList<NetworkInformation> netInfoList = new ArrayList<NetworkInformation>();
-      for (Network network : getAllNetworks()) {
-        NetworkInformation info = networkToInfo(network);
-        if (info != null) {
-          netInfoList.add(info);
-        }
-      }
-      return netInfoList;
-    }
-
-    /**
-     * Returns the NetID of the current default network. Returns
-     * INVALID_NET_ID if no current default network connected.
-     * Only callable on Lollipop and newer releases.
-     */
-    @SuppressLint("NewApi")
-    long getDefaultNetId() {
-      if (!supportNetworkCallback()) {
-        return INVALID_NET_ID;
-      }
-      // Android Lollipop had no API to get the default network; only an
-      // API to return the NetworkInfo for the default network. To
-      // determine the default network one can find the network with
-      // type matching that of the default network.
-      final NetworkInfo defaultNetworkInfo = connectivityManager.getActiveNetworkInfo();
-      if (defaultNetworkInfo == null) {
-        return INVALID_NET_ID;
-      }
-      final Network[] networks = getAllNetworks();
-      long defaultNetId = INVALID_NET_ID;
-      for (Network network : networks) {
-        if (!hasInternetCapability(network)) {
-          continue;
-        }
-        final NetworkInfo networkInfo = connectivityManager.getNetworkInfo(network);
-        if (networkInfo != null && networkInfo.getType() == defaultNetworkInfo.getType()) {
-          // There should not be multiple connected networks of the
-          // same type. At least as of Android Marshmallow this is
-          // not supported. If this becomes supported this assertion
-          // may trigger. At that point we could consider using
-          // ConnectivityManager.getDefaultNetwork() though this
-          // may give confusing results with VPNs and is only
-          // available with Android Marshmallow.
-          assert defaultNetId == INVALID_NET_ID;
-          defaultNetId = networkToNetId(network);
-        }
-      }
-      return defaultNetId;
-    }
-
-    @SuppressLint("NewApi")
-    private NetworkInformation networkToInfo(Network network) {
-      LinkProperties linkProperties = connectivityManager.getLinkProperties(network);
-      // getLinkProperties will return null if the network is unknown.
-      if (linkProperties == null) {
-        Logging.w(TAG, "Detected unknown network: " + network.toString());
-        return null;
-      }
-      if (linkProperties.getInterfaceName() == null) {
-        Logging.w(TAG, "Null interface name for network " + network.toString());
-        return null;
-      }
-
-      NetworkState networkState = getNetworkState(network);
-      if (networkState.connected && networkState.getNetworkType() == ConnectivityManager.TYPE_VPN) {
-        // If a VPN network is in place, we can find the underlying network type via querying the
-        // active network info thanks to
-        // https://android.googlesource.com/platform/frameworks/base/+/d6a7980d
-        networkState = getNetworkState();
-      }
-      ConnectionType connectionType = getConnectionType(networkState);
-      if (connectionType == ConnectionType.CONNECTION_NONE) {
-        // This may not be an error. The OS may signal a network event with connection type
-        // NONE when the network disconnects.
-        Logging.d(TAG, "Network " + network.toString() + " is disconnected");
-        return null;
-      }
-
-      // Some android device may return a CONNECTION_UNKNOWN_CELLULAR or CONNECTION_UNKNOWN type,
-      // which appears to be usable. Just log them here.
-      if (connectionType == ConnectionType.CONNECTION_UNKNOWN
-          || connectionType == ConnectionType.CONNECTION_UNKNOWN_CELLULAR) {
-        Logging.d(TAG, "Network " + network.toString() + " connection type is " + connectionType
-                + " because it has type " + networkState.getNetworkType() + " and subtype "
-                + networkState.getNetworkSubType());
-      }
-
-      NetworkInformation networkInformation =
-          new NetworkInformation(linkProperties.getInterfaceName(), connectionType,
-              networkToNetId(network), getIPAddresses(linkProperties));
-      return networkInformation;
-    }
-
-    /**
-     * Returns true if {@code network} can provide Internet access. Can be used to
-     * ignore specialized networks (e.g. IMS, FOTA).
-     */
-    @SuppressLint("NewApi")
-    boolean hasInternetCapability(Network network) {
-      if (connectivityManager == null) {
-        return false;
-      }
-      final NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
-      return capabilities != null && capabilities.hasCapability(NET_CAPABILITY_INTERNET);
-    }
-
-    /** Only callable on Lollipop and newer releases. */
-    @SuppressLint("NewApi")
-    public void registerNetworkCallback(NetworkCallback networkCallback) {
-      connectivityManager.registerNetworkCallback(
-          new NetworkRequest.Builder().addCapability(NET_CAPABILITY_INTERNET).build(),
-          networkCallback);
-    }
-
-    /** Only callable on Lollipop and newer releases. */
-    @SuppressLint("NewApi")
-    public void requestMobileNetwork(NetworkCallback networkCallback) {
-      NetworkRequest.Builder builder = new NetworkRequest.Builder();
-      builder.addCapability(NET_CAPABILITY_INTERNET).addTransportType(TRANSPORT_CELLULAR);
-      connectivityManager.requestNetwork(builder.build(), networkCallback);
-    }
-
-    @SuppressLint("NewApi")
-    IPAddress[] getIPAddresses(LinkProperties linkProperties) {
-      IPAddress[] ipAddresses = new IPAddress[linkProperties.getLinkAddresses().size()];
-      int i = 0;
-      for (LinkAddress linkAddress : linkProperties.getLinkAddresses()) {
-        ipAddresses[i] = new IPAddress(linkAddress.getAddress().getAddress());
-        ++i;
-      }
-      return ipAddresses;
-    }
-
-    @SuppressLint("NewApi")
-    public void releaseCallback(NetworkCallback networkCallback) {
-      if (supportNetworkCallback()) {
-        Logging.d(TAG, "Unregister network callback");
-        connectivityManager.unregisterNetworkCallback(networkCallback);
-      }
-    }
-
-    public boolean supportNetworkCallback() {
-      return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && connectivityManager != null;
-    }
-  }
-
-  /** Queries the WifiManager for SSID of the current Wifi connection. */
-  static class WifiManagerDelegate {
-    private final Context context;
-    WifiManagerDelegate(Context context) {
-      this.context = context;
-    }
-
-    // For testing.
-    WifiManagerDelegate() {
-      // All the methods below should be overridden.
-      context = null;
-    }
-
-    String getWifiSSID() {
-      final Intent intent = context.registerReceiver(
-          null, new IntentFilter(WifiManager.NETWORK_STATE_CHANGED_ACTION));
-      if (intent != null) {
-        final WifiInfo wifiInfo = intent.getParcelableExtra(WifiManager.EXTRA_WIFI_INFO);
-        if (wifiInfo != null) {
-          final String ssid = wifiInfo.getSSID();
-          if (ssid != null) {
-            return ssid;
-          }
-        }
-      }
-      return "";
-    }
-  }
-
-  static final long INVALID_NET_ID = -1;
-  private static final String TAG = "NetworkMonitorAutoDetect";
-
-  // Observer for the connection type change.
-  private final Observer observer;
-  private final IntentFilter intentFilter;
-  private final Context context;
-  // Used to request mobile network. It does not do anything except for keeping
-  // the callback for releasing the request.
-  private final NetworkCallback mobileNetworkCallback;
-  // Used to receive updates on all networks.
-  private final NetworkCallback allNetworkCallback;
-  // connectivityManagerDelegate and wifiManagerDelegate are only non-final for testing.
-  private ConnectivityManagerDelegate connectivityManagerDelegate;
-  private WifiManagerDelegate wifiManagerDelegate;
-
-  private boolean isRegistered;
-  private ConnectionType connectionType;
-  private String wifiSSID;
-
-  /**
-   * Observer interface by which observer is notified of network changes.
-   */
-  public static interface Observer {
-    /**
-     * Called when default network changes.
-     */
-    public void onConnectionTypeChanged(ConnectionType newConnectionType);
-    public void onNetworkConnect(NetworkInformation networkInfo);
-    public void onNetworkDisconnect(long networkHandle);
-  }
-
-  /**
-   * Constructs a NetworkMonitorAutoDetect. Should only be called on UI thread.
-   */
-  @SuppressLint("NewApi")
-  public NetworkMonitorAutoDetect(Observer observer, Context context) {
-    this.observer = observer;
-    this.context = context;
-    connectivityManagerDelegate = new ConnectivityManagerDelegate(context);
-    wifiManagerDelegate = new WifiManagerDelegate(context);
-
-    final NetworkState networkState = connectivityManagerDelegate.getNetworkState();
-    connectionType = getConnectionType(networkState);
-    wifiSSID = getWifiSSID(networkState);
-    intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
-
-    registerReceiver();
-    if (connectivityManagerDelegate.supportNetworkCallback()) {
-      // On Android 6.0.0, the WRITE_SETTINGS permission is necessary for
-      // requestNetwork, so it will fail. This was fixed in Android 6.0.1.
-      NetworkCallback tempNetworkCallback = new NetworkCallback();
-      try {
-        connectivityManagerDelegate.requestMobileNetwork(tempNetworkCallback);
-      } catch (java.lang.SecurityException e) {
-        Logging.w(TAG, "Unable to obtain permission to request a cellular network.");
-        tempNetworkCallback = null;
-      }
-      mobileNetworkCallback = tempNetworkCallback;
-      allNetworkCallback = new SimpleNetworkCallback();
-      connectivityManagerDelegate.registerNetworkCallback(allNetworkCallback);
-    } else {
-      mobileNetworkCallback = null;
-      allNetworkCallback = null;
-    }
-  }
-
-  /**
-   * Allows overriding the ConnectivityManagerDelegate for tests.
-   */
-  void setConnectivityManagerDelegateForTests(ConnectivityManagerDelegate delegate) {
-    connectivityManagerDelegate = delegate;
-  }
-
-  /**
-   * Allows overriding the WifiManagerDelegate for tests.
-   */
-  void setWifiManagerDelegateForTests(WifiManagerDelegate delegate) {
-    wifiManagerDelegate = delegate;
-  }
-
-  /**
-   * Returns whether the object has registered to receive network connectivity intents.
-   * Visible for testing.
-   */
-  boolean isReceiverRegisteredForTesting() {
-    return isRegistered;
-  }
-
-  List<NetworkInformation> getActiveNetworkList() {
-    return connectivityManagerDelegate.getActiveNetworkList();
-  }
-
-  public void destroy() {
-    if (allNetworkCallback != null) {
-      connectivityManagerDelegate.releaseCallback(allNetworkCallback);
-    }
-    if (mobileNetworkCallback != null) {
-      connectivityManagerDelegate.releaseCallback(mobileNetworkCallback);
-    }
-    unregisterReceiver();
-  }
-
-  /**
-   * Registers a BroadcastReceiver in the given context.
-   */
-  private void registerReceiver() {
-    if (isRegistered)
-      return;
-
-    isRegistered = true;
-    context.registerReceiver(this, intentFilter);
-  }
-
-  /**
-   * Unregisters the BroadcastReceiver in the given context.
-   */
-  private void unregisterReceiver() {
-    if (!isRegistered)
-      return;
-
-    isRegistered = false;
-    context.unregisterReceiver(this);
-  }
-
-  public NetworkState getCurrentNetworkState() {
-    return connectivityManagerDelegate.getNetworkState();
-  }
-
-  /**
-   * Returns NetID of device's current default connected network used for
-   * communication.
-   * Only implemented on Lollipop and newer releases, returns INVALID_NET_ID
-   * when not implemented.
-   */
-  public long getDefaultNetId() {
-    return connectivityManagerDelegate.getDefaultNetId();
-  }
-
-  public static ConnectionType getConnectionType(NetworkState networkState) {
-    if (!networkState.isConnected()) {
-      return ConnectionType.CONNECTION_NONE;
-    }
-
-    switch (networkState.getNetworkType()) {
-      case ConnectivityManager.TYPE_ETHERNET:
-        return ConnectionType.CONNECTION_ETHERNET;
-      case ConnectivityManager.TYPE_WIFI:
-        return ConnectionType.CONNECTION_WIFI;
-      case ConnectivityManager.TYPE_WIMAX:
-        return ConnectionType.CONNECTION_4G;
-      case ConnectivityManager.TYPE_BLUETOOTH:
-        return ConnectionType.CONNECTION_BLUETOOTH;
-      case ConnectivityManager.TYPE_MOBILE:
-        // Use information from TelephonyManager to classify the connection.
-        switch (networkState.getNetworkSubType()) {
-          case TelephonyManager.NETWORK_TYPE_GPRS:
-          case TelephonyManager.NETWORK_TYPE_EDGE:
-          case TelephonyManager.NETWORK_TYPE_CDMA:
-          case TelephonyManager.NETWORK_TYPE_1xRTT:
-          case TelephonyManager.NETWORK_TYPE_IDEN:
-            return ConnectionType.CONNECTION_2G;
-          case TelephonyManager.NETWORK_TYPE_UMTS:
-          case TelephonyManager.NETWORK_TYPE_EVDO_0:
-          case TelephonyManager.NETWORK_TYPE_EVDO_A:
-          case TelephonyManager.NETWORK_TYPE_HSDPA:
-          case TelephonyManager.NETWORK_TYPE_HSUPA:
-          case TelephonyManager.NETWORK_TYPE_HSPA:
-          case TelephonyManager.NETWORK_TYPE_EVDO_B:
-          case TelephonyManager.NETWORK_TYPE_EHRPD:
-          case TelephonyManager.NETWORK_TYPE_HSPAP:
-            return ConnectionType.CONNECTION_3G;
-          case TelephonyManager.NETWORK_TYPE_LTE:
-            return ConnectionType.CONNECTION_4G;
-          default:
-            return ConnectionType.CONNECTION_UNKNOWN_CELLULAR;
-        }
-      default:
-        return ConnectionType.CONNECTION_UNKNOWN;
-    }
-  }
-
-  private String getWifiSSID(NetworkState networkState) {
-    if (getConnectionType(networkState) != ConnectionType.CONNECTION_WIFI)
-      return "";
-    return wifiManagerDelegate.getWifiSSID();
-  }
-
-  // BroadcastReceiver
-  @Override
-  public void onReceive(Context context, Intent intent) {
-    final NetworkState networkState = getCurrentNetworkState();
-    if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
-      connectionTypeChanged(networkState);
-    }
-  }
-
-  private void connectionTypeChanged(NetworkState networkState) {
-    ConnectionType newConnectionType = getConnectionType(networkState);
-    String newWifiSSID = getWifiSSID(networkState);
-    if (newConnectionType == connectionType && newWifiSSID.equals(wifiSSID))
-      return;
-
-    connectionType = newConnectionType;
-    wifiSSID = newWifiSSID;
-    Logging.d(TAG, "Network connectivity changed, type is: " + connectionType);
-    observer.onConnectionTypeChanged(newConnectionType);
-  }
-
-  /**
-   * Extracts NetID of network on Lollipop and NetworkHandle (which is mungled
-   * NetID) on Marshmallow and newer releases. Only available on Lollipop and
-   * newer releases. Returns long since getNetworkHandle returns long.
-   */
-  @SuppressLint("NewApi")
-  private static long networkToNetId(Network network) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-      return network.getNetworkHandle();
-    }
-
-    // NOTE(honghaiz): This depends on Android framework implementation details.
-    // These details cannot change because Lollipop has been released.
-    return Integer.parseInt(network.toString());
-  }
-}