FileDocCategorySizeDatePackage
ConnectivityManager.javaAPI DocAndroid 5.1 API101974Thu Mar 12 22:22:10 GMT 2015android.net

ConnectivityManager

public class ConnectivityManager extends Object
Class that answers queries about the state of network connectivity. It also notifies applications when network connectivity changes. Get an instance of this class by calling {@link android.content.Context#getSystemService(String) Context.getSystemService(Context.CONNECTIVITY_SERVICE)}.

The primary responsibilities of this class are to:

  1. Monitor network connections (Wi-Fi, GPRS, UMTS, etc.)
  2. Send broadcast intents when network connectivity changes
  3. Attempt to "fail over" to another network when connectivity to a network is lost
  4. Provide an API that allows applications to query the coarse-grained or fine-grained state of the available networks
  5. Provide an API that allows applications to request and select networks for their data traffic

Fields Summary
private static final String
TAG
public static final String
CONNECTIVITY_ACTION
A change in network connectivity has occurred. A default connection has either been established or lost. The NetworkInfo for the affected network is sent as an extra; it should be consulted to see what kind of connectivity event occurred.

If this is a connection that was the result of failing over from a disconnected network, then the FAILOVER_CONNECTION boolean extra is set to true.

For a loss of connectivity, if the connectivity manager is attempting to connect (or has already connected) to another network, the NetworkInfo for the new network is also passed as an extra. This lets any receivers of the broadcast know that they should not necessarily tell the user that no data traffic will be possible. Instead, the receiver should expect another broadcast soon, indicating either that the failover attempt succeeded (and so there is still overall data connectivity), or that the failover attempt failed, meaning that all connectivity has been lost.

For a disconnect event, the boolean extra EXTRA_NO_CONNECTIVITY is set to {@code true} if there are no connected networks at all.

public static final String
CONNECTIVITY_ACTION_IMMEDIATE
Identical to {@link #CONNECTIVITY_ACTION} broadcast, but sent without any historic {@link Settings.Global#CONNECTIVITY_CHANGE_DELAY}.
public static final String
EXTRA_NETWORK_INFO
The lookup key for a {@link NetworkInfo} object. Retrieve with {@link android.content.Intent#getParcelableExtra(String)}.
public static final String
EXTRA_NETWORK_TYPE
Network type which triggered a {@link #CONNECTIVITY_ACTION} broadcast. Can be used with {@link #getNetworkInfo(int)} to get {@link NetworkInfo} state based on the calling application.
public static final String
EXTRA_IS_FAILOVER
The lookup key for a boolean that indicates whether a connect event is for a network to which the connectivity manager was failing over following a disconnect on another network. Retrieve it with {@link android.content.Intent#getBooleanExtra(String,boolean)}.
public static final String
EXTRA_OTHER_NETWORK_INFO
The lookup key for a {@link NetworkInfo} object. This is supplied when there is another network that it may be possible to connect to. Retrieve with {@link android.content.Intent#getParcelableExtra(String)}.
public static final String
EXTRA_NO_CONNECTIVITY
The lookup key for a boolean that indicates whether there is a complete lack of connectivity, i.e., no network is available. Retrieve it with {@link android.content.Intent#getBooleanExtra(String,boolean)}.
public static final String
EXTRA_REASON
The lookup key for a string that indicates why an attempt to connect to a network failed. The string has no particular structure. It is intended to be used in notifications presented to users. Retrieve it with {@link android.content.Intent#getStringExtra(String)}.
public static final String
EXTRA_EXTRA_INFO
The lookup key for a string that provides optionally supplied extra information about the network state. The information may be passed up from the lower networking layers, and its meaning may be specific to a particular network type. Retrieve it with {@link android.content.Intent#getStringExtra(String)}.
public static final String
EXTRA_INET_CONDITION
The lookup key for an int that provides information about our connection to the internet at large. 0 indicates no connection, 100 indicates a great connection. Retrieve it with {@link android.content.Intent#getIntExtra(String, int)}. {@hide}
public static final String
ACTION_DATA_ACTIVITY_CHANGE
Broadcast action to indicate the change of data activity status (idle or active) on a network in a recent period. The network becomes active when data transmission is started, or idle if there is no data transmission for a period of time. {@hide}
public static final String
EXTRA_DEVICE_TYPE
The lookup key for an enum that indicates the network device type on which this data activity change happens. {@hide}
public static final String
EXTRA_IS_ACTIVE
The lookup key for a boolean that indicates the device is active or not. {@code true} means it is actively sending or receiving data and {@code false} means it is idle. {@hide}
public static final String
EXTRA_REALTIME_NS
The lookup key for a long that contains the timestamp (nanos) of the radio state change. {@hide}
public static final String
ACTION_BACKGROUND_DATA_SETTING_CHANGED
Broadcast Action: The setting for background data usage has changed values. Use {@link #getBackgroundDataSetting()} to get the current value.

If an application uses the network in the background, it should listen for this broadcast and stop using the background data if the value is {@code false}.

public static final String
INET_CONDITION_ACTION
Broadcast Action: The network connection may not be good uses {@code ConnectivityManager.EXTRA_INET_CONDITION} and {@code ConnectivityManager.EXTRA_NETWORK_INFO} to specify the network and it's condition.
public static final String
ACTION_TETHER_STATE_CHANGED
Broadcast Action: A tetherable connection has come or gone. Uses {@code ConnectivityManager.EXTRA_AVAILABLE_TETHER}, {@code ConnectivityManager.EXTRA_ACTIVE_TETHER} and {@code ConnectivityManager.EXTRA_ERRORED_TETHER} to indicate the current state of tethering. Each include a list of interface names in that state (may be empty).
public static final String
EXTRA_AVAILABLE_TETHER
public static final String
EXTRA_ACTIVE_TETHER
public static final String
EXTRA_ERRORED_TETHER
public static final String
ACTION_CAPTIVE_PORTAL_TEST_COMPLETED
Broadcast Action: The captive portal tracker has finished its test. Sent only while running Setup Wizard, in lieu of showing a user notification.
public static final String
EXTRA_IS_CAPTIVE_PORTAL
The lookup key for a boolean that indicates whether a captive portal was detected. Retrieve it with {@link android.content.Intent#getBooleanExtra(String,boolean)}.
public static final int
TYPE_NONE
The absence of a connection type.
public static final int
TYPE_MOBILE
The Mobile data connection. When active, all data traffic will use this network type's interface by default (it has a default route)
public static final int
TYPE_WIFI
The WIFI data connection. When active, all data traffic will use this network type's interface by default (it has a default route).
public static final int
TYPE_MOBILE_MMS
An MMS-specific Mobile data connection. This network type may use the same network interface as {@link #TYPE_MOBILE} or it may use a different one. This is used by applications needing to talk to the carrier's Multimedia Messaging Service servers.
public static final int
TYPE_MOBILE_SUPL
A SUPL-specific Mobile data connection. This network type may use the same network interface as {@link #TYPE_MOBILE} or it may use a different one. This is used by applications needing to talk to the carrier's Secure User Plane Location servers for help locating the device.
public static final int
TYPE_MOBILE_DUN
A DUN-specific Mobile data connection. This network type may use the same network interface as {@link #TYPE_MOBILE} or it may use a different one. This is sometimes by the system when setting up an upstream connection for tethering so that the carrier is aware of DUN traffic.
public static final int
TYPE_MOBILE_HIPRI
A High Priority Mobile data connection. This network type uses the same network interface as {@link #TYPE_MOBILE} but the routing setup is different. Only requesting processes will have access to the Mobile DNS servers and only IP's explicitly requested via {@link #requestRouteToHost} will route over this interface if no default route exists.
public static final int
TYPE_WIMAX
The WiMAX data connection. When active, all data traffic will use this network type's interface by default (it has a default route).
public static final int
TYPE_BLUETOOTH
The Bluetooth data connection. When active, all data traffic will use this network type's interface by default (it has a default route).
public static final int
TYPE_DUMMY
Dummy data connection. This should not be used on shipping devices.
public static final int
TYPE_ETHERNET
The Ethernet data connection. When active, all data traffic will use this network type's interface by default (it has a default route).
public static final int
TYPE_MOBILE_FOTA
Over the air Administration. {@hide}
public static final int
TYPE_MOBILE_IMS
IP Multimedia Subsystem. {@hide}
public static final int
TYPE_MOBILE_CBS
Carrier Branded Services. {@hide}
public static final int
TYPE_WIFI_P2P
A Wi-Fi p2p connection. Only requesting processes will have access to the peers connected. {@hide}
public static final int
TYPE_MOBILE_IA
The network to use for initially attaching to the network {@hide}
public static final int
TYPE_MOBILE_EMERGENCY
Emergency PDN connection for emergency calls {@hide}
public static final int
TYPE_PROXY
The network that uses proxy to achieve connectivity. {@hide}
public static final int
TYPE_VPN
A virtual network using one or more native bearers. It may or may not be providing security services.
public static final int
MAX_RADIO_TYPE
{@hide}
public static final int
MAX_NETWORK_TYPE
{@hide}
public static final int
DEFAULT_NETWORK_PREFERENCE
If you want to set the default network preference,you can directly change the networkAttributes array in framework's config.xml.
public static final int
REQUEST_ID_UNSET
public static final int
NETID_UNSET
A NetID indicating no Network is selected. Keep in sync with bionic/libc/dns/include/resolv_netid.h
private final IConnectivityManager
mService
private static ConnectivityManager
sInstance
A kludge to facilitate static access where a Context pointer isn't available, like in the case of the static set/getProcessDefaultNetwork methods and from the Network class. TODO: Remove this after deprecating the static methods in favor of non-static methods or methods that take a Context argument.
private android.os.INetworkManagementService
mNMService
private static HashMap
sLegacyRequests
private final android.util.ArrayMap
mNetworkActivityListeners
public static final int
TETHER_ERROR_NO_ERROR
{@hide}
public static final int
TETHER_ERROR_UNKNOWN_IFACE
{@hide}
public static final int
TETHER_ERROR_SERVICE_UNAVAIL
{@hide}
public static final int
TETHER_ERROR_UNSUPPORTED
{@hide}
public static final int
TETHER_ERROR_UNAVAIL_IFACE
{@hide}
public static final int
TETHER_ERROR_MASTER_ERROR
{@hide}
public static final int
TETHER_ERROR_TETHER_IFACE_ERROR
{@hide}
public static final int
TETHER_ERROR_UNTETHER_IFACE_ERROR
{@hide}
public static final int
TETHER_ERROR_ENABLE_NAT_ERROR
{@hide}
public static final int
TETHER_ERROR_DISABLE_NAT_ERROR
{@hide}
public static final int
TETHER_ERROR_IFACE_CFG_ERROR
{@hide}
private static final int
BASE
public static final int
CALLBACK_PRECHECK
public static final int
CALLBACK_AVAILABLE
public static final int
CALLBACK_LOSING
public static final int
CALLBACK_LOST
public static final int
CALLBACK_UNAVAIL
public static final int
CALLBACK_CAP_CHANGED
public static final int
CALLBACK_IP_CHANGED
public static final int
CALLBACK_RELEASED
public static final int
CALLBACK_EXIT
private static final int
EXPIRE_LEGACY_REQUEST
static final HashMap
sNetworkCallback
static final AtomicInteger
sCallbackRefCount
static CallbackHandler
sCallbackHandler
private static final int
LISTEN
private static final int
REQUEST
public static final int
MAX_NETWORK_REQUEST_TIMEOUT_MS
The maximum number of milliseconds the framework will look for a suitable network during a timeout-equiped call to {@link requestNetwork}. {@hide}
public static final String
EXTRA_NETWORK
The lookup key for a {@link Network} object included with the intent after successfully finding a network for the applications request. Retrieve it with {@link android.content.Intent#getParcelableExtra(String)}.

Note that if you intend to invoke (@link #setProcessDefaultNetwork(Network)) or {@link Network#openConnection(java.net.URL)} then you must get a ConnectivityManager instance before doing so.

public static final String
EXTRA_NETWORK_REQUEST
The lookup key for a {@link NetworkRequest} object included with the intent after successfully finding a network for the applications request. Retrieve it with {@link android.content.Intent#getParcelableExtra(String)}.
Constructors Summary
public ConnectivityManager(IConnectivityManager service)
{@hide}

        mService = checkNotNull(service, "missing IConnectivityManager");
        sInstance = this;
Methods Summary
public voidaddDefaultNetworkActiveListener(android.net.ConnectivityManager$OnNetworkActiveListener l)
Start listening to reports when the system's default data network is active, meaning it is a good time to perform network traffic. Use {@link #isDefaultNetworkActive()} to determine the current state of the system's default network after registering the listener.

If the process default network has been set with {@link ConnectivityManager#setProcessDefaultNetwork} this function will not reflect the process's default, but the system default.

param
l The listener to be told when the network is active.


                                                                                     
         
        INetworkActivityListener rl = new INetworkActivityListener.Stub() {
            @Override
            public void onNetworkActive() throws RemoteException {
                l.onNetworkActive();
            }
        };

        try {
            getNetworkManagementService().registerNetworkActivityListener(rl);
            mNetworkActivityListeners.put(l, rl);
        } catch (RemoteException e) {
        }
public voidcaptivePortalCheckCompleted(NetworkInfo info, boolean isCaptivePortal)
Signal that the captive portal check on the indicated network is complete and whether its a captive portal or not.

param
info the {@link NetworkInfo} object for the networkType in question.
param
isCaptivePortal true/false.

This method requires the call to hold the permission {@link android.Manifest.permission#CONNECTIVITY_INTERNAL}. {@hide}

        try {
            mService.captivePortalCheckCompleted(info, isCaptivePortal);
        } catch (RemoteException e) {
        }
public intcheckMobileProvisioning(int suggestedTimeOutMs)
Check mobile provisioning.

param
suggestedTimeOutMs, timeout in milliseconds
return
time out that will be used, maybe less that suggestedTimeOutMs -1 if an error. {@hide}

        int timeOutMs = -1;
        try {
            timeOutMs = mService.checkMobileProvisioning(suggestedTimeOutMs);
        } catch (RemoteException e) {
        }
        return timeOutMs;
private voidcheckPendingIntent(android.app.PendingIntent intent)

        if (intent == null) {
            throw new IllegalArgumentException("PendingIntent cannot be null.");
        }
private voiddecCallbackHandlerRefCount()

        synchronized(sCallbackRefCount) {
            if (sCallbackRefCount.decrementAndGet() == 0) {
                sCallbackHandler.obtainMessage(CALLBACK_EXIT).sendToTarget();
                sCallbackHandler = null;
            }
        }
public static final voidenforceTetherChangePermission(android.content.Context context)
{@hide

        if (context.getResources().getStringArray(
                com.android.internal.R.array.config_mobile_hotspot_provision_app).length == 2) {
            // Have a provisioning app - must only let system apps (which check this app)
            // turn on tethering
            context.enforceCallingOrSelfPermission(
                    android.Manifest.permission.CONNECTIVITY_INTERNAL, "ConnectivityService");
        } else {
            context.enforceCallingOrSelfPermission(
                    android.Manifest.permission.CHANGE_NETWORK_STATE, "ConnectivityService");
        }
private voidexpireRequest(NetworkCapabilities netCap, int sequenceNum)

        int ourSeqNum = -1;
        synchronized (sLegacyRequests) {
            LegacyRequest l = sLegacyRequests.get(netCap);
            if (l == null) return;
            ourSeqNum = l.expireSequenceNumber;
            if (l.expireSequenceNumber == sequenceNum) removeRequestForFeature(netCap);
        }
        Log.d(TAG, "expireRequest with " + ourSeqNum + ", " + sequenceNum);
private NetworkRequestfindRequestForFeature(NetworkCapabilities netCap)


        
        synchronized (sLegacyRequests) {
            LegacyRequest l = sLegacyRequests.get(netCap);
            if (l != null) return l.networkRequest;
        }
        return null;
public static android.net.ConnectivityManagerfrom(android.content.Context context)
{@hide}

        return (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
public LinkPropertiesgetActiveLinkProperties()
Returns the IP information for the current default network.

return
a {@link LinkProperties} object describing the IP info for the current default network, or {@code null} if there is no current default network.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.getActiveLinkProperties();
        } catch (RemoteException e) {
            return null;
        }
public NetworkInfogetActiveNetworkInfo()
Returns details about the currently active default data network. When connected, this network is the default route for outgoing connections. You should always check {@link NetworkInfo#isConnected()} before initiating network traffic. This may return {@code null} when there is no default network.

return
a {@link NetworkInfo} object for the current default network or {@code null} if no network default network is currently active

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

        try {
            return mService.getActiveNetworkInfo();
        } catch (RemoteException e) {
            return null;
        }
public NetworkInfogetActiveNetworkInfoForUid(int uid)
Returns details about the currently active default data network for a given uid. This is for internal use only to avoid spying other apps.

return
a {@link NetworkInfo} object for the current default network for the given uid or {@code null} if no default network is available for the specified uid.

This method requires the caller to hold the permission {@link android.Manifest.permission#CONNECTIVITY_INTERNAL} {@hide}

        try {
            return mService.getActiveNetworkInfoForUid(uid);
        } catch (RemoteException e) {
            return null;
        }
public NetworkQuotaInfogetActiveNetworkQuotaInfo()
Return quota status for the current active network, or {@code null} if no network is active. Quota status can change rapidly, so these values shouldn't be cached.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

hide

        try {
            return mService.getActiveNetworkQuotaInfo();
        } catch (RemoteException e) {
            return null;
        }
public NetworkInfo[]getAllNetworkInfo()
Returns connection status information about all network types supported by the device.

return
an array of {@link NetworkInfo} objects. Check each {@link NetworkInfo#getType} for which type each applies.

This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

        try {
            return mService.getAllNetworkInfo();
        } catch (RemoteException e) {
            return null;
        }
public Network[]getAllNetworks()
Returns an array of all {@link Network} currently tracked by the framework.

return
an array of {@link Network} objects.

This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

        try {
            return mService.getAllNetworks();
        } catch (RemoteException e) {
            return null;
        }
public booleangetBackgroundDataSetting()
Returns the value of the setting for background data usage. If false, applications should not use the network if the application is not in the foreground. Developers should respect this setting, and check the value of this before performing any background data operations.

All applications that have background services that use the network should listen to {@link #ACTION_BACKGROUND_DATA_SETTING_CHANGED}.

deprecated
As of {@link VERSION_CODES#ICE_CREAM_SANDWICH}, availability of background data depends on several combined factors, and this method will always return {@code true}. Instead, when background data is unavailable, {@link #getActiveNetworkInfo()} will now appear disconnected.
return
Whether background data usage is allowed.

        // assume that background data is allowed; final authority is
        // NetworkInfo which may be blocked.
        return true;
public NetworkCapabilities[]getDefaultNetworkCapabilitiesForUser(int userId)
Returns an array of of {@link NetworkCapabilities} objects, representing the Networks that applications run by the given user will use by default.

hide

        try {
            return mService.getDefaultNetworkCapabilitiesForUser(userId);
        } catch (RemoteException e) {
            return null;
        }
public ProxyInfogetDefaultProxy()
Get the current default HTTP proxy settings. If a global proxy is set it will be returned, otherwise if this process is bound to a {@link Network} using {@link #setProcessDefaultNetwork} then that {@code Network}'s proxy is returned, otherwise the default network's proxy is returned.

return
the {@link ProxyInfo} for the current HTTP proxy, or {@code null} if no HTTP proxy is active.
hide

        final Network network = getProcessDefaultNetwork();
        if (network != null) {
            final ProxyInfo globalProxy = getGlobalProxy();
            if (globalProxy != null) return globalProxy;
            final LinkProperties lp = getLinkProperties(network);
            if (lp != null) return lp.getHttpProxy();
            return null;
        }
        try {
            return mService.getDefaultProxy();
        } catch (RemoteException e) {
            return null;
        }
public ProxyInfogetGlobalProxy()
Retrieve any network-independent global HTTP proxy.

return
{@link ProxyInfo} for the current global HTTP proxy or {@code null} if no global HTTP proxy is set.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

hide

        try {
            return mService.getGlobalProxy();
        } catch (RemoteException e) {
            return null;
        }
public static android.net.ConnectivityManagergetInstance()

deprecated
- use getSystemService. This is a kludge to support static access in certain situations where a Context pointer is unavailable.
hide

        if (sInstance == null) {
            throw new IllegalStateException("No ConnectivityManager yet constructed");
        }
        return sInstance;
public intgetLastTetherError(java.lang.String iface)
Get a more detailed error code after a Tethering or Untethering request asynchronously failed.

param
iface The name of the interface of interest
return
error The error code of the last error tethering or untethering the named interface

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}


                                                                         
        
        try {
            return mService.getLastTetherError(iface);
        } catch (RemoteException e) {
            return TETHER_ERROR_SERVICE_UNAVAIL;
        }
public LinkPropertiesgetLinkProperties(int networkType)
Returns the IP information for a given network type.

param
networkType the network type of interest.
return
a {@link LinkProperties} object describing the IP info for the given networkType, or {@code null} if there is no current default network.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.getLinkPropertiesForType(networkType);
        } catch (RemoteException e) {
            return null;
        }
public LinkPropertiesgetLinkProperties(Network network)
Get the {@link LinkProperties} for the given {@link Network}. This will return {@code null} if the network is unknown.

param
network The {@link Network} object identifying the network in question.
return
The {@link LinkProperties} for the network, or {@code null}.

        try {
            return mService.getLinkProperties(network);
        } catch (RemoteException e) {
            return null;
        }
public booleangetMobileDataEnabled()

hide
deprecated
Talk to TelephonyManager directly

        IBinder b = ServiceManager.getService(Context.TELEPHONY_SERVICE);
        if (b != null) {
            try {
                ITelephony it = ITelephony.Stub.asInterface(b);
                int subId = SubscriptionManager.getDefaultDataSubId();
                Log.d("ConnectivityManager", "getMobileDataEnabled()+ subId=" + subId);
                boolean retVal = it.getDataEnabled(subId);
                Log.d("ConnectivityManager", "getMobileDataEnabled()- subId=" + subId
                        + " retVal=" + retVal);
                return retVal;
            } catch (RemoteException e) { }
        }
        Log.d("ConnectivityManager", "getMobileDataEnabled()- remote exception retVal=false");
        return false;
public java.lang.StringgetMobileProvisioningUrl()
Get the mobile provisioning url. {@hide}

        try {
            return mService.getMobileProvisioningUrl();
        } catch (RemoteException e) {
        }
        return null;
public java.lang.StringgetMobileRedirectedProvisioningUrl()
Get the mobile redirected provisioning url. {@hide}

        try {
            return mService.getMobileRedirectedProvisioningUrl();
        } catch (RemoteException e) {
        }
        return null;
public NetworkCapabilitiesgetNetworkCapabilities(Network network)
Get the {@link NetworkCapabilities} for the given {@link Network}. This will return {@code null} if the network is unknown.

param
network The {@link Network} object identifying the network in question.
return
The {@link NetworkCapabilities} for the network, or {@code null}.

        try {
            return mService.getNetworkCapabilities(network);
        } catch (RemoteException e) {
            return null;
        }
public NetworkgetNetworkForType(int networkType)
Returns the {@link Network} object currently serving a given type, or null if the given type is not connected.

This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

hide

        try {
            return mService.getNetworkForType(networkType);
        } catch (RemoteException e) {
            return null;
        }
public NetworkInfogetNetworkInfo(Network network)
Returns connection status information about a particular Network.

param
network {@link Network} specifying which network in which you're interested.
return
a {@link NetworkInfo} object for the requested network or {@code null} if the {@code Network} is not valid.

This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

        try {
            return mService.getNetworkInfoForNetwork(network);
        } catch (RemoteException e) {
            return null;
        }
public NetworkInfogetNetworkInfo(int networkType)
Returns connection status information about a particular network type.

param
networkType integer specifying which networkType in which you're interested.
return
a {@link NetworkInfo} object for the requested network type or {@code null} if the type is not supported by the device.

This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

        try {
            return mService.getNetworkInfo(networkType);
        } catch (RemoteException e) {
            return null;
        }
private android.os.INetworkManagementServicegetNetworkManagementService()

        synchronized (this) {
            if (mNMService != null) {
                return mNMService;
            }
            IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
            mNMService = INetworkManagementService.Stub.asInterface(b);
            return mNMService;
        }
public intgetNetworkPreference()
Retrieves the current preferred network type.

return
an integer representing the preferred network type

This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

deprecated
Functionality has been removed as it no longer makes sense, with many more than two networks - we'd need an array to express preference. Instead we use dynamic network properties of the networks to describe their precedence.

        return TYPE_NONE;
public static java.lang.StringgetNetworkTypeName(int type)
Returns a non-localized string representing a given network type. ONLY used for debugging output.

param
type the type needing naming
return
a String for the given type, or a string version of the type ("87") if no name is known. {@hide}

        switch (type) {
            case TYPE_MOBILE:
                return "MOBILE";
            case TYPE_WIFI:
                return "WIFI";
            case TYPE_MOBILE_MMS:
                return "MOBILE_MMS";
            case TYPE_MOBILE_SUPL:
                return "MOBILE_SUPL";
            case TYPE_MOBILE_DUN:
                return "MOBILE_DUN";
            case TYPE_MOBILE_HIPRI:
                return "MOBILE_HIPRI";
            case TYPE_WIMAX:
                return "WIMAX";
            case TYPE_BLUETOOTH:
                return "BLUETOOTH";
            case TYPE_DUMMY:
                return "DUMMY";
            case TYPE_ETHERNET:
                return "ETHERNET";
            case TYPE_MOBILE_FOTA:
                return "MOBILE_FOTA";
            case TYPE_MOBILE_IMS:
                return "MOBILE_IMS";
            case TYPE_MOBILE_CBS:
                return "MOBILE_CBS";
            case TYPE_WIFI_P2P:
                return "WIFI_P2P";
            case TYPE_MOBILE_IA:
                return "MOBILE_IA";
            case TYPE_MOBILE_EMERGENCY:
                return "MOBILE_EMERGENCY";
            case TYPE_PROXY:
                return "PROXY";
            default:
                return Integer.toString(type);
        }
public static NetworkgetProcessDefaultNetwork()
Returns the {@link Network} currently bound to this process via {@link #setProcessDefaultNetwork}, or {@code null} if no {@link Network} is explicitly bound.

return
{@code Network} to which this process is bound, or {@code null}.

        int netId = NetworkUtils.getNetworkBoundToProcess();
        if (netId == NETID_UNSET) return null;
        return new Network(netId);
public NetworkInfogetProvisioningOrActiveNetworkInfo()
Returns details about the Provisioning or currently active default data network. When connected, this network is the default route for outgoing connections. You should always check {@link NetworkInfo#isConnected()} before initiating network traffic. This may return {@code null} when there is no default network.

return
a {@link NetworkInfo} object for the current default network or {@code null} if no network default network is currently active

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.getProvisioningOrActiveNetworkInfo();
        } catch (RemoteException e) {
            return null;
        }
public java.lang.String[]getTetherableBluetoothRegexs()
Get the list of regular expressions that define any tetherable Bluetooth network interfaces. If Bluetooth tethering is not supported by the device, this list should be empty.

return
an array of 0 or more regular expression Strings defining what interfaces are considered tetherable bluetooth interfaces.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.getTetherableBluetoothRegexs();
        } catch (RemoteException e) {
            return new String[0];
        }
public java.lang.String[]getTetherableIfaces()
Get the set of tetherable, available interfaces. This list is limited by device configuration and current interface existence.

return
an array of 0 or more Strings of tetherable interface names.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.getTetherableIfaces();
        } catch (RemoteException e) {
            return new String[0];
        }
public java.lang.String[]getTetherableUsbRegexs()
Get the list of regular expressions that define any tetherable USB network interfaces. If USB tethering is not supported by the device, this list should be empty.

return
an array of 0 or more regular expression Strings defining what interfaces are considered tetherable usb interfaces.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.getTetherableUsbRegexs();
        } catch (RemoteException e) {
            return new String[0];
        }
public java.lang.String[]getTetherableWifiRegexs()
Get the list of regular expressions that define any tetherable Wifi network interfaces. If Wifi tethering is not supported by the device, this list should be empty.

return
an array of 0 or more regular expression Strings defining what interfaces are considered tetherable wifi interfaces.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.getTetherableWifiRegexs();
        } catch (RemoteException e) {
            return new String[0];
        }
public java.lang.String[]getTetheredDhcpRanges()
Get the set of tethered dhcp ranges.

return
an array of 0 or more {@code String} of tethered dhcp ranges. {@hide}

        try {
            return mService.getTetheredDhcpRanges();
        } catch (RemoteException e) {
            return new String[0];
        }
public java.lang.String[]getTetheredIfaces()
Get the set of tethered interfaces.

return
an array of 0 or more String of currently tethered interface names.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.getTetheredIfaces();
        } catch (RemoteException e) {
            return new String[0];
        }
public java.lang.String[]getTetheringErroredIfaces()
Get the set of interface names which attempted to tether but failed. Re-attempting to tether may cause them to reset to the Tethered state. Alternatively, causing the interface to be destroyed and recreated may cause them to reset to the available state. {@link ConnectivityManager#getLastTetherError} can be used to get more information on the cause of the errors.

return
an array of 0 or more String indicating the interface names which failed to tether.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.getTetheringErroredIfaces();
        } catch (RemoteException e) {
            return new String[0];
        }
private voidincCallbackHandlerRefCount()

        synchronized(sCallbackRefCount) {
            if (sCallbackRefCount.incrementAndGet() == 1) {
                // TODO - switch this over to a ManagerThread or expire it when done
                HandlerThread callbackThread = new HandlerThread("ConnectivityManager");
                callbackThread.start();
                sCallbackHandler = new CallbackHandler(callbackThread.getLooper(),
                        sNetworkCallback, sCallbackRefCount, this);
            }
        }
private intinferLegacyTypeForNetworkCapabilities(NetworkCapabilities netCap)
Guess what the network request was trying to say so that the resulting network is accessible via the legacy (deprecated) API such as requestRouteToHost. This means we should try to be fairly preceise about transport and capability but ignore things such as networkSpecifier. If the request has more than one transport or capability it doesn't match the old legacy requests (they selected only single transport/capability) so this function cannot map the request to a single legacy type and the resulting network will not be available to the legacy APIs. TODO - This should be removed when the legacy APIs are removed.

        if (netCap == null) {
            return TYPE_NONE;
        }

        if (!netCap.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
            return TYPE_NONE;
        }

        String type = null;
        int result = TYPE_NONE;

        if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_CBS)) {
            type = "enableCBS";
            result = TYPE_MOBILE_CBS;
        } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)) {
            type = "enableIMS";
            result = TYPE_MOBILE_IMS;
        } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA)) {
            type = "enableFOTA";
            result = TYPE_MOBILE_FOTA;
        } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)) {
            type = "enableDUN";
            result = TYPE_MOBILE_DUN;
        } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)) {
            type = "enableSUPL";
            result = TYPE_MOBILE_SUPL;
        } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)) {
            type = "enableMMS";
            result = TYPE_MOBILE_MMS;
        } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) {
            type = "enableHIPRI";
            result = TYPE_MOBILE_HIPRI;
        }
        if (type != null) {
            NetworkCapabilities testCap = networkCapabilitiesForFeature(TYPE_MOBILE, type);
            if (testCap.equalsNetCapabilities(netCap) && testCap.equalsTransportTypes(netCap)) {
                return result;
            }
        }
        return TYPE_NONE;
public booleanisActiveNetworkMetered()
Returns if the currently active data network is metered. A network is classified as metered when the user is sensitive to heavy data usage on that connection due to monetary costs, data limitations or battery/performance issues. You should check this before doing large data transfers, and warn the user or delay the operation until another network is available.

return
{@code true} if large transfers should be avoided, otherwise {@code false}.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

        try {
            return mService.isActiveNetworkMetered();
        } catch (RemoteException e) {
            return false;
        }
public booleanisDefaultNetworkActive()
Return whether the data network is currently active. An active network means that it is currently in a high power state for performing data transmission. On some types of networks, it may be expensive to move and stay in such a state, so it is more power efficient to batch network traffic together when the radio is already in this state. This method tells you whether right now is currently a good time to initiate network traffic, as the network is already active.

        try {
            return getNetworkManagementService().isNetworkActive();
        } catch (RemoteException e) {
        }
        return false;
public booleanisNetworkSupported(int networkType)
Returns true if the hardware supports the given network type else it returns false. This doesn't indicate we have coverage or are authorized onto a network, just whether or not the hardware supports it. For example a GSM phone without a SIM should still return {@code true} for mobile data, but a wifi only tablet would return {@code false}.

param
networkType The network type we'd like to check
return
{@code true} if supported, else {@code false}

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}.

hide

        try {
            return mService.isNetworkSupported(networkType);
        } catch (RemoteException e) {}
        return false;
public static booleanisNetworkTypeMobile(int networkType)
Checks if a given type uses the cellular data connection. This should be replaced in the future by a network property.

param
networkType the type to check
return
a boolean - {@code true} if uses cellular network, else {@code false} {@hide}

        switch (networkType) {
            case TYPE_MOBILE:
            case TYPE_MOBILE_MMS:
            case TYPE_MOBILE_SUPL:
            case TYPE_MOBILE_DUN:
            case TYPE_MOBILE_HIPRI:
            case TYPE_MOBILE_FOTA:
            case TYPE_MOBILE_IMS:
            case TYPE_MOBILE_CBS:
            case TYPE_MOBILE_IA:
            case TYPE_MOBILE_EMERGENCY:
                return true;
            default:
                return false;
        }
public static booleanisNetworkTypeValid(int networkType)
Tests if a given integer represents a valid network type.

param
networkType the type to be tested
return
a boolean. {@code true} if the type is valid, else {@code false}


                                        
         
        return networkType >= 0 && networkType <= MAX_NETWORK_TYPE;
public static booleanisNetworkTypeWifi(int networkType)
Checks if the given network type is backed by a Wi-Fi radio.

hide

        switch (networkType) {
            case TYPE_WIFI:
            case TYPE_WIFI_P2P:
                return true;
            default:
                return false;
        }
public booleanisTetheringSupported()
Check if the device allows for tethering. It may be disabled via {@code ro.tether.denied} system property, Settings.TETHER_SUPPORTED or due to device configuration.

return
a boolean - {@code true} indicating Tethering is supported.

This method requires the call to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. {@hide}

        try {
            return mService.isTetheringSupported();
        } catch (RemoteException e) {
            return false;
        }
private intlegacyTypeForNetworkCapabilities(NetworkCapabilities netCap)

        if (netCap == null) return TYPE_NONE;
        if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_CBS)) {
            return TYPE_MOBILE_CBS;
        }
        if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)) {
            return TYPE_MOBILE_IMS;
        }
        if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA)) {
            return TYPE_MOBILE_FOTA;
        }
        if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)) {
            return TYPE_MOBILE_DUN;
        }
        if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)) {
            return TYPE_MOBILE_SUPL;
        }
        if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)) {
            return TYPE_MOBILE_MMS;
        }
        if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) {
            return TYPE_MOBILE_HIPRI;
        }
        if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_WIFI_P2P)) {
            return TYPE_WIFI_P2P;
        }
        return TYPE_NONE;
public static voidmaybeMarkCapabilitiesRestricted(NetworkCapabilities nc)
Removes the NET_CAPABILITY_NOT_RESTRICTED capability from the given NetworkCapabilities object if all the capabilities it provides are typically provided by restricted networks. TODO: consider: - Moving to NetworkCapabilities - Renaming it to guessRestrictedCapability and make it set the restricted capability bit in addition to clearing it.

hide

        for (int capability : nc.getCapabilities()) {
            switch (capability) {
                case NetworkCapabilities.NET_CAPABILITY_CBS:
                case NetworkCapabilities.NET_CAPABILITY_DUN:
                case NetworkCapabilities.NET_CAPABILITY_EIMS:
                case NetworkCapabilities.NET_CAPABILITY_FOTA:
                case NetworkCapabilities.NET_CAPABILITY_IA:
                case NetworkCapabilities.NET_CAPABILITY_IMS:
                case NetworkCapabilities.NET_CAPABILITY_RCS:
                case NetworkCapabilities.NET_CAPABILITY_XCAP:
                case NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED: //there by default
                    continue;
                default:
                    // At least one capability usually provided by unrestricted
                    // networks. Conclude that this network is unrestricted.
                    return;
            }
        }
        // All the capabilities are typically provided by restricted networks.
        // Conclude that this network is restricted.
        nc.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);
private NetworkCapabilitiesnetworkCapabilitiesForFeature(int networkType, java.lang.String feature)

        if (networkType == TYPE_MOBILE) {
            int cap = -1;
            if ("enableMMS".equals(feature)) {
                cap = NetworkCapabilities.NET_CAPABILITY_MMS;
            } else if ("enableSUPL".equals(feature)) {
                cap = NetworkCapabilities.NET_CAPABILITY_SUPL;
            } else if ("enableDUN".equals(feature) || "enableDUNAlways".equals(feature)) {
                cap = NetworkCapabilities.NET_CAPABILITY_DUN;
            } else if ("enableHIPRI".equals(feature)) {
                cap = NetworkCapabilities.NET_CAPABILITY_INTERNET;
            } else if ("enableFOTA".equals(feature)) {
                cap = NetworkCapabilities.NET_CAPABILITY_FOTA;
            } else if ("enableIMS".equals(feature)) {
                cap = NetworkCapabilities.NET_CAPABILITY_IMS;
            } else if ("enableCBS".equals(feature)) {
                cap = NetworkCapabilities.NET_CAPABILITY_CBS;
            } else {
                return null;
            }
            NetworkCapabilities netCap = new NetworkCapabilities();
            netCap.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR).addCapability(cap);
            maybeMarkCapabilitiesRestricted(netCap);
            return netCap;
        } else if (networkType == TYPE_WIFI) {
            if ("p2p".equals(feature)) {
                NetworkCapabilities netCap = new NetworkCapabilities();
                netCap.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);
                netCap.addCapability(NetworkCapabilities.NET_CAPABILITY_WIFI_P2P);
                maybeMarkCapabilitiesRestricted(netCap);
                return netCap;
            }
        }
        return null;
public voidregisterNetworkAgent(android.os.Messenger messenger, NetworkInfo ni, LinkProperties lp, NetworkCapabilities nc, int score, NetworkMisc misc)
{@hide}

        try {
            mService.registerNetworkAgent(messenger, ni, lp, nc, score, misc);
        } catch (RemoteException e) { }
public voidregisterNetworkCallback(NetworkRequest request, android.net.ConnectivityManager$NetworkCallback networkCallback)
Registers to receive notifications about all networks which satisfy the given {@link NetworkRequest}. The callbacks will continue to be called until either the application exits or {@link #unregisterNetworkCallback} is called

param
request {@link NetworkRequest} describing this request.
param
networkCallback The {@link NetworkCallback} that the system will call as suitable networks change state.

        sendRequestForNetwork(request.networkCapabilities, networkCallback, 0, LISTEN, TYPE_NONE);
public voidregisterNetworkFactory(android.os.Messenger messenger, java.lang.String name)
{@hide}

        try {
            mService.registerNetworkFactory(messenger, name);
        } catch (RemoteException e) { }
public voidreleaseNetworkRequest(android.app.PendingIntent operation)
Removes a request made via {@link #requestNetwork(NetworkRequest, android.app.PendingIntent)}

This method has the same behavior as {@link #unregisterNetworkCallback} with respect to releasing network resources and disconnecting.

param
operation A PendingIntent equal (as defined by {@link Intent#filterEquals}) to the PendingIntent passed to {@link #requestNetwork(NetworkRequest, android.app.PendingIntent)} with the corresponding NetworkRequest you'd like to remove. Cannot be null.

        checkPendingIntent(operation);
        try {
            mService.releasePendingNetworkRequest(operation);
        } catch (RemoteException e) {}
public voidremoveDefaultNetworkActiveListener(android.net.ConnectivityManager$OnNetworkActiveListener l)
Remove network active listener previously registered with {@link #addDefaultNetworkActiveListener}.

param
l Previously registered listener.

        INetworkActivityListener rl = mNetworkActivityListeners.get(l);
        if (rl == null) {
            throw new IllegalArgumentException("Listener not registered: " + l);
        }
        try {
            getNetworkManagementService().unregisterNetworkActivityListener(rl);
        } catch (RemoteException e) {
        }
private booleanremoveRequestForFeature(NetworkCapabilities netCap)

        final LegacyRequest l;
        synchronized (sLegacyRequests) {
            l = sLegacyRequests.remove(netCap);
        }
        if (l == null) return false;
        unregisterNetworkCallback(l.networkCallback);
        l.clearDnsBinding();
        return true;
private voidrenewRequestLocked(android.net.ConnectivityManager$LegacyRequest l)

        l.expireSequenceNumber++;
        Log.d(TAG, "renewing request to seqNum " + l.expireSequenceNumber);
        sendExpireMsgForFeature(l.networkCapabilities, l.expireSequenceNumber, l.delay);
public voidreportBadNetwork(Network network)
Report a problem network to the framework. This provides a hint to the system that there might be connectivity problems on this network and may cause the framework to re-evaluate network connectivity and/or switch to another network.

param
network The {@link Network} the application was attempting to use or {@code null} to indicate the current default network.

        try {
            mService.reportBadNetwork(network);
        } catch (RemoteException e) {
        }
public voidreportInetCondition(int networkType, int percentage)
Report network connectivity status. This is currently used only to alter status bar UI.

param
networkType The type of network you want to report on
param
percentage The quality of the connection 0 is bad, 100 is good

This method requires the call to hold the permission {@link android.Manifest.permission#STATUS_BAR}. {@hide}

        try {
            mService.reportInetCondition(networkType, percentage);
        } catch (RemoteException e) {
        }
public voidrequestNetwork(NetworkRequest request, android.net.ConnectivityManager$NetworkCallback networkCallback)
Request a network to satisfy a set of {@link NetworkCapabilities}. This {@link NetworkRequest} will live until released via {@link #unregisterNetworkCallback} or the calling application exits. Status of the request can be followed by listening to the various callbacks described in {@link NetworkCallback}. The {@link Network} can be used to direct traffic to the network.

param
request {@link NetworkRequest} describing this request.
param
networkCallback The {@link NetworkCallback} to be utilized for this request. Note the callback must not be shared - they uniquely specify this request.

        sendRequestForNetwork(request.networkCapabilities, networkCallback, 0,
                REQUEST, inferLegacyTypeForNetworkCapabilities(request.networkCapabilities));
public voidrequestNetwork(NetworkRequest request, android.net.ConnectivityManager$NetworkCallback networkCallback, int timeoutMs)
Request a network to satisfy a set of {@link NetworkCapabilities}, limited by a timeout. This function behaves identically to the non-timedout version, but if a suitable network is not found within the given time (in milliseconds) the {@link NetworkCallback#unavailable} callback is called. The request must still be released normally by calling {@link releaseNetworkRequest}.

param
request {@link NetworkRequest} describing this request.
param
networkCallback The callbacks to be utilized for this request. Note the callbacks must not be shared - they uniquely specify this request.
param
timeoutMs The time in milliseconds to attempt looking for a suitable network before {@link NetworkCallback#unavailable} is called.
hide

        sendRequestForNetwork(request.networkCapabilities, networkCallback, timeoutMs,
                REQUEST, inferLegacyTypeForNetworkCapabilities(request.networkCapabilities));
public voidrequestNetwork(NetworkRequest request, android.app.PendingIntent operation)
Request a network to satisfy a set of {@link NetworkCapabilities}. This function behaves identically to the version that takes a NetworkCallback, but instead of {@link NetworkCallback} a {@link PendingIntent} is used. This means the request may outlive the calling application and get called back when a suitable network is found.

The operation is an Intent broadcast that goes to a broadcast receiver that you registered with {@link Context#registerReceiver} or through the <receiver> tag in an AndroidManifest.xml file

The operation Intent is delivered with two extras, a {@link Network} typed extra called {@link #EXTRA_NETWORK} and a {@link NetworkRequest} typed extra called {@link #EXTRA_NETWORK_REQUEST} containing the original requests parameters. It is important to create a new, {@link NetworkCallback} based request before completing the processing of the Intent to reserve the network or it will be released shortly after the Intent is processed.

If there is already an request for this Intent registered (with the equality of two Intents defined by {@link Intent#filterEquals}), then it will be removed and replaced by this one, effectively releasing the previous {@link NetworkRequest}.

The request may be released normally by calling {@link #releaseNetworkRequest(android.app.PendingIntent)}.

param
request {@link NetworkRequest} describing this request.
param
operation Action to perform when the network is available (corresponds to the {@link NetworkCallback#onAvailable} call. Typically comes from {@link PendingIntent#getBroadcast}. Cannot be null.



                                                                                                                                                                                                                                                                           
          
        checkPendingIntent(operation);
        try {
            mService.pendingRequestForNetwork(request.networkCapabilities, operation);
        } catch (RemoteException e) {}
private NetworkRequestrequestNetworkForFeatureLocked(NetworkCapabilities netCap)

        int delay = -1;
        int type = legacyTypeForNetworkCapabilities(netCap);
        try {
            delay = mService.getRestoreDefaultNetworkDelay(type);
        } catch (RemoteException e) {}
        LegacyRequest l = new LegacyRequest();
        l.networkCapabilities = netCap;
        l.delay = delay;
        l.expireSequenceNumber = 0;
        l.networkRequest = sendRequestForNetwork(netCap, l.networkCallback, 0,
                REQUEST, type);
        if (l.networkRequest == null) return null;
        sLegacyRequests.put(netCap, l);
        sendExpireMsgForFeature(netCap, l.expireSequenceNumber, delay);
        return l.networkRequest;
public booleanrequestRouteToHost(int networkType, int hostAddress)
Ensure that a network route exists to deliver traffic to the specified host via the specified network interface. An attempt to add a route that already exists is ignored, but treated as successful.

This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}.

param
networkType the type of the network over which traffic to the specified host is to be routed
param
hostAddress the IP address of the host to which the route is desired
return
{@code true} on success, {@code false} on failure
deprecated
Deprecated in favor of the {@link #requestNetwork}, {@link #setProcessDefaultNetwork} and {@link Network#getSocketFactory} api.

        return requestRouteToHostAddress(networkType, NetworkUtils.intToInetAddress(hostAddress));
public booleanrequestRouteToHostAddress(int networkType, java.net.InetAddress hostAddress)
Ensure that a network route exists to deliver traffic to the specified host via the specified network interface. An attempt to add a route that already exists is ignored, but treated as successful.

This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}.

param
networkType the type of the network over which traffic to the specified host is to be routed
param
hostAddress the IP address of the host to which the route is desired
return
{@code true} on success, {@code false} on failure
hide
deprecated
Deprecated in favor of the {@link #requestNetwork} and {@link #setProcessDefaultNetwork} api.

        try {
            return mService.requestRouteToHostAddress(networkType, hostAddress.getAddress());
        } catch (RemoteException e) {
            return false;
        }
private voidsendExpireMsgForFeature(NetworkCapabilities netCap, int seqNum, int delay)

        if (delay >= 0) {
            Log.d(TAG, "sending expire msg with seqNum " + seqNum + " and delay " + delay);
            Message msg = sCallbackHandler.obtainMessage(EXPIRE_LEGACY_REQUEST, seqNum, 0, netCap);
            sCallbackHandler.sendMessageDelayed(msg, delay);
        }
private NetworkRequestsendRequestForNetwork(NetworkCapabilities need, android.net.ConnectivityManager$NetworkCallback networkCallback, int timeoutSec, int action, int legacyType)


       
                 
              
        if (networkCallback == null) {
            throw new IllegalArgumentException("null NetworkCallback");
        }
        if (need == null) throw new IllegalArgumentException("null NetworkCapabilities");
        try {
            incCallbackHandlerRefCount();
            synchronized(sNetworkCallback) {
                if (action == LISTEN) {
                    networkCallback.networkRequest = mService.listenForNetwork(need,
                            new Messenger(sCallbackHandler), new Binder());
                } else {
                    networkCallback.networkRequest = mService.requestNetwork(need,
                            new Messenger(sCallbackHandler), timeoutSec, new Binder(), legacyType);
                }
                if (networkCallback.networkRequest != null) {
                    sNetworkCallback.put(networkCallback.networkRequest, networkCallback);
                }
            }
        } catch (RemoteException e) {}
        if (networkCallback.networkRequest == null) decCallbackHandlerRefCount();
        return networkCallback.networkRequest;
public voidsetAirplaneMode(boolean enable)
Set the value for enabling/disabling airplane mode

param
enable whether to enable airplane mode or not

This method requires the call to hold the permission {@link android.Manifest.permission#CONNECTIVITY_INTERNAL}.

hide

        try {
            mService.setAirplaneMode(enable);
        } catch (RemoteException e) {
        }
public voidsetBackgroundDataSetting(boolean allowBackgroundData)
Sets the value of the setting for background data usage.

param
allowBackgroundData Whether an application should use data while it is in the background.
attr
ref android.Manifest.permission#CHANGE_BACKGROUND_DATA_SETTING
see
#getBackgroundDataSetting()
hide

        // ignored
public voidsetDataDependency(int networkType, boolean met)
Sets a secondary requirement bit for the given networkType. This requirement bit is generally under the control of the carrier or its agents and is not directly controlled by the user.

param
networkType The network who's dependence has changed
param
met Boolean - true if network use is OK, false if not

This method requires the call to hold the permission {@link android.Manifest.permission#CONNECTIVITY_INTERNAL}. {@hide}

        try {
            mService.setDataDependency(networkType, met);
        } catch (RemoteException e) {
        }
public voidsetGlobalProxy(ProxyInfo p)
Set a network-independent global http proxy. This is not normally what you want for typical HTTP proxies - they are general network dependent. However if you're doing something unusual like general internal filtering this may be useful. On a private network where the proxy is not accessible, you may break HTTP using this.

param
p The a {@link ProxyInfo} object defining the new global HTTP proxy. A {@code null} value will clear the global HTTP proxy.

This method requires the call to hold the permission android.Manifest.permission#CONNECTIVITY_INTERNAL.

hide

        try {
            mService.setGlobalProxy(p);
        } catch (RemoteException e) {
        }
public voidsetNetworkPreference(int preference)
Specifies the preferred network type. When the device has more than one type available the preferred network type will be used.

param
preference the network type to prefer over all others. It is unspecified what happens to the old preferred network in the overall ordering.
deprecated
Functionality has been removed as it no longer makes sense, with many more than two networks - we'd need an array to express preference. Instead we use dynamic network properties of the networks to describe their precedence.
public static booleansetProcessDefaultNetwork(Network network)
Binds the current process to {@code network}. All Sockets created in the future (and not explicitly bound via a bound SocketFactory from {@link Network#getSocketFactory() Network.getSocketFactory()}) will be bound to {@code network}. All host name resolutions will be limited to {@code network} as well. Note that if {@code network} ever disconnects, all Sockets created in this way will cease to work and all host name resolutions will fail. This is by design so an application doesn't accidentally use Sockets it thinks are still bound to a particular {@link Network}. To clear binding pass {@code null} for {@code network}. Using individually bound Sockets created by Network.getSocketFactory().createSocket() and performing network-specific host name resolutions via {@link Network#getAllByName Network.getAllByName} is preferred to calling {@code setProcessDefaultNetwork}.

param
network The {@link Network} to bind the current process to, or {@code null} to clear the current binding.
return
{@code true} on success, {@code false} if the {@link Network} is no longer valid.

        int netId = (network == null) ? NETID_UNSET : network.netId;
        if (netId == NetworkUtils.getNetworkBoundToProcess()) {
            return true;
        }
        if (NetworkUtils.bindProcessToNetwork(netId)) {
            // Set HTTP proxy system properties to match network.
            // TODO: Deprecate this static method and replace it with a non-static version.
            Proxy.setHttpProxySystemProperty(getInstance().getDefaultProxy());
            // Must flush DNS cache as new network may have different DNS resolutions.
            InetAddress.clearDnsCache();
            // Must flush socket pool as idle sockets will be bound to previous network and may
            // cause subsequent fetches to be performed on old network.
            NetworkEventDispatcher.getInstance().onNetworkConfigurationChanged();
            return true;
        } else {
            return false;
        }
public static booleansetProcessDefaultNetworkForHostResolution(Network network)
Binds host resolutions performed by this process to {@code network}. {@link #setProcessDefaultNetwork} takes precedence over this setting.

param
network The {@link Network} to bind host resolutions from the current process to, or {@code null} to clear the current binding.
return
{@code true} on success, {@code false} if the {@link Network} is no longer valid.
hide
deprecated
This is strictly for legacy usage to support {@link #startUsingNetworkFeature}.

        return NetworkUtils.bindProcessToNetworkForHostResolution(
                network == null ? NETID_UNSET : network.netId);
public voidsetProvisioningNotificationVisible(boolean visible, int networkType, java.lang.String action)
Set sign in error notification to visible or in visible

param
visible
param
networkType {@hide}

        try {
            mService.setProvisioningNotificationVisible(visible, networkType, action);
        } catch (RemoteException e) {
        }
public intsetUsbTethering(boolean enable)
Attempt to both alter the mode of USB and Tethering of USB. A utility method to deal with some of the complexity of USB - will attempt to switch to Rndis and subsequently tether the resulting interface on {@code true} or turn off tethering and switch off Rndis on {@code false}.

param
enable a boolean - {@code true} to enable tethering
return
error a {@code TETHER_ERROR} value indicating success or failure type

This method requires the call to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. {@hide}

        try {
            return mService.setUsbTethering(enable);
        } catch (RemoteException e) {
            return TETHER_ERROR_SERVICE_UNAVAIL;
        }
public intstartUsingNetworkFeature(int networkType, java.lang.String feature)
Tells the underlying networking system that the caller wants to begin using the named feature. The interpretation of {@code feature} is completely up to each networking implementation.

This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}.

param
networkType specifies which network the request pertains to
param
feature the name of the feature to be used
return
an integer value representing the outcome of the request. The interpretation of this value is specific to each networking implementation+feature combination, except that the value {@code -1} always indicates failure.
deprecated
Deprecated in favor of the cleaner {@link #requestNetwork} api.

        NetworkCapabilities netCap = networkCapabilitiesForFeature(networkType, feature);
        if (netCap == null) {
            Log.d(TAG, "Can't satisfy startUsingNetworkFeature for " + networkType + ", " +
                    feature);
            return PhoneConstants.APN_REQUEST_FAILED;
        }

        NetworkRequest request = null;
        synchronized (sLegacyRequests) {
            LegacyRequest l = sLegacyRequests.get(netCap);
            if (l != null) {
                Log.d(TAG, "renewing startUsingNetworkFeature request " + l.networkRequest);
                renewRequestLocked(l);
                if (l.currentNetwork != null) {
                    return PhoneConstants.APN_ALREADY_ACTIVE;
                } else {
                    return PhoneConstants.APN_REQUEST_STARTED;
                }
            }

            request = requestNetworkForFeatureLocked(netCap);
        }
        if (request != null) {
            Log.d(TAG, "starting startUsingNetworkFeature for request " + request);
            return PhoneConstants.APN_REQUEST_STARTED;
        } else {
            Log.d(TAG, " request Failed");
            return PhoneConstants.APN_REQUEST_FAILED;
        }
public intstopUsingNetworkFeature(int networkType, java.lang.String feature)
Tells the underlying networking system that the caller is finished using the named feature. The interpretation of {@code feature} is completely up to each networking implementation.

This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}.

param
networkType specifies which network the request pertains to
param
feature the name of the feature that is no longer needed
return
an integer value representing the outcome of the request. The interpretation of this value is specific to each networking implementation+feature combination, except that the value {@code -1} always indicates failure.
deprecated
Deprecated in favor of the cleaner {@link #requestNetwork} api.

        NetworkCapabilities netCap = networkCapabilitiesForFeature(networkType, feature);
        if (netCap == null) {
            Log.d(TAG, "Can't satisfy stopUsingNetworkFeature for " + networkType + ", " +
                    feature);
            return -1;
        }

        if (removeRequestForFeature(netCap)) {
            Log.d(TAG, "stopUsingNetworkFeature for " + networkType + ", " + feature);
        }
        return 1;
public voidsupplyMessenger(int networkType, android.os.Messenger messenger)
Supply the backend messenger for a network tracker

param
networkType NetworkType to set
param
messenger {@link Messenger} {@hide}

        try {
            mService.supplyMessenger(networkType, messenger);
        } catch (RemoteException e) {
        }
public inttether(java.lang.String iface)
Attempt to tether the named interface. This will setup a dhcp server on the interface, forward and NAT IP packets and forward DNS requests to the best active upstream network interface. Note that if no upstream IP network interface is available, dhcp will still run and traffic will be allowed between the tethered devices and this device, though upstream net access will of course fail until an upstream network interface becomes active.

param
iface the interface name to tether.
return
error a {@code TETHER_ERROR} value indicating success or failure type

This method requires the call to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. {@hide}

        try {
            return mService.tether(iface);
        } catch (RemoteException e) {
            return TETHER_ERROR_SERVICE_UNAVAIL;
        }
public voidunregisterNetworkCallback(android.net.ConnectivityManager$NetworkCallback networkCallback)
Unregisters callbacks about and possibly releases networks originating from {@link #requestNetwork} and {@link #registerNetworkCallback} calls. If the given {@code NetworkCallback} had previously been used with {@code #requestNetwork}, any networks that had been connected to only to satisfy that request will be disconnected.

param
networkCallback The {@link NetworkCallback} used when making the request.

        if (networkCallback == null || networkCallback.networkRequest == null ||
                networkCallback.networkRequest.requestId == REQUEST_ID_UNSET) {
            throw new IllegalArgumentException("Invalid NetworkCallback");
        }
        try {
            mService.releaseNetworkRequest(networkCallback.networkRequest);
        } catch (RemoteException e) {}
public voidunregisterNetworkFactory(android.os.Messenger messenger)
{@hide}

        try {
            mService.unregisterNetworkFactory(messenger);
        } catch (RemoteException e) { }
public intuntether(java.lang.String iface)
Stop tethering the named interface.

param
iface the interface name to untether.
return
error a {@code TETHER_ERROR} value indicating success or failure type

This method requires the call to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. {@hide}

        try {
            return mService.untether(iface);
        } catch (RemoteException e) {
            return TETHER_ERROR_SERVICE_UNAVAIL;
        }
public booleanupdateLockdownVpn()
If the LockdownVpn mechanism is enabled, updates the vpn with a reload of its profile.

return
a boolean with {@code} indicating success

This method can only be called by the system UID {@hide}

        try {
            return mService.updateLockdownVpn();
        } catch (RemoteException e) {
            return false;
        }