/**@class android.net.ConnectivityManager @extends java.lang.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)}. <p> The primary responsibilities of this class are to: <ol> <li>Monitor network connections (Wi-Fi, GPRS, UMTS, etc.)</li> <li>Send broadcast intents when network connectivity changes</li> <li>Attempt to "fail over" to another network when connectivity to a network is lost</li> <li>Provide an API that allows applications to query the coarse-grained or fine-grained state of the available networks</li> <li>Provide an API that allows applications to request and select networks for their data traffic</li> </ol> */ var ConnectivityManager = { /** 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. <p/> 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. <p/> 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. <p/> For a disconnect event, the boolean extra EXTRA_NO_CONNECTIVITY is set to {@code true} if there are no connected networks at all. */ CONNECTIVITY_ACTION : "android.net.conn.CONNECTIVITY_CHANGE", /** The device has connected to a network that has presented a captive portal, which is blocking Internet connectivity. The user was presented with a notification that network sign in is required, and the user invoked the notification's action indicating they desire to sign in to the network. Apps handling this activity should facilitate signing in to the network. This action includes a {@link android.net.Network} typed extra called {@link #EXTRA_NETWORK} that represents the network presenting the captive portal; all communication with the captive portal must be done using this {@code Network} object. <p/> This activity includes a {@link android.net.CaptivePortal} extra named {@link #EXTRA_CAPTIVE_PORTAL} that can be used to indicate different outcomes of the captive portal sign in to the system: <ul> <li> When the app handling this action believes the user has signed in to the network and the captive portal has been dismissed, the app should call {@link android.net.CaptivePortal#reportandroid.net.CaptivePortalDismissed} so the system can reevaluate the network. If reevaluation finds the network no longer subject to a captive portal, the network may become the default active data network. </li> <li> When the app handling this action believes the user explicitly wants to ignore the captive portal and the network, the app should call {@link android.net.CaptivePortal#ignoreNetwork}. </li> </ul> */ ACTION_CAPTIVE_PORTAL_SIGN_IN : "android.net.conn.CAPTIVE_PORTAL", /** The lookup key for a {@link android.net.NetworkInfo} object. Retrieve with {@link android.content.Intent#getParcelableExtra(String)}. @deprecated Since {@link android.net.NetworkInfo} can vary based on UID, applications should always obtain network information through {@link #getActiveNetworkInfo}(). @see #EXTRA_NETWORK_TYPE */ EXTRA_NETWORK_INFO : "networkInfo", /** Network type which triggered a {@link #CONNECTIVITY_ACTION} broadcast. @see android.content.Intent#getIntExtra(String, int) */ EXTRA_NETWORK_TYPE : "networkType", /** 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)}. */ EXTRA_IS_FAILOVER : "isFailover", /** The lookup key for a {@link android.net.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)}. */ 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 {@link android.content.Intent#getBooleanExtra(String,boolean)}. */ 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 {@link android.content.Intent#getStringExtra(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 {@link android.content.Intent#getStringExtra(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 {@link android.content.Intent#getIntExtra(String, int)}. {@hide} */ EXTRA_INET_CONDITION : "inetCondition", /** The lookup key for a {@link android.net.CaptivePortal} object included with the {@link #ACTION_CAPTIVE_PORTAL_SIGN_IN} intent. The {@code CaptivePortal} object can be used to either indicate to the system that the captive portal has been dismissed or that the user does not want to pursue signing in to captive portal. Retrieve it with {@link android.content.Intent#getParcelableExtra(String)}. */ EXTRA_CAPTIVE_PORTAL : "android.net.extra.CAPTIVE_PORTAL", /** 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} */ ACTION_DATA_ACTIVITY_CHANGE : "android.net.conn.DATA_ACTIVITY_CHANGE", /** The lookup key for an enum that indicates the network device type on which this data activity change happens. {@hide} */ EXTRA_DEVICE_TYPE : "deviceType", /** 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} */ EXTRA_IS_ACTIVE : "isActive", /** The lookup key for a long that contains the timestamp (nanos) of the radio state change. {@hide} */ EXTRA_REALTIME_NS : "tsNanos", /** Broadcast Action: The setting for background data usage has changed values. Use {@link #getBackgroundDataSetting}() to get the current value. <p> 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}. <p> @deprecated As of {@link 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, {@link #getActiveNetworkInfo}() will now appear disconnected. During first boot after a platform upgrade, this broadcast will be sent once if {@link #getBackgroundDataSetting}() was {@code false} before the upgrade. */ ACTION_BACKGROUND_DATA_SETTING_CHANGED : "android.net.conn.BACKGROUND_DATA_SETTING_CHANGED", /** 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. @hide */ INET_CONDITION_ACTION : "android.net.conn.INET_CONDITION_ACTION", /** 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). @hide */ ACTION_TETHER_STATE_CHANGED : "android.net.conn.TETHER_STATE_CHANGED", /** @hide gives a String[] listing all the interfaces configured for tethering and currently available for tethering. */ EXTRA_AVAILABLE_TETHER : "availableArray", /** @hide gives a String[] listing all the interfaces currently tethered (ie, has dhcp support and packets potentially forwarded/NATed) */ EXTRA_ACTIVE_TETHER : "activeArray", /** @hide gives a String[] listing all the interfaces we tried to tether and failed. Use {@link #getLastTetherError} to find the error code for any interfaces listed here. */ EXTRA_ERRORED_TETHER : "erroredArray", /** Broadcast Action: The captive portal tracker has finished its test. Sent only while running Setup Wizard, in lieu of showing a user notification. @hide */ ACTION_CAPTIVE_PORTAL_TEST_COMPLETED : "android.net.conn.CAPTIVE_PORTAL_TEST_COMPLETED", /** The lookup key for a boolean that indicates whether a captive portal was detected. Retrieve it with {@link android.content.Intent#getBooleanExtra(String,boolean)}. @hide */ EXTRA_IS_CAPTIVE_PORTAL : "captivePortal", /** Action used to display a dialog that asks the user whether to connect to a network that is not validated. This intent is used to start the dialog in settings via startActivity. @hide */ ACTION_PROMPT_UNVALIDATED : "android.net.conn.PROMPT_UNVALIDATED", /** The absence of a connection type. @hide */ TYPE_NONE : "-1", /** The Mobile data connection. When active, all data traffic will use this network type's interface by default (it has a default route) */ TYPE_MOBILE : "0", /** The WIFI data connection. When active, all data traffic will use this network type's interface by default (it has a default route). */ TYPE_WIFI : "1", /** 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. @deprecated Applications should instead use {@link #requestNetwork(NetworkRequest, android.net.ConnectivityManager.NetworkCallback)} to request a network that provides the {@link android.net.NetworkCapabilities#NET_CAPABILITY_MMS} capability. */ TYPE_MOBILE_MMS : "2", /** 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. @deprecated Applications should instead use {@link #requestNetwork(NetworkRequest, android.net.ConnectivityManager.NetworkCallback)} to request a network that provides the {@link android.net.NetworkCapabilities#NET_CAPABILITY_SUPL} capability. */ TYPE_MOBILE_SUPL : "3", /** 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. */ TYPE_MOBILE_DUN : "4", /** A High Priority Mobile data connection. This network type uses the same network interface as {@link #TYPE_MOBILE} but the routing setup is different. @deprecated Applications should instead use {@link #requestNetwork(NetworkRequest, android.net.ConnectivityManager.NetworkCallback)} to request a network that uses the {@link android.net.NetworkCapabilities#TRANSPORT_CELLULAR} transport. */ TYPE_MOBILE_HIPRI : "5", /** The WiMAX data connection. When active, all data traffic will use this network type's interface by default (it has a default route). */ TYPE_WIMAX : "6", /** The Bluetooth data connection. When active, all data traffic will use this network type's interface by default (it has a default route). */ TYPE_BLUETOOTH : "7", /** Dummy data connection. This should not be used on shipping devices. */ TYPE_DUMMY : "8", /** The Ethernet data connection. When active, all data traffic will use this network type's interface by default (it has a default route). */ TYPE_ETHERNET : "9", /** Over the air Administration. {@hide} */ TYPE_MOBILE_FOTA : "10", /** IP Multimedia Subsystem. {@hide} */ TYPE_MOBILE_IMS : "11", /** Carrier Branded Services. {@hide} */ TYPE_MOBILE_CBS : "12", /** A Wi-Fi p2p connection. Only requesting processes will have access to the peers connected. {@hide} */ TYPE_WIFI_P2P : "13", /** The network to use for initially attaching to the network {@hide} */ TYPE_MOBILE_IA : "14", /** Emergency PDN connection for emergency services. This may include IMS and MMS in emergency situations. {@hide} */ TYPE_MOBILE_EMERGENCY : "15", /** The network that uses proxy to achieve connectivity. {@hide} */ TYPE_PROXY : "16", /** A virtual network using one or more native bearers. It may or may not be providing security services. */ TYPE_VPN : "17", /**{@hide} */ MAX_RADIO_TYPE : "17", /**{@hide} */ MAX_NETWORK_TYPE : "17", /** If you want to set the default network preference,you can directly change the networkAttributes array in framework's config.xml. @deprecated Since we support so many more networks now, the single network default network preference can't really express the hierarchy. Instead, the default is defined by the networkAttributes in config.xml. You can determine the current value by calling {@link #getNetworkPreference}() from an App. */ DEFAULT_NETWORK_PREFERENCE : "1", /** @hide */ REQUEST_ID_UNSET : "0", /** A NetID indicating no Network is selected. Keep in sync with bionic/libc/dns/include/resolv_netid.h @hide */ NETID_UNSET : "0", /**{@hide} */ TETHER_ERROR_NO_ERROR : "0", /**{@hide} */ TETHER_ERROR_UNKNOWN_IFACE : "1", /**{@hide} */ TETHER_ERROR_SERVICE_UNAVAIL : "2", /**{@hide} */ TETHER_ERROR_UNSUPPORTED : "3", /**{@hide} */ TETHER_ERROR_UNAVAIL_IFACE : "4", /**{@hide} */ TETHER_ERROR_MASTER_ERROR : "5", /**{@hide} */ TETHER_ERROR_TETHER_IFACE_ERROR : "6", /**{@hide} */ TETHER_ERROR_UNTETHER_IFACE_ERROR : "7", /**{@hide} */ TETHER_ERROR_ENABLE_NAT_ERROR : "8", /**{@hide} */ TETHER_ERROR_DISABLE_NAT_ERROR : "9", /**{@hide} */ TETHER_ERROR_IFACE_CFG_ERROR : "10", /**@hide */ CALLBACK_PRECHECK : "524289", /**@hide */ CALLBACK_AVAILABLE : "524290", /**@hide arg1 = TTL */ CALLBACK_LOSING : "524291", /**@hide */ CALLBACK_LOST : "524292", /**@hide */ CALLBACK_UNAVAIL : "524293", /**@hide */ CALLBACK_CAP_CHANGED : "524294", /**@hide */ CALLBACK_IP_CHANGED : "524295", /**@hide */ CALLBACK_RELEASED : "524296", /**@hide */ CALLBACK_EXIT : "524297", /**@hide */ CALLBACK_SUSPENDED : "524299", /**@hide */ CALLBACK_RESUMED : "524300", /** The maximum number of milliseconds the framework will look for a suitable network during a timeout-equiped call to {@link requestNetwork}. {@hide} */ MAX_NETWORK_REQUEST_TIMEOUT_MS : "6000000", /** The lookup key for a {@link android.net.Network} object included with the intent after successfully finding a network for the applications request. Retrieve it with {@link android.content.Intent#getParcelableExtra(String)}. <p> Note that if you intend to invoke {@link android.net.Network#openConnection(java.net.URL)} then you must get a ConnectivityManager instance before doing so. */ EXTRA_NETWORK : "android.net.extra.NETWORK", /** The lookup key for a {@link android.net.NetworkRequest} object included with the intent after successfully finding a network for the applications request. Retrieve it with {@link android.content.Intent#getParcelableExtra(String)}. */ EXTRA_NETWORK_REQUEST : "android.net.extra.NETWORK_REQUEST", /**Tests if a given integer represents a valid network type. @param {Number} networkType the type to be tested @return {Boolean} a boolean. {@code true} if the type is valid, else {@code false} @deprecated All APIs accepting a network type are deprecated. There should be no need to validate a network type. */ isNetworkTypeValid : function( ) {}, /**Returns a non-localized string representing a given network type. ONLY used for debugging output. @param {Number} type the type needing naming @return {String} a String for the given type, or a string version of the type ("87") if no name is known. {@hide} */ getNetworkTypeName : function( ) {}, /**Checks if a given type uses the cellular data connection. This should be replaced in the future by a network property. @param {Number} networkType the type to check @return {Boolean} a boolean - {@code true} if uses cellular network, else {@code false} {@hide} */ isNetworkTypeMobile : function( ) {}, /**Checks if the given network type is backed by a Wi-Fi radio. @hide */ isNetworkTypeWifi : function( ) {}, /**Specifies the preferred network type. When the device has more than one type available the preferred network type will be used. @param {Number} 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. */ setNetworkPreference : function( ) {}, /**Retrieves the current preferred network type. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {Number} an integer representing the preferred network type @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. */ getNetworkPreference : function( ) {}, /**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 android.net.NetworkInfo#isConnected()} before initiating network traffic. This may return {@code null} when there is no default network. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {Object {android.net.NetworkInfo}} a {@link NetworkInfo} object for the current default network or {@code null} if no default network is currently active */ getActiveNetworkInfo : function( ) {}, /**Returns a {@link android.net.Network} object corresponding to the currently active default data network. In the event that the current active default data network disconnects, the returned {@code Network} object will no longer be usable. This will return {@code null} when there is no default network. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {Object {android.net.Network}} a {@link Network} object for the current default network or {@code null} if no default network is currently active */ getActiveNetwork : function( ) {}, /**Returns details about the currently active default data network for a given uid. This is for internal use only to avoid spying other apps. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CONNECTIVITY_INTERNAL} @return {Object {android.net.NetworkInfo}} 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. {@hide} */ getActiveNetworkInfoForUid : function( ) {}, /**Returns connection status information about a particular network type. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @param {Number} networkType integer specifying which networkType in which you're interested. @return {Object {android.net.NetworkInfo}} a {@link NetworkInfo} object for the requested network type or {@code null} if the type is not supported by the device. @deprecated This method does not support multiple connected networks of the same type. Use {@link #getAllNetworks} and {@link #getNetworkInfo(android.net.Network)} instead. */ getNetworkInfo : function( ) {}, /**Returns connection status information about a particular Network. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @param {Object {Network}} network {@link Network} specifying which network in which you're interested. @return {Object {android.net.NetworkInfo}} a {@link NetworkInfo} object for the requested network or {@code null} if the {@code Network} is not valid. */ getNetworkInfo : function( ) {}, /**Returns connection status information about all network types supported by the device. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {Object {android.net.NetworkInfo}} an array of {@link NetworkInfo} objects. Check each {@link NetworkInfo#getType} for which type each applies. @deprecated This method does not support multiple connected networks of the same type. Use {@link #getAllNetworks} and {@link #getNetworkInfo(android.net.Network)} instead. */ getAllNetworkInfo : function( ) {}, /**Returns the {@link android.net.Network} object currently serving a given type, or null if the given type is not connected. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @hide @deprecated This method does not support multiple connected networks of the same type. Use {@link #getAllNetworks} and {@link #getNetworkInfo(android.net.Network)} instead. */ getNetworkForType : function( ) {}, /**Returns an array of all {@link android.net.Network} currently tracked by the framework. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {Object {android.net.Network}} an array of {@link Network} objects. */ getAllNetworks : function( ) {}, /**Returns an array of {@link android.net.NetworkCapabilities} objects, representing the Networks that applications run by the given user will use by default. @hide */ getDefaultNetworkCapabilitiesForUser : function( ) {}, /**Returns the IP information for the current default network. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {Object {android.net.LinkProperties}} a {@link LinkProperties} object describing the IP info for the current default network, or {@code null} if there is no current default network. {@hide} */ getActiveLinkProperties : function( ) {}, /**Returns the IP information for a given network type. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @param {Number} networkType the network type of interest. @return {Object {android.net.LinkProperties}} a {@link LinkProperties} object describing the IP info for the given networkType, or {@code null} if there is no current default network. {@hide} @deprecated This method does not support multiple connected networks of the same type. Use {@link #getAllNetworks}, {@link #getNetworkInfo(android.net.Network)}, and {@link #getLinkProperties(android.net.Network)} instead. */ getLinkProperties : function( ) {}, /**Get the {@link android.net.LinkProperties} for the given {@link android.net.Network}. This will return {@code null} if the network is unknown. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @param {Object {Network}} network The {@link Network} object identifying the network in question. @return {Object {android.net.LinkProperties}} The {@link LinkProperties} for the network, or {@code null}. */ getLinkProperties : function( ) {}, /**Get the {@link android.net.NetworkCapabilities} for the given {@link android.net.Network}. This will return {@code null} if the network is unknown. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @param {Object {Network}} network The {@link Network} object identifying the network in question. @return {Object {android.net.NetworkCapabilities}} The {@link android.net.NetworkCapabilities} for the network, or {@code null}. */ getNetworkCapabilities : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {Number} networkType specifies which network the request pertains to @param {String} feature the name of the feature to be used @return {Number} 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(NetworkRequest, NetworkCallback)} API. In {@link VERSION_CODES#M}, and above, this method is unsupported and will throw {@code UnsupportedOperationException} if called. */ startUsingNetworkFeature : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {Number} networkType specifies which network the request pertains to @param {String} feature the name of the feature that is no longer needed @return {Number} 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 #unregisterNetworkCallback} API. In {@link VERSION_CODES#M}, and above, this method is unsupported and will throw {@code UnsupportedOperationException} if called. */ stopUsingNetworkFeature : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {Number} networkType the type of the network over which traffic to the specified host is to be routed @param {Number} hostAddress the IP address of the host to which the route is desired @return {Boolean} {@code true} on success, {@code false} on failure @deprecated Deprecated in favor of the {@link #requestNetwork(NetworkRequest, NetworkCallback)}, {@link #bindProcessToNetwork} and {@link Network#getSocketFactory} API. In {@link VERSION_CODES#M}, and above, this method is unsupported and will throw {@code UnsupportedOperationException} if called. */ requestRouteToHost : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {Number} networkType the type of the network over which traffic to the specified host is to be routed @param {Object {InetAddress}} hostAddress the IP address of the host to which the route is desired @return {Boolean} {@code true} on success, {@code false} on failure @hide @deprecated Deprecated in favor of the {@link #requestNetwork} and {@link #bindProcessToNetwork} API. */ requestRouteToHostAddress : function( ) {}, /**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. <p> All applications that have background services that use the network should listen to {@link #ACTION_BACKGROUND_DATA_SETTING_CHANGED}. <p> @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 {Boolean} Whether background data usage is allowed. */ getBackgroundDataSetting : function( ) {}, /**Sets the value of the setting for background data usage. @param {Boolean} 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 */ setBackgroundDataSetting : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @hide */ getActiveNetworkQuotaInfo : function( ) {}, /** @hide @deprecated Talk to TelephonyManager directly */ getMobileDataEnabled : function( ) {}, /**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. <p> If the process default network has been set with {@link android.net.ConnectivityManager#bindProcessToNetwork} this function will not reflect the process's default, but the system default. @param {Object {ConnectivityManager.OnNetworkActiveListener}} l The listener to be told when the network is active. */ addDefaultNetworkActiveListener : function( ) {}, /**Remove network active listener previously registered with {@link #addDefaultNetworkActiveListener}. @param {Object {ConnectivityManager.OnNetworkActiveListener}} l Previously registered listener. */ removeDefaultNetworkActiveListener : function( ) {}, /**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. */ isDefaultNetworkActive : function( ) {}, /**{@hide} */ from : function( ) {}, /**{@hide */ enforceTetherChangePermission : function( ) {}, /**Get the set of tetherable, available interfaces. This list is limited by device configuration and current interface existence. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {String} an array of 0 or more Strings of tetherable interface names. {@hide} */ getTetherableIfaces : function( ) {}, /**Get the set of tethered interfaces. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {String} an array of 0 or more String of currently tethered interface names. {@hide} */ getTetheredIfaces : function( ) {}, /**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 android.net.ConnectivityManager#getLastTetherError} can be used to get more information on the cause of the errors. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {String} an array of 0 or more String indicating the interface names which failed to tether. {@hide} */ getTetheringErroredIfaces : function( ) {}, /**Get the set of tethered dhcp ranges. @return {String} an array of 0 or more {@code String} of tethered dhcp ranges. {@hide} */ getTetheredDhcpRanges : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {String} iface the interface name to tether. @return {Number} error a {@code TETHER_ERROR} value indicating success or failure type {@hide} */ tether : function( ) {}, /**Stop tethering the named interface. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {String} iface the interface name to untether. @return {Number} error a {@code TETHER_ERROR} value indicating success or failure type {@hide} */ untether : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {Boolean} a boolean - {@code true} indicating Tethering is supported. {@hide} */ isTetheringSupported : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {String} an array of 0 or more regular expression Strings defining what interfaces are considered tetherable usb interfaces. {@hide} */ getTetherableUsbRegexs : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {String} an array of 0 or more regular expression Strings defining what interfaces are considered tetherable wifi interfaces. {@hide} */ getTetherableWifiRegexs : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {String} an array of 0 or more regular expression Strings defining what interfaces are considered tetherable bluetooth interfaces. {@hide} */ getTetherableBluetoothRegexs : function( ) {}, /**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}. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {Boolean} enable a boolean - {@code true} to enable tethering @return {Number} error a {@code TETHER_ERROR} value indicating success or failure type {@hide} */ setUsbTethering : function( ) {}, /**Get a more detailed error code after a Tethering or Untethering request asynchronously failed. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @param {String} iface The name of the interface of interest @return {Number} error The error code of the last error tethering or untethering the named interface {@hide} */ getLastTetherError : function( ) {}, /**Report network connectivity status. This is currently used only to alter status bar UI. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#STATUS_BAR}. @param {Number} networkType The type of network you want to report on @param {Number} percentage The quality of the connection 0 is bad, 100 is good {@hide} */ reportInetCondition : function( ) {}, /**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 {Object {Network}} network The {@link Network} the application was attempting to use or {@code null} to indicate the current default network. @deprecated Use {@link #reportNetworkConnectivity} which allows reporting both working and non-working connectivity. */ reportBadNetwork : function( ) {}, /**Report to the framework whether a network has working connectivity. This provides a hint to the system that a particular network is providing working connectivity or not. In response the framework may re-evaluate the network's connectivity and might take further action thereafter. @param {Object {Network}} network The {@link Network} the application was attempting to use or {@code null} to indicate the current default network. @param {Boolean} hasConnectivity {@code true} if the application was able to successfully access the Internet using {@code network} or {@code false} if not. */ reportNetworkConnectivity : function( ) {}, /**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. <p>This method requires the caller to hold the permission android.Manifest.permission#CONNECTIVITY_INTERNAL. @param {Object {ProxyInfo}} p A {@link ProxyInfo} object defining the new global HTTP proxy. A {@code null} value will clear the global HTTP proxy. @hide */ setGlobalProxy : function( ) {}, /**Retrieve any network-independent global HTTP proxy. @return {Object {android.net.ProxyInfo}} {@link ProxyInfo} for the current global HTTP proxy or {@code null} if no global HTTP proxy is set. @hide */ getGlobalProxy : function( ) {}, /**Retrieve the global HTTP proxy, or if no global HTTP proxy is set, a network-specific HTTP proxy. If {@code network} is null, the network-specific proxy returned is the proxy of the default active network. @return {Object {android.net.ProxyInfo}} {@link ProxyInfo} for the current global HTTP proxy, or if no global HTTP proxy is set, {@code ProxyInfo} for {@code network}, or when {@code network} is {@code null}, the {@code ProxyInfo} for the default active network. Returns {@code null} when no proxy applies or the caller doesn't have permission to use {@code network}. @hide */ getProxyForNetwork : function( ) {}, /**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 android.net.Network} using {@link #bindProcessToNetwork} then that {@code Network}'s proxy is returned, otherwise the default network's proxy is returned. @return {Object {android.net.ProxyInfo}} the {@link ProxyInfo} for the current HTTP proxy, or {@code null} if no HTTP proxy is active. */ getDefaultProxy : function( ) {}, /**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}. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @param {Number} networkType The network type we'd like to check @return {Boolean} {@code true} if supported, else {@code false} @hide */ isNetworkSupported : function( ) {}, /**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. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @return {Boolean} {@code true} if large transfers should be avoided, otherwise {@code false}. */ isActiveNetworkMetered : function( ) {}, /**If the LockdownVpn mechanism is enabled, updates the vpn with a reload of its profile. @return {Boolean} a boolean with {@code} indicating success <p>This method can only be called by the system UID {@hide} */ updateLockdownVpn : function( ) {}, /**Check mobile provisioning. @param {Number} suggestedTimeOutMs, timeout in milliseconds @return {Number} time out that will be used, maybe less that suggestedTimeOutMs -1 if an error. {@hide} */ checkMobileProvisioning : function( ) {}, /**Get the mobile provisioning url. {@hide} */ getMobileProvisioningUrl : function( ) {}, /**Set sign in error notification to visible or in visible @param {Boolean} visible @param {Number} networkType {@hide} @deprecated Doesn't properly deal with multiple connected networks of the same type. */ setProvisioningNotificationVisible : function( ) {}, /**Set the value for enabling/disabling airplane mode <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CONNECTIVITY_INTERNAL}. @param {Boolean} enable whether to enable airplane mode or not @hide */ setAirplaneMode : function( ) {}, /**{@hide} */ registerNetworkFactory : function( ) {}, /**{@hide} */ unregisterNetworkFactory : function( ) {}, /** @hide Register a NetworkAgent with ConnectivityService. @return {Number} NetID corresponding to NetworkAgent. */ registerNetworkAgent : function( ) {}, /**Request a network to satisfy a set of {@link android.net.NetworkCapabilities}. This {@link android.net.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 android.net.ConnectivityManager.NetworkCallback}. The {@link android.net.Network} can be used to direct traffic to the network. <p>It is presently unsupported to request a network with mutable {@link android.net.NetworkCapabilities} such as {@link android.net.NetworkCapabilities#NET_CAPABILITY_VALIDATED} or {@link android.net.NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL} as these {@code NetworkCapabilities} represent states that a particular network may never attain, and whether a network will attain these states is unknown prior to bringing up the network so the framework does not know how to go about satisfing a request with these capabilities. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {Object {NetworkRequest}} request {@link NetworkRequest} describing this request. @param {Object {ConnectivityManager.NetworkCallback}} networkCallback The {@link NetworkCallback} to be utilized for this request. Note the callback must not be shared - they uniquely specify this request. @throws IllegalArgumentException if {@code request} specifies any mutable {@code NetworkCapabilities}. */ requestNetwork : function( ) {}, /**Request a network to satisfy a set of {@link android.net.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 android.net.ConnectivityManager.NetworkCallback#unavailable} callback is called. The request must still be released normally by calling {@link releaseNetworkRequest}. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {Object {NetworkRequest}} request {@link NetworkRequest} describing this request. @param {Object {ConnectivityManager.NetworkCallback}} networkCallback The callbacks to be utilized for this request. Note the callbacks must not be shared - they uniquely specify this request. @param {Number} timeoutMs The time in milliseconds to attempt looking for a suitable network before {@link NetworkCallback#unavailable} is called. @hide */ requestNetwork : function( ) {}, /**Request a network to satisfy a set of {@link android.net.NetworkCapabilities}. This function behaves identically to the version that takes a NetworkCallback, but instead of {@link android.net.ConnectivityManager.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. <p> 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 <p> The operation Intent is delivered with two extras, a {@link android.net.Network} typed extra called {@link #EXTRA_NETWORK} and a {@link android.net.NetworkRequest} typed extra called {@link #EXTRA_NETWORK_REQUEST} containing the original requests parameters. It is important to create a new, {@link android.net.ConnectivityManager.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. <p> If there is already a 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 android.net.NetworkRequest}. <p> The request may be released normally by calling {@link #releaseNetworkRequest(android.app.PendingIntent)}. <p>It is presently unsupported to request a network with either {@link android.net.NetworkCapabilities#NET_CAPABILITY_VALIDATED} or {@link android.net.NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL} as these {@code NetworkCapabilities} represent states that a particular network may never attain, and whether a network will attain these states is unknown prior to bringing up the network so the framework does not know how to go about satisfing a request with these capabilities. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CHANGE_NETWORK_STATE}. @param {Object {NetworkRequest}} request {@link NetworkRequest} describing this request. @param {Object {PendingIntent}} 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. @throws IllegalArgumentException if {@code request} contains either {@link NetworkCapabilities#NET_CAPABILITY_VALIDATED} or {@link NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL}. */ requestNetwork : function( ) {}, /**Removes a request made via {@link #requestNetwork(NetworkRequest, android.app.PendingIntent)} <p> This method has the same behavior as {@link #unregisterNetworkCallback} with respect to releasing network resources and disconnecting. @param {Object {PendingIntent}} 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. */ releaseNetworkRequest : function( ) {}, /**Registers to receive notifications about all networks which satisfy the given {@link android.net.NetworkRequest}. The callbacks will continue to be called until either the application exits or {@link #unregisterNetworkCallback} is called <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @param {Object {NetworkRequest}} request {@link NetworkRequest} describing this request. @param {Object {ConnectivityManager.NetworkCallback}} networkCallback The {@link NetworkCallback} that the system will call as suitable networks change state. */ registerNetworkCallback : function( ) {}, /**Registers a PendingIntent to be sent when a network is available which satisfies the given {@link android.net.NetworkRequest}. This function behaves identically to the version that takes a NetworkCallback, but instead of {@link android.net.ConnectivityManager.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. <p> 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 <p> The operation Intent is delivered with two extras, a {@link android.net.Network} typed extra called {@link #EXTRA_NETWORK} and a {@link android.net.NetworkRequest} typed extra called {@link #EXTRA_NETWORK_REQUEST} containing the original requests parameters. <p> If there is already a 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 android.net.NetworkRequest}. <p> The request may be released normally by calling {@link #unregisterNetworkCallback(android.app.PendingIntent)}. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#ACCESS_NETWORK_STATE}. @param {Object {NetworkRequest}} request {@link NetworkRequest} describing this request. @param {Object {PendingIntent}} 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. */ registerNetworkCallback : function( ) {}, /**Requests bandwidth update for a given {@link android.net.Network} and returns whether the update request is accepted by ConnectivityService. Once accepted, ConnectivityService will poll underlying network connection for updated bandwidth information. The caller will be notified via {@link android.net.ConnectivityManager.NetworkCallback} if there is an update. Notice that this method assumes that the caller has previously called {@link #registerNetworkCallback} to listen for network changes. @param {Object {Network}} network {@link Network} specifying which network you're interested. @return {Boolean} {@code true} on success, {@code false} if the {@link Network} is no longer valid. */ requestBandwidthUpdate : function( ) {}, /**Unregisters callbacks about and possibly releases networks originating from {@link #requestNetwork(NetworkRequest, android.net.ConnectivityManager.NetworkCallback)} 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 {Object {ConnectivityManager.NetworkCallback}} networkCallback The {@link NetworkCallback} used when making the request. */ unregisterNetworkCallback : function( ) {}, /**Unregisters a callback previously registered via {@link #registerNetworkCallback(NetworkRequest, android.app.PendingIntent)}. @param {Object {PendingIntent}} operation A PendingIntent equal (as defined by {@link Intent#filterEquals}) to the PendingIntent passed to {@link #registerNetworkCallback(NetworkRequest, android.app.PendingIntent)}. Cannot be null. */ unregisterNetworkCallback : function( ) {}, /**Informs the system whether it should switch to {@code network} regardless of whether it is validated or not. If {@code accept} is true, and the network was explicitly selected by the user (e.g., by selecting a Wi-Fi network in the Settings app), then the network will become the system default network regardless of any other network that's currently connected. If {@code always} is true, then the choice is remembered, so that the next time the user connects to this network, the system will switch to it. <p>This method requires the caller to hold the permission {@link android.Manifest.permission#CONNECTIVITY_INTERNAL} @param {Object {Network}} network The network to accept. @param {Boolean} accept Whether to accept the network even if unvalidated. @param {Boolean} always Whether to remember this choice in the future. @hide */ setAcceptUnvalidated : function( ) {}, /**Resets all connectivity manager settings back to factory defaults. @hide */ factoryReset : function( ) {}, /**Binds the current process to {@code network}. All Sockets created in the future (and not explicitly bound via a bound SocketFactory from {@link android.net.Network#getSocketFactory() android.net.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 android.net.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 android.net.Network#getAllByName android.net.Network.getAllByName} is preferred to calling {@code bindProcessToNetwork}. @param {Object {Network}} network The {@link Network} to bind the current process to, or {@code null} to clear the current binding. @return {Boolean} {@code true} on success, {@code false} if the {@link Network} is no longer valid. */ bindProcessToNetwork : function( ) {}, /**Binds the current process to {@code network}. All Sockets created in the future (and not explicitly bound via a bound SocketFactory from {@link android.net.Network#getSocketFactory() android.net.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 android.net.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 android.net.Network#getAllByName android.net.Network.getAllByName} is preferred to calling {@code setProcessDefaultNetwork}. @param {Object {Network}} network The {@link Network} to bind the current process to, or {@code null} to clear the current binding. @return {Boolean} {@code true} on success, {@code false} if the {@link Network} is no longer valid. @deprecated This function can throw {@link IllegalStateException}. Use {@link #bindProcessToNetwork} instead. {@code bindProcessToNetwork} is a direct replacement. */ setProcessDefaultNetwork : function( ) {}, /**Returns the {@link android.net.Network} currently bound to this process via {@link #bindProcessToNetwork}, or {@code null} if no {@link android.net.Network} is explicitly bound. @return {Object {android.net.Network}} {@code Network} to which this process is bound, or {@code null}. */ getBoundNetworkForProcess : function( ) {}, /**Returns the {@link android.net.Network} currently bound to this process via {@link #bindProcessToNetwork}, or {@code null} if no {@link android.net.Network} is explicitly bound. @return {Object {android.net.Network}} {@code Network} to which this process is bound, or {@code null}. @deprecated Using this function can lead to other functions throwing {@link IllegalStateException}. Use {@link #getBoundNetworkForProcess} instead. {@code getBoundNetworkForProcess} is a direct replacement. */ getProcessDefaultNetwork : function( ) {}, /**Binds host resolutions performed by this process to {@code network}. {@link #bindProcessToNetwork} takes precedence over this setting. @param {Object {Network}} network The {@link Network} to bind host resolutions from the current process to, or {@code null} to clear the current binding. @return {Boolean} {@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}. */ setProcessDefaultNetworkForHostResolution : function( ) {}, };