Java Code Examples for android.net.ConnectivityManager#NetworkCallback

private void waitForSomeNetworkToConnect() throws Exception {
  final SettableFuture<Void> future = SettableFuture.create();

  ConnectivityManager.NetworkCallback cb =
      new ConnectivityManager.NetworkCallback() {
        @Override
        public void onAvailable(Network network) {
          NetworkInfo netInfo = connManager.getNetworkInfo(network);
          if (netInfo != null && netInfo.isConnected()) {
            future.set(null);
          }
        }
      };

  connManager.requestNetwork(
      new NetworkRequest.Builder().addCapability(NET_CAPABILITY_INTERNET).build(), cb);

  try {
    future.get(NETWORK_STATE_CHANGE_TIMEOUT_SECONDS, TimeUnit.SECONDS);
  } finally {
    connManager.unregisterNetworkCallback(cb);
  }
}
 

@Implementation(minSdk = LOLLIPOP)
@Override
public void unregisterNetworkCallback(ConnectivityManager.NetworkCallback networkCallback) {
  if (getApiLevel() >= N) {
    if (networkCallback != null || defaultNetworkCallbacks.contains(networkCallback)) {
      defaultNetworkCallbacks.remove(networkCallback);
    }
  }
  super.unregisterNetworkCallback(networkCallback);
}
 

private void registerTrackMobileCallback() {
    final NetworkRequest request = new NetworkRequest.Builder()
            .addCapability(NET_CAPABILITY_INTERNET)
            .addTransportType(TRANSPORT_CELLULAR)
            .build();
    mMobileNetworkCallback = new ConnectivityManager.NetworkCallback() {
        @Override
        public void onCapabilitiesChanged(Network network, NetworkCapabilities nc) {
            MultipathTracker existing = mMultipathTrackers.get(network);
            if (existing != null) {
                existing.setNetworkCapabilities(nc);
                existing.updateMultipathBudget();
                return;
            }

            try {
                mMultipathTrackers.put(network, new MultipathTracker(network, nc));
            } catch (IllegalStateException e) {
                Slog.e(TAG, "Can't track mobile network " + network + ": " + e.getMessage());
            }
            if (DBG) Slog.d(TAG, "Tracking mobile network " + network);
        }

        @Override
        public void onLost(Network network) {
            MultipathTracker existing = mMultipathTrackers.get(network);
            if (existing != null) {
                existing.shutdown();
                mMultipathTrackers.remove(network);
            }
            if (DBG) Slog.d(TAG, "No longer tracking mobile network " + network);
        }
    };

    mCM.registerNetworkCallback(request, mMobileNetworkCallback, mHandler);
}
 

@RequiresPermission(Manifest.permission.ACCESS_NETWORK_STATE)
private void enableOnlyWifiNetwork() {

    Log.d(TAG, "enableOnlyWifiNetwork()");

    NetworkRequest.Builder request = new NetworkRequest.Builder();
    request.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);

    networkCallback = new ConnectivityManager.NetworkCallback() {

        @Override
        public void onAvailable(Network network) {

            Log.e(TAG, "Network is available - 3");
            connectivityManager.bindProcessToNetwork(network);
        }

        @Override
        public void onUnavailable() {
            super.onUnavailable();
            Log.e(TAG, "Network is Unavailable - 3");
        }

        @Override
        public void onLost(@NonNull Network network) {
            super.onLost(network);
            Log.e(TAG, "Lost Network Connection - 3");
        }
    };
    connectivityManager.registerNetworkCallback(request.build(), networkCallback);
}
 

@TargetApi(21)
@Override
public void setImageUrl(String url, ImageLoader imageLoader) {
    mShowLocal = TextUtils.isEmpty(url);
    if (mDiskCache.get(url) == null && !OnlineAccessVerifier.check(getContext())) {
        this.setImageBitmap(null);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            final ConnectivityManager cm = (ConnectivityManager)
                    getContext().getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
            networkCallback = new ConnectivityManager.NetworkCallback() {
                @Override
                public void onAvailable(Network network) {
                    super.onAvailable(network);
                    new CoverArtLoader((MainActivity) FadeInNetworkImageView.this.getActivity()).execute(mLyrics);
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && networkCallback != null)
                        try {
                            cm.unregisterNetworkCallback(networkCallback);
                        } catch (IllegalArgumentException ignored) {
                        }
                }
            };
            NetworkRequest request = new NetworkRequest.Builder()
                    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build();
            cm.registerNetworkCallback(request, networkCallback);
        }
        defaultShown = true;
    } else {
        super.setImageUrl(url, imageLoader);
        if (!TextUtils.isEmpty(url))
            defaultShown = false;
    }
}
 

@Implementation(minSdk = LOLLIPOP)
@Override
public void unregisterNetworkCallback(ConnectivityManager.NetworkCallback networkCallback) {
  if (getApiLevel() >= N) {
    if (networkCallback != null || defaultNetworkCallbacks.contains(networkCallback)) {
      defaultNetworkCallbacks.remove(networkCallback);
    }
  }
  super.unregisterNetworkCallback(networkCallback);
}
 

private void notifyDefaultNetworkCallbacksOnAvailable(Network network) {
  for (ConnectivityManager.NetworkCallback networkCallback : defaultNetworkCallbacks) {
    networkCallback.onAvailable(network);
  }
}
 

private void notifyDefaultNetworkCallbacksOnLost(Network network) {
  for (ConnectivityManager.NetworkCallback networkCallback : defaultNetworkCallbacks) {
    networkCallback.onLost(network);
  }
}
 

@Implementation(minSdk = N)
protected void registerDefaultNetworkCallback(
    ConnectivityManager.NetworkCallback networkCallback) {
  defaultNetworkCallbacks.add(networkCallback);
}
 

private void requestHighBandwidthNetwork() {
    // Before requesting a high-bandwidth network, ensure prior requests are invalidated.
    unregisterNetworkCallback();

    Log.d(LOG_TAG, "Requesting high-bandwidth network");

    // Requesting an unmetered network may prevent you from connecting to the cellular
    // network on the user's watch or phone; however, unless you explicitly ask for permission
    // to a access the user's cellular network, you should request an unmetered network.
    NetworkRequest request = new NetworkRequest.Builder()
            .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
            .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
            .build();

    mNetworkCallback = new ConnectivityManager.NetworkCallback() {
        @Override
        public void onAvailable(final Network network) {
            mTimeOutHandler.removeMessages(MESSAGE_CONNECTIVITY_TIMEOUT);

            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    // requires android.permission.INTERNET
                    if (!mConnectivityManager.bindProcessToNetwork(network)) {
                        Log.e(LOG_TAG, "ConnectivityManager.bindProcessToNetwork()"
                                + " requires android.permission.INTERNET");
                        setUiState(UI_STATE_REQUEST_NETWORK);
                    } else {
                        Log.d(LOG_TAG, "Network available");
                        setUiState(UI_STATE_NETWORK_CONNECTED);
                    }
                }
            });
        }

        @Override
        public void onCapabilitiesChanged(Network network,
                                          NetworkCapabilities networkCapabilities) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Log.d(LOG_TAG, "Network capabilities changed");
                }
            });
        }

        @Override
        public void onLost(Network network) {
            Log.d(LOG_TAG, "Network lost");

            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    setUiState(UI_STATE_REQUEST_NETWORK);
                }
            });
        }
    };

    // requires android.permission.CHANGE_NETWORK_STATE
    mConnectivityManager.requestNetwork(request, mNetworkCallback);

    mTimeOutHandler.sendMessageDelayed(
            mTimeOutHandler.obtainMessage(MESSAGE_CONNECTIVITY_TIMEOUT),
            NETWORK_CONNECTIVITY_TIMEOUT_MS);
}
 

@RequiresApi(Build.VERSION_CODES.Q)
private static boolean connectAndroidQ(@Nullable ConnectivityManager connectivityManager, @NonNull ScanResult scanResult, @NonNull String password) {
    if (connectivityManager == null) {
        return false;
    }

    WifiNetworkSpecifier.Builder wifiNetworkSpecifierBuilder = new WifiNetworkSpecifier.Builder()
            .setSsid(scanResult.SSID)
            .setBssid(MacAddress.fromString(scanResult.BSSID));

    final String security = ConfigSecurities.getSecurity(scanResult);

    ConfigSecurities.setupWifiNetworkSpecifierSecurities(wifiNetworkSpecifierBuilder, security, password);


    NetworkRequest networkRequest = new NetworkRequest.Builder()
            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
            .setNetworkSpecifier(wifiNetworkSpecifierBuilder.build())
            .build();

    // not sure, if this is needed
    if (networkCallback != null) {
        connectivityManager.unregisterNetworkCallback(networkCallback);
    }

    networkCallback = new ConnectivityManager.NetworkCallback() {
        @Override
        public void onAvailable(@NonNull Network network) {
            super.onAvailable(network);

            wifiLog("AndroidQ+ connected to wifi ");

            // bind so all api calls are performed over this new network
            connectivityManager.bindProcessToNetwork(network);
        }

        @Override
        public void onUnavailable() {
            super.onUnavailable();

            wifiLog("AndroidQ+ could not connect to wifi");
        }
    };

    connectivityManager.requestNetwork(networkRequest, networkCallback);

    return true;
}
 

public void setNetworkCallback(ConnectivityManager.NetworkCallback networkCallback) {
    this.networkCallback = networkCallback;
}
 

public void setNetworkCallback(ConnectivityManager.NetworkCallback networkCallback) {
    this.networkCallback = networkCallback;
}
 

private void notifyDefaultNetworkCallbacksOnAvailable(Network network) {
  for (ConnectivityManager.NetworkCallback networkCallback : defaultNetworkCallbacks) {
    networkCallback.onAvailable(network);
  }
}
 

private void notifyDefaultNetworkCallbacksOnLost(Network network) {
  for (ConnectivityManager.NetworkCallback networkCallback : defaultNetworkCallbacks) {
    networkCallback.onLost(network);
  }
}
 

@Implementation(minSdk = N)
@Override
protected void registerDefaultNetworkCallback(
    ConnectivityManager.NetworkCallback networkCallback) {
  defaultNetworkCallbacks.add(networkCallback);
}