Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2008 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package android.net;
 
 import static com.android.internal.util.Preconditions.checkNotNull;
 
 
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 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
 
 public class ConnectivityManager {
     private static final String TAG = "ConnectivityManager";

    
A change in network connectivity has occurred. A 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 reciever 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 true if there are no connected networks at all.

 
     public static final String CONNECTIVITY_ACTION = "android.net.conn.CONNECTIVITY_CHANGE";

    
Identical to CONNECTIVITY_ACTION broadcast, but sent without any applicable android.provider.Settings.Secure.CONNECTIVITY_CHANGE_DELAY.

Hide:
 
     public static final String CONNECTIVITY_ACTION_IMMEDIATE =
             "android.net.conn.CONNECTIVITY_CHANGE_IMMEDIATE";

    
The lookup key for a NetworkInfo object. Retrieve with android.content.Intent.getParcelableExtra(java.lang.String).

Deprecated:
Since NetworkInfo can vary based on UID, applications should always obtain network information through getActiveNetworkInfo() or getAllNetworkInfo().
 
     @Deprecated
     public static final String EXTRA_NETWORK_INFO = "networkInfo";

    
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 android.content.Intent.getBooleanExtra(java.lang.String,boolean).
    public static final String EXTRA_IS_FAILOVER = "isFailover";
    
The lookup key for a NetworkInfo object. This is supplied when there is another network that it may be possible to connect to. Retrieve with android.content.Intent.getParcelableExtra(java.lang.String).
    public static final String EXTRA_OTHER_NETWORK_INFO = "otherNetwork";
    
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 android.content.Intent.getBooleanExtra(java.lang.String,boolean).
    public static final String EXTRA_NO_CONNECTIVITY = "noConnectivity";
    
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 android.content.Intent.getStringExtra(java.lang.String).
    public static final String EXTRA_REASON = "reason";
    
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 android.content.Intent.getStringExtra(java.lang.String).
    public static final String EXTRA_EXTRA_INFO = "extraInfo";
    
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 android.content.Intent.getIntExtra(java.lang.String,int).
    public static final String EXTRA_INET_CONDITION = "inetCondition";

    
Broadcast Action: The setting for background data usage has changed values. Use 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 false.

Deprecated:
As of android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH, availability of background data depends on several combined factors, and this broadcast is no longer sent. Instead, when background data is unavailable, getActiveNetworkInfo() will now appear disconnected. During first boot after a platform upgrade, this broadcast will be sent once if getBackgroundDataSetting() was false before the upgrade.
    @Deprecated
    public static final String ACTION_BACKGROUND_DATA_SETTING_CHANGED =
            "android.net.conn.BACKGROUND_DATA_SETTING_CHANGED";

    
Broadcast Action: The network connection may not be good uses ConnectivityManager.EXTRA_INET_CONDITION and ConnectivityManager.EXTRA_NETWORK_INFO to specify the network and it's condition.

Hide:
    public static final String INET_CONDITION_ACTION =
            "android.net.conn.INET_CONDITION_ACTION";

    
Broadcast Action: A tetherable connection has come or gone TODO - finish the doc

Hide:
    public static final String ACTION_TETHER_STATE_CHANGED =
            "android.net.conn.TETHER_STATE_CHANGED";

    

Hide:
gives a String[]
    public static final String EXTRA_AVAILABLE_TETHER = "availableArray";

    

Hide:
gives a String[]
    public static final String EXTRA_ACTIVE_TETHER = "activeArray";

    

Hide:
gives a String[]
    public static final String EXTRA_ERRORED_TETHER = "erroredArray";

    
The absence of APN..

Hide:
    public static final int TYPE_NONE        = -1;

    
The Default Mobile data connection. When active, all data traffic will use this connection by default.
    public static final int TYPE_MOBILE      = 0;
    
The Default WIFI data connection. When active, all data traffic will use this connection by default.
    public static final int TYPE_WIFI        = 1;
    
An MMS-specific Mobile data connection. This connection may be the same as TYPE_MOBILE but it may be different. This is used by applications needing to talk to the carrier's Multimedia Messaging Service servers. It may coexist with default data connections.
    public static final int TYPE_MOBILE_MMS  = 2;
    
A SUPL-specific Mobile data connection. This connection may be the same as TYPE_MOBILE but it may be different. This is used by applications needing to talk to the carrier's Secure User Plane Location servers for help locating the device. It may coexist with default data connections.
    public static final int TYPE_MOBILE_SUPL = 3;
    
A DUN-specific Mobile data connection. This connection may be the same as TYPE_MOBILE but it may be different. This is used by applicaitons performing a Dial Up Networking bridge so that the carrier is aware of DUN traffic. It may coexist with default data connections.
    public static final int TYPE_MOBILE_DUN  = 4;
    
A High Priority Mobile data connection. This connection is typically the same as 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 requestRouteToHost(int,int) will route over this interface if a default route exists.
    public static final int TYPE_MOBILE_HIPRI = 5;
    
The Default WiMAX data connection. When active, all data traffic will use this connection by default.
    public static final int TYPE_WIMAX       = 6;

    
The Default Bluetooth data connection. When active, all data traffic will use this connection by default.
    public static final int TYPE_BLUETOOTH   = 7;

    
Dummy data connection. This should not be used on shipping devices.
    public static final int TYPE_DUMMY       = 8;

    
The Default Ethernet data connection. When active, all data traffic will use this connection by default.
    public static final int TYPE_ETHERNET    = 9;

    
Over the air Adminstration.
    public static final int TYPE_MOBILE_FOTA = 10;

    
IP Multimedia Subsystem
    public static final int TYPE_MOBILE_IMS  = 11;

    
Carrier Branded Services
    public static final int TYPE_MOBILE_CBS  = 12;

    
A Wi-Fi p2p connection. Only requesting processes will have access to the peers connected.
    public static final int TYPE_WIFI_P2P    = 13;

    
    public static final int MAX_RADIO_TYPE   = ;

    
    public static final int MAX_NETWORK_TYPE = ;
    public static final int DEFAULT_NETWORK_PREFERENCE = ;
    private final IConnectivityManager mService;
    public static boolean isNetworkTypeValid(int networkType) {
        return networkType >= 0 && networkType <= ;
    }

    
    public static String getNetworkTypeName(int type) {
        switch (type) {
            case :
                return "MOBILE";
            case :
                return "WIFI";
            case :
                return "MOBILE_MMS";
            case :
                return "MOBILE_SUPL";
            case :
                return "MOBILE_DUN";
            case :
                return "MOBILE_HIPRI";
            case :
                return "WIMAX";
            case :
                return "BLUETOOTH";
            case :
                return "DUMMY";
            case :
                return "ETHERNET";
            case :
                return "MOBILE_FOTA";
            case :
                return "MOBILE_IMS";
            case :
                return "MOBILE_CBS";
            case :
                return "WIFI_P2P";
            default:
                return Integer.toString(type);
        }
    }

    
    public static boolean isNetworkTypeMobile(int networkType) {
        switch (networkType) {
            case :
            case :
            case :
            case :
            case :
            case :
            case :
            case :
                return true;
            default:
                return false;
        }
    }
    public void setNetworkPreference(int preference) {
        try {
            .setNetworkPreference(preference);
        } catch (RemoteException e) {
        }
    }
    public int getNetworkPreference() {
        try {
            return .getNetworkPreference();
        } catch (RemoteException e) {
            return -1;
        }
    }

    
Returns details about the currently active data network. When connected, this network is the default route for outgoing connections. You should always check NetworkInfo.isConnected() before initiating network traffic. This may return null when no networks are available.

This method requires the caller to hold the permission android.Manifest.permission.

    public NetworkInfo getActiveNetworkInfo() {
        try {
            return .getActiveNetworkInfo();
        } catch (RemoteException e) {
            return null;
        }
    }

    
    public NetworkInfo getActiveNetworkInfoForUid(int uid) {
        try {
            return .getActiveNetworkInfoForUid(uid);
        } catch (RemoteException e) {
            return null;
        }
    }
    public NetworkInfo getNetworkInfo(int networkType) {
        try {
            return .getNetworkInfo(networkType);
        } catch (RemoteException e) {
            return null;
        }
    }
    public NetworkInfo[] getAllNetworkInfo() {
        try {
            return .getAllNetworkInfo();
        } catch (RemoteException e) {
            return null;
        }
    }

    
        try {
            return .getActiveLinkProperties();
        } catch (RemoteException e) {
            return null;
        }
    }

    
    public LinkProperties getLinkProperties(int networkType) {
        try {
            return .getLinkProperties(networkType);
        } catch (RemoteException e) {
            return null;
        }
    }

    
    public boolean setRadios(boolean turnOn) {
        try {
            return .setRadios(turnOn);
        } catch (RemoteException e) {
            return false;
        }
    }

    
    public boolean setRadio(int networkTypeboolean turnOn) {
        try {
            return .setRadio(networkTypeturnOn);
        } catch (RemoteException e) {
            return false;
        }
    }

    
Tells the underlying networking system that the caller wants to begin using the named feature. The interpretation of feature is completely up to each networking implementation.

This method requires the caller to hold the permission android.Manifest.permission.

Parameters:
networkType specifies which network the request pertains to
feature the name of the feature to be used
Returns:
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 -1 always indicates failure.
    public int startUsingNetworkFeature(int networkTypeString feature) {
        try {
            return .startUsingNetworkFeature(networkTypefeature,
                    new Binder());
        } catch (RemoteException e) {
            return -1;
        }
    }

    
Tells the underlying networking system that the caller is finished using the named feature. The interpretation of feature is completely up to each networking implementation.

This method requires the caller to hold the permission android.Manifest.permission.

Parameters:
networkType specifies which network the request pertains to
feature the name of the feature that is no longer needed
Returns:
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 -1 always indicates failure.
    public int stopUsingNetworkFeature(int networkTypeString feature) {
        try {
            return .stopUsingNetworkFeature(networkTypefeature);
        } catch (RemoteException e) {
            return -1;
        }
    }

    
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 android.Manifest.permission.

Parameters:
networkType the type of the network over which traffic to the specified host is to be routed
hostAddress the IP address of the host to which the route is desired
Returns:
true on success, false on failure
    public boolean requestRouteToHost(int networkTypeint hostAddress) {
        InetAddress inetAddress = NetworkUtils.intToInetAddress(hostAddress);
        if (inetAddress == null) {
            return false;
        }
        return requestRouteToHostAddress(networkTypeinetAddress);
    }

    
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.

Parameters:
networkType the type of the network over which traffic to the specified host is to be routed
hostAddress the IP address of the host to which the route is desired
Returns:
true on success, false on failure
Hide:
    public boolean requestRouteToHostAddress(int networkTypeInetAddress hostAddress) {
        byte[] address = hostAddress.getAddress();
        try {
            return .requestRouteToHostAddress(networkTypeaddress);
        } catch (RemoteException e) {
            return false;
        }
    }

    
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 ACTION_BACKGROUND_DATA_SETTING_CHANGED.

Deprecated:
As of android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH, availability of background data depends on several combined factors, and this method will always return true. Instead, when background data is unavailable, getActiveNetworkInfo() will now appear disconnected.
Returns:
Whether background data usage is allowed.
    @Deprecated
    public boolean getBackgroundDataSetting() {
        // assume that background data is allowed; final authority is
        // NetworkInfo which may be blocked.
        return true;
    }

    
Sets the value of the setting for background data usage.

Parameters:
allowBackgroundData Whether an application should use data while it is in the background.
See also:
getBackgroundDataSetting()
Attr:
ref android.Manifest.permission#CHANGE_BACKGROUND_DATA_SETTING
Hide:
    @Deprecated
    public void setBackgroundDataSetting(boolean allowBackgroundData) {
        // ignored
    }

    
Return quota status for the current active network, or null if no network is active. Quota status can change rapidly, so these values shouldn't be cached.

Hide:
        try {
            return .getActiveNetworkQuotaInfo();
        } catch (RemoteException e) {
            return null;
        }
    }

    
Gets the value of the setting for enabling Mobile data.

Returns:
Whether mobile data is enabled.
Hide:
    public boolean getMobileDataEnabled() {
        try {
            return .getMobileDataEnabled();
        } catch (RemoteException e) {
            return true;
        }
    }

    
Sets the persisted value for enabling/disabling Mobile data.

Parameters:
enabled Whether the mobile data connection should be used or not.
Hide:
    public void setMobileDataEnabled(boolean enabled) {
        try {
            .setMobileDataEnabled(enabled);
        } catch (RemoteException e) {
        }
    }

    
    public ConnectivityManager(IConnectivityManager service) {
         = checkNotNull(service"missing IConnectivityManager");
    }

    
    public static ConnectivityManager from(Context context) {
    }

    
    public String[] getTetherableIfaces() {
        try {
            return .getTetherableIfaces();
        } catch (RemoteException e) {
            return new String[0];
        }
    }

    
    public String[] getTetheredIfaces() {
        try {
            return .getTetheredIfaces();
        } catch (RemoteException e) {
            return new String[0];
        }
    }

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

    

Returns:
error A TETHER_ERROR value indicating success or failure type
    public int tether(String iface) {
        try {
            return .tether(iface);
        } catch (RemoteException e) {
            return ;
        }
    }

    

Returns:
error A TETHER_ERROR value indicating success or failure type
    public int untether(String iface) {
        try {
            return .untether(iface);
        } catch (RemoteException e) {
            return ;
        }
    }

    
    public boolean isTetheringSupported() {
        try {
            return .isTetheringSupported();
        } catch (RemoteException e) {
            return false;
        }
    }

    
    public String[] getTetherableUsbRegexs() {
        try {
            return .getTetherableUsbRegexs();
        } catch (RemoteException e) {
            return new String[0];
        }
    }

    
    public String[] getTetherableWifiRegexs() {
        try {
            return .getTetherableWifiRegexs();
        } catch (RemoteException e) {
            return new String[0];
        }
    }

    
    public String[] getTetherableBluetoothRegexs() {
        try {
            return .getTetherableBluetoothRegexs();
        } catch (RemoteException e) {
            return new String[0];
        }
    }

    
    public int setUsbTethering(boolean enable) {
        try {
            return .setUsbTethering(enable);
        } catch (RemoteException e) {
            return ;
        }
    }

    
    public static final int TETHER_ERROR_NO_ERROR           = 0;
    
    public static final int TETHER_ERROR_UNKNOWN_IFACE      = 1;
    
    public static final int TETHER_ERROR_SERVICE_UNAVAIL    = 2;
    
    public static final int TETHER_ERROR_UNSUPPORTED        = 3;
    
    public static final int TETHER_ERROR_UNAVAIL_IFACE      = 4;
    
    public static final int TETHER_ERROR_MASTER_ERROR       = 5;
    
    public static final int TETHER_ERROR_TETHER_IFACE_ERROR = 6;
    
    public static final int TETHER_ERROR_UNTETHER_IFACE_ERROR = 7;
    
    public static final int TETHER_ERROR_ENABLE_NAT_ERROR     = 8;
    
    public static final int TETHER_ERROR_DISABLE_NAT_ERROR    = 9;
    
    public static final int TETHER_ERROR_IFACE_CFG_ERROR      = 10;

    

Parameters:
iface The name of the interface we're interested in
Returns:
error The error code of the last error tethering or untethering the named interface
    public int getLastTetherError(String iface) {
        try {
            return .getLastTetherError(iface);
        } catch (RemoteException e) {
            return ;
        }
    }

    
Ensure the device stays awake until we connect with the next network

Parameters:
forWhome The name of the network going down for logging purposes
Returns:
true on success, false on failure
    public boolean requestNetworkTransitionWakelock(String forWhom) {
        try {
            .requestNetworkTransitionWakelock(forWhom);
            return true;
        } catch (RemoteException e) {
            return false;
        }
    }

    

Parameters:
networkType The type of network you want to report on
percentage The quality of the connection 0 is bad, 100 is good
    public void reportInetCondition(int networkTypeint percentage) {
        try {
            .reportInetCondition(networkTypepercentage);
        } catch (RemoteException e) {
        }
    }

    

Parameters:
proxyProperties The definition for the new global http proxy
    public void setGlobalProxy(ProxyProperties p) {
        try {
            .setGlobalProxy(p);
        } catch (RemoteException e) {
        }
    }

    

Returns:
proxyProperties for the current global proxy
    public ProxyProperties getGlobalProxy() {
        try {
            return .getGlobalProxy();
        } catch (RemoteException e) {
            return null;
        }
    }

    

Returns:
proxyProperties for the current proxy (global if set, network specific if not)
    public ProxyProperties getProxy() {
        try {
            return .getProxy();
        } catch (RemoteException e) {
            return null;
        }
    }

    

Parameters:
networkType The network who's dependence has changed
met Boolean - true if network use is ok, false if not
    public void setDataDependency(int networkTypeboolean met) {
        try {
            .setDataDependency(networkTypemet);
        } catch (RemoteException e) {
        }
    }

    
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 true for mobile data, but a wifi only tablet would return false.

Parameters:
networkType The nework type we'd like to check
Returns:
true if supported, else false
Hide:
    public boolean isNetworkSupported(int networkType) {
        try {
            return .isNetworkSupported(networkType);
        } catch (RemoteException e) {}
        return false;
    }

    
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. You should check this before doing large data transfers, and warn the user or delay the operation until another network is available.
    public boolean isActiveNetworkMetered() {
        try {
            return .isActiveNetworkMetered();
        } catch (RemoteException e) {
            return false;
        }
    }
New to GrepCode? Check out our FAQ X