Java 类android.net.NetworkCapabilities 实例源码

@Override public Observable<Connectivity> observeNetworkConnectivity(final Context context) {
    final String service = Context.CONNECTIVITY_SERVICE;
    final ConnectivityManager manager = (ConnectivityManager) context.getSystemService(service);
    networkCallback = createNetworkCallback(context);

    registerIdleReceiver(context);

    final NetworkRequest request =
            new NetworkRequest.Builder().addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                    .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
                    .build();

    manager.registerNetworkCallback(request, networkCallback);

    return connectivitySubject.toFlowable(BackpressureStrategy.LATEST).doOnCancel(new Action() {
        @Override public void run() {
            tryToUnregisterCallback(manager);
            tryToUnregisterReceiver(context);
        }
    }).startWith(Connectivity.create(context)).distinctUntilChanged().toObservable();
}

/**
 * @param context the current application context
 * @return whether the device was connected to the internet
 */
public static boolean hasInternetConnection(Context context) {

    /*
    Taken from Johan's answer at: https://stackoverflow.com/a/35009615
     */

    ConnectivityManager connectivityManager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
    Network network;
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
        network = connectivityManager.getActiveNetwork();
    } else
        return true;
    NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
    return capabilities != null && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
}

@Override
public void onCapabilitiesChanged(
        Network network, NetworkCapabilities networkCapabilities) {
    if (ignoreConnectedNetwork(network, networkCapabilities)) {
        return;
    }
    // A capabilities change may indicate the ConnectionType has changed,
    // so forward the new ConnectionType along to observer.
    final long netId = networkToNetId(network);
    final int connectionType =
            getCurrentConnectionType(mConnectivityManagerDelegate.getNetworkState(network));
    ThreadUtils.postOnUiThread(new Runnable() {
        @Override
        public void run() {
            mObserver.onNetworkConnect(netId, connectionType);
        }
    });
}

/**
 * Determines if any of specified transport types occurred.
 *
 * @param transportTypes one or many {@code NetworkCapabilities#TRANSPORT_*}
 *
 * @return {@code true} if any of the given transport types occurred, {@code false} otherwise
 */
public static Predicate<RxNetworkInfo> hasTransportType(final int... transportTypes) {
  return new Predicate<RxNetworkInfo>() {
    @Override
    public boolean test(RxNetworkInfo networkInfo) throws Exception {
      final NetworkCapabilities networkCapabilities = networkInfo.getNetworkCapabilities();

      if (networkCapabilities != null) {
        for (Integer transportType : transportTypes) {
          if (networkCapabilities.hasTransport(transportType)) {
            return true;
          }
        }
      }

      return false;
    }
  };
}

public static void registerLollipopNetworkReceiver(Context context) {
    if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        cm.registerNetworkCallback(
                new NetworkRequest.Builder()
                        .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
                        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                        .build(),
                new ConnectivityManager.NetworkCallback() {
                    @Override
                    public void onAvailable(Network network) {
                        boolean connected = false;
                        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                            connected = cm.bindProcessToNetwork(network);
                        } else if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP){
                            //noinspection deprecation
                            connected = ConnectivityManager.setProcessDefaultNetwork(network);
                        }
                        if(connected) {
                            Customerly.get().__SOCKET__check();
                        }
                    }
                });
    }
}

private void checkConnectivity() {
    final ConnectivityManager connectivityManager
            = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    final NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    connected = activeNetworkInfo != null && activeNetworkInfo.isConnected();
    if (!connected) {
        loading.setVisibility(View.GONE);
        if (noConnection == null) {
            final ViewStub stub = (ViewStub) findViewById(R.id.stub_no_connection);
            noConnection = (ImageView) stub.inflate();
        }
        final AnimatedVectorDrawable avd =
                (AnimatedVectorDrawable) getDrawable(R.drawable.avd_no_connection);
        noConnection.setImageDrawable(avd);
        avd.start();

        connectivityManager.registerNetworkCallback(
                new NetworkRequest.Builder()
                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build(),
                connectivityCallback);
        monitoringConnectivity = true;
    }
}

@Nonnull
private List<InetAddress> getDns() {
  final ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(
      CONNECTIVITY_SERVICE
  );
  if (connectivityManager == null) {
    return Collections.emptyList();
  }
  return Observable.fromArray(
      connectivityManager.getAllNetworks()
  ).filter(it -> connectivityManager.getNetworkCapabilities(it).hasCapability(
      NetworkCapabilities.NET_CAPABILITY_INTERNET
  )).map(connectivityManager::getLinkProperties).flatMap(
      it -> Observable.fromIterable(it.getDnsServers())
  ).toList().blockingGet();
}

private void checkConnectivity() {
    final ConnectivityManager connectivityManager
            = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    final NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    connected = activeNetworkInfo != null && activeNetworkInfo.isConnected();
    if (!connected) {
        loading.setVisibility(View.GONE);
        if (noConnection == null) {
            final ViewStub stub = (ViewStub) findViewById(R.id.stub_no_connection);
            noConnection = (ImageView) stub.inflate();
        }
        final AnimatedVectorDrawable avd =
                (AnimatedVectorDrawable) getDrawable(R.drawable.avd_no_connection);
        if (noConnection != null && avd != null) {
            noConnection.setImageDrawable(avd);
            avd.start();
        }

        connectivityManager.registerNetworkCallback(
                new NetworkRequest.Builder()
                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build(),
                connectivityCallback);
        monitoringConnectivity = true;
    }
}

private void checkConnectivity() {
    final ConnectivityManager connectivityManager
            = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    final NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    connected = activeNetworkInfo != null && activeNetworkInfo.isConnected();
    if (!connected) {
        loading.setVisibility(View.GONE);
        if (noConnection == null) {
            final ViewStub stub = (ViewStub) findViewById(R.id.stub_no_connection);
            noConnection = (ImageView) stub.inflate();
        }
        final AnimatedVectorDrawable avd =
                (AnimatedVectorDrawable) getDrawable(R.drawable.avd_no_connection);
        noConnection.setImageDrawable(avd);
        avd.start();

        connectivityManager.registerNetworkCallback(
                new NetworkRequest.Builder()
                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build(),
                connectivityCallback);
        monitoringConnectivity = true;
    }
}

public static void registerLollipopNetworkReceiver(Context context) {
    if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        cm.registerNetworkCallback(
                new NetworkRequest.Builder()
                        .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
                        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                        .build(),
                new ConnectivityManager.NetworkCallback() {
                    @Override
                    public void onAvailable(Network network) {
                        boolean connected = false;
                        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                            connected = cm.bindProcessToNetwork(network);
                        } else if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP){
                            //noinspection deprecation
                            connected = ConnectivityManager.setProcessDefaultNetwork(network);
                        }
                        if(connected) {
                            Customerly.get().__SOCKET__check();
                        }
                    }
                });
    }
}

/**
 * Returns true if the system's captive portal probe was blocked for the current default data
 * network. The method will return false if the captive portal probe was not blocked, the login
 * process to the captive portal has been successfully completed, or if the captive portal
 * status can't be determined. Requires ACCESS_NETWORK_STATE permission. Only available on
 * Android Marshmallow and later versions. Returns false on earlier versions.
 */
@TargetApi(Build.VERSION_CODES.M)
@CalledByNative
private static boolean getIsCaptivePortal() {
    // NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL is only available on Marshmallow and
    // later versions.
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return false;
    ConnectivityManager connectivityManager =
            (ConnectivityManager) ContextUtils.getApplicationContext().getSystemService(
                    Context.CONNECTIVITY_SERVICE);
    if (connectivityManager == null) return false;

    Network network = connectivityManager.getActiveNetwork();
    if (network == null) return false;

    NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
    return capabilities != null
            && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL);
}

@Override
public void onCapabilitiesChanged(
        Network network, NetworkCapabilities networkCapabilities) {
    if (ignoreConnectedNetwork(network, networkCapabilities)) {
        return;
    }
    // A capabilities change may indicate the ConnectionType has changed,
    // so forward the new ConnectionType along to observer.
    final long netId = networkToNetId(network);
    final int connectionType = mConnectivityManagerDelegate.getConnectionType(network);
    runOnThread(new Runnable() {
        @Override
        public void run() {
            mObserver.onNetworkConnect(netId, connectionType);
        }
    });
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
private LinkProperties getLP(ConnectivityManager connMgr, int cap) {
    Network nets[] = connMgr.getAllNetworks();
    for (Network n: nets) {
        LinkProperties lp = connMgr.getLinkProperties(n);
        NetworkCapabilities np = connMgr.getNetworkCapabilities(n);
        String iname =  lp.getInterfaceName();
        if (iname != null && np != null) {
            //Log.d(TAG, ">>> " + iname + ": " + np.hasTransport(cap));
            if (np.hasTransport(cap))
                return lp;
        }
    }
    return null;
}

void initializeVpnInPlace() {
    final Network[] networks = getAllNetworksFiltered(mConnectivityManagerDelegate, null);
    mVpnInPlace = null;
    // If the filtered list of networks contains just a VPN, then that VPN is in place.
    if (networks.length == 1) {
        final NetworkCapabilities capabilities =
                mConnectivityManagerDelegate.getNetworkCapabilities(networks[0]);
        if (capabilities != null && capabilities.hasTransport(TRANSPORT_VPN)) {
            mVpnInPlace = networks[0];
        }
    }
}

/**
 * Should changes to connected network {@code network} be ignored?
 * @param network Network to possibly consider ignoring changes to.
 * @param capabilities {@code NetworkCapabilities} for {@code network} if known, otherwise
 *         {@code null}.
 * @return {@code true} when either: {@code network} is an inaccessible VPN, or has already
 *         disconnected.
 */
private boolean ignoreConnectedInaccessibleVpn(
        Network network, NetworkCapabilities capabilities) {
    // Fetch capabilities if not provided.
    if (capabilities == null) {
        capabilities = mConnectivityManagerDelegate.getNetworkCapabilities(network);
    }
    // Ignore inaccessible VPNs as they don't apply to Chrome.
    return capabilities == null
            || capabilities.hasTransport(TRANSPORT_VPN)
            && !mConnectivityManagerDelegate.vpnAccessible(network);
}

@Override
public void onAvailable(Network network) {
    final NetworkCapabilities capabilities =
            mConnectivityManagerDelegate.getNetworkCapabilities(network);
    if (ignoreConnectedNetwork(network, capabilities)) {
        return;
    }
    final boolean makeVpnDefault = capabilities.hasTransport(TRANSPORT_VPN);
    if (makeVpnDefault) {
        mVpnInPlace = network;
    }
    final long netId = networkToNetId(network);
    final int connectionType =
            getCurrentConnectionType(mConnectivityManagerDelegate.getNetworkState(network));
    ThreadUtils.postOnUiThread(new Runnable() {
        @Override
        public void run() {
            mObserver.onNetworkConnect(netId, connectionType);
            if (makeVpnDefault) {
                // Make VPN the default network.
                mObserver.onConnectionTypeChanged(connectionType);
                // Purge all other networks as they're inaccessible to Chrome now.
                mObserver.purgeActiveNetworkList(new long[] {netId});
            }
        }
    });
}

/**
 * Returns all connected networks that are useful and accessible to Chrome.
 * Only callable on Lollipop and newer releases.
 * @param ignoreNetwork ignore this network as if it is not connected.
 */
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
private static Network[] getAllNetworksFiltered(
        ConnectivityManagerDelegate connectivityManagerDelegate, Network ignoreNetwork) {
    Network[] networks = connectivityManagerDelegate.getAllNetworksUnfiltered();
    // Whittle down |networks| into just the list of networks useful to us.
    int filteredIndex = 0;
    for (Network network : networks) {
        if (network.equals(ignoreNetwork)) {
            continue;
        }
        final NetworkCapabilities capabilities =
                connectivityManagerDelegate.getNetworkCapabilities(network);
        if (capabilities == null || !capabilities.hasCapability(NET_CAPABILITY_INTERNET)) {
            continue;
        }
        if (capabilities.hasTransport(TRANSPORT_VPN)) {
            // If we can access the VPN then...
            if (connectivityManagerDelegate.vpnAccessible(network)) {
                // ...we cannot access any other network, so return just the VPN.
                return new Network[] {network};
            } else {
                // ...otherwise ignore it as we cannot use it.
                continue;
            }
        }
        networks[filteredIndex++] = network;
    }
    return Arrays.copyOf(networks, filteredIndex);
}

private static NetworkCapabilities getCapabilities(int transport) {
    // Create a NetworkRequest with corresponding capabilities
    NetworkRequest request = new NetworkRequest.Builder()
                                     .addCapability(NET_CAPABILITY_INTERNET)
                                     .addTransportType(transport)
                                     .build();
    // Extract the NetworkCapabilities from the NetworkRequest.
    try {
        return (NetworkCapabilities) request.getClass()
                .getDeclaredField("networkCapabilities")
                .get(request);
    } catch (NoSuchFieldException | IllegalAccessException e) {
        return null;
    }
}

@Override
protected NetworkCapabilities getNetworkCapabilities(Network network) {
    int netId = demungeNetId(NetworkChangeNotifierAutoDetect.networkToNetId(network));
    for (MockNetwork mockNetwork : mMockNetworks) {
        if (netId == mockNetwork.mNetId) {
            return mockNetwork.getCapabilities();
        }
    }
    return null;
}

@Override
public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
    super.onCapabilitiesChanged(network, networkCapabilities);
    if (!networkCapabilities.toString().equals(mLastNetworkCapabilities)) {
        mLastNetworkCapabilities = networkCapabilities.toString();
        VpnStatus.logDebug(String.format("Network capabilities of %s: %s", network, networkCapabilities));
    }
}

@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);
}

/**
 * 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(NetworkCapabilities.NET_CAPABILITY_INTERNET);
}

/** Only callable on Lollipop and newer releases. */
@SuppressLint("NewApi")
public void registerNetworkCallback(NetworkCallback networkCallback) {
  connectivityManager.registerNetworkCallback(
      new NetworkRequest.Builder()
          .addCapability(NetworkCapabilities.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(NetworkCapabilities.NET_CAPABILITY_INTERNET)
      .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);
  connectivityManager.requestNetwork(builder.build(), networkCallback);
}

/**
 * Initializes the network.
 */
private void resetNetwork() {
    // Initialize network
    onNoNetwork();
    mConnectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkRequest networkRequest = new NetworkRequest.Builder()
            .addTransportType(NetworkCapabilities.TRANSPORT_LOWPAN)
            .build();
    mBackgroundHandlerThread = new HandlerThread(TAG);
    mBackgroundHandlerThread.start();
    mHandler = new Handler(mBackgroundHandlerThread.getLooper());
    // Make sure that it is connected to a valid network
    mConnectivityManager.registerNetworkCallback(networkRequest,
            mNetworkCallback, mUiThreadHandler);
}

@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);
}

/**
 * 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(NetworkCapabilities.NET_CAPABILITY_INTERNET);
}

/** Only callable on Lollipop and newer releases. */
@SuppressLint("NewApi")
public void registerNetworkCallback(NetworkCallback networkCallback) {
  connectivityManager.registerNetworkCallback(
      new NetworkRequest.Builder()
          .addCapability(NetworkCapabilities.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(NetworkCapabilities.NET_CAPABILITY_INTERNET)
      .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);
  connectivityManager.requestNetwork(builder.build(), networkCallback);
}

/**
 * Gets {@link RxNetworkInfo network information} from given {@link Network} instance
 * along with {@link NetworkCapabilities} provided at the time of registering network callback
 * in {@linkplain ConnectivityManager#registerNetworkCallback} (if available).
 *
 * @param network             {@link Network}
 * @param connectivityManager {@link ConnectivityManager}
 *
 * @return {@link RxNetworkInfo} instance
 */
@RequiresApi(LOLLIPOP)
public static RxNetworkInfo create(@NonNull Network network,
    @NonNull ConnectivityManager connectivityManager) {

  checkNotNull(network, "network");
  checkNotNull(connectivityManager, "manager");

  final NetworkInfo networkInfo = getNetworkInfo(network, connectivityManager);
  final NetworkCapabilities capabilities = getCapabilities(network, connectivityManager);

  return networkInfo != null ? builder(networkInfo).networkCapabilities(capabilities).build()
                             : create();
}

@RequiresApi(LOLLIPOP)
@Nullable
static NetworkCapabilities getCapabilities(@NonNull Network network,
    @NonNull ConnectivityManager connectivityManager) {

  NetworkCapabilities networkCapabilities = null;

  try {
    networkCapabilities = connectivityManager.getNetworkCapabilities(network);
  } catch (Exception exc) {
    logger.log(WARNING,
        "Could not retrieve network capabilities from provided network: " + exc.getMessage());
  }

  return networkCapabilities;
}

public static NetworkCapabilities newInstance(long networkCapabilities, long transportTypes,
    int linkUpBandwidthKbps, int linkDownBandwidthKbps, String networkSpecifier,
    int signalStrength) {

  NetworkCapabilities nc = Shadow.newInstanceOf(NetworkCapabilities.class);
  final ShadowNetworkCapabilities capabilities = Shadow.extract(nc);

  capabilities.mNetworkCapabilities = networkCapabilities;
  capabilities.mTransportTypes = transportTypes;
  capabilities.mLinkUpBandwidthKbps = linkUpBandwidthKbps;
  capabilities.mLinkDownBandwidthKbps = linkDownBandwidthKbps;
  capabilities.mNetworkSpecifier = networkSpecifier;
  capabilities.mSignalStrength = signalStrength;
  return nc;
}

private void registerNetworkCallback(Context context) {
  final ConnectivityManager manager =
      (ConnectivityManager) context.getSystemService(CONNECTIVITY_SERVICE);
  manager.registerNetworkCallback(
      new NetworkRequest.Builder()
          .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
          .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
          .build(),
      new NetworkCallback() {
        @Override
        public void onAvailable(Network network) {
          mSambaClient.reset();
        }
      });
}

@TargetApi(LOLLIPOP)
void bindToNetwork(final String networkSSID, final NetworkStateChangeListener listener) {
    if (SDK_INT < LOLLIPOP) {
        logger.i("SDK version is below Lollipop. No need to bind process to network. Skipping...");
        return;
    }
    logger.i("Currently active network is not " + networkSSID + ", would bind the app to use this when available");

    NetworkRequest request = new NetworkRequest.Builder()
            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI).build();
    networkCallback = networkCallback(networkSSID, listener);
    manager.registerNetworkCallback(request, networkCallback);
}

@Override
protected void onResume() {
    super.onResume();
    // Register network callbacks
    ConnectivityManager connectivityManager =
            (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
    networkCallback = new NetworkCallback(this);

    NetworkRequest.Builder networkRequestBuilder = new NetworkRequest.Builder();
    networkRequestBuilder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
    connectivityManager.registerNetworkCallback(
            networkRequestBuilder.build(), networkCallback);

}

@Override
public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
    super.onCapabilitiesChanged(network, networkCapabilities);
    if (!networkCapabilities.toString().equals(mLastNetworkCapabilities)) {
        mLastNetworkCapabilities = networkCapabilities.toString();
        VpnStatus.logDebug(String.format("Network capabilities of %s: %s", network, networkCapabilities));
    }
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
private void bringUpCellularNetwork() {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP)
        return;

    // Wait until the drone is connected.
    if(drone == null || !drone.isConnected())
        return;

    Timber.i("Setting up cellular network request.");
    final ConnectivityManager connMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    final NetworkRequest networkReq = new NetworkRequest.Builder()
            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
            .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
            .build();

    connMgr.requestNetwork(networkReq, new ConnectivityManager.NetworkCallback() {
        @Override
        public void onAvailable(Network network) {
            Timber.i("Setting up process default network: %s", network);
            boolean wasBound;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                wasBound = connMgr.bindProcessToNetwork(network);
            } else {
                wasBound = ConnectivityManager.setProcessDefaultNetwork(network);
            }
            DroidPlannerApp.setCellularNetworkAvailability(wasBound);
        }
    });
}

@SuppressWarnings("deprecation")
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void requestNetwork(Context context) {
    if (!Utils.postVersion(Build.VERSION_CODES.LOLLIPOP)) {
        return;
    }

    setUpConnectivityManager(context);
    NetworkRequest.Builder builder = new NetworkRequest.Builder();
    builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
    builder.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);

    if (mCallback != null) {
        try {
            mConnectivityManager.unregisterNetworkCallback(mCallback);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }
    }
    mCallback = new ConnectivityManager.NetworkCallback() {

        @Override
        public void onAvailable(Network network) {
            if (mCallback != null) {
                if (Utils.postVersion(Build.VERSION_CODES.M)) {
                    mConnectivityManager.bindProcessToNetwork(network);
                } else {
                    ConnectivityManager.setProcessDefaultNetwork(network);
                }
            }
        }
    };

    mConnectivityManager.requestNetwork(builder.build(), mCallback);
}

private static SocketFactory getWifiSocketFactory(final Context context) {
    SocketFactory socketFactory = SocketFactory.getDefault();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !isGalaxyDevice()) {
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        Network[] allNetwork = cm.getAllNetworks();
        for (Network network : allNetwork) {
            NetworkCapabilities networkCapabilities = cm.getNetworkCapabilities(network);
            if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                socketFactory = network.getSocketFactory();
            }
        }
    }
    return socketFactory;
}

@TargetApi(21)
private void selectWifiNetwork(ConnectivityManager cManager) {
    Network[] networks = cManager.getAllNetworks();
    for (Network network : networks) {
        NetworkCapabilities networkCapabilities = cManager.getNetworkCapabilities(network);
        if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
            ConnectivityManager.setProcessDefaultNetwork(network);
        }
    }
}