/**@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
 &lt;receiver&gt; 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
 &lt;receiver&gt; 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(  ) {},


};