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