1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 package android.net; 17 18 import android.annotation.IntDef; 19 import android.annotation.Nullable; 20 import android.annotation.RequiresPermission; 21 import android.annotation.SdkConstant; 22 import android.annotation.SdkConstant.SdkConstantType; 23 import android.annotation.SystemApi; 24 import android.annotation.SystemService; 25 import android.app.PendingIntent; 26 import android.content.Context; 27 import android.content.Intent; 28 import android.content.pm.PackageManager; 29 import android.os.Binder; 30 import android.os.Build.VERSION_CODES; 31 import android.os.Bundle; 32 import android.os.Handler; 33 import android.os.HandlerThread; 34 import android.os.IBinder; 35 import android.os.INetworkActivityListener; 36 import android.os.INetworkManagementService; 37 import android.os.Looper; 38 import android.os.Message; 39 import android.os.Messenger; 40 import android.os.Process; 41 import android.os.RemoteException; 42 import android.os.ResultReceiver; 43 import android.os.ServiceManager; 44 import android.os.ServiceSpecificException; 45 import android.provider.Settings; 46 import android.telephony.SubscriptionManager; 47 import android.util.ArrayMap; 48 import android.util.Log; 49 import android.util.SparseIntArray; 50 51 import com.android.internal.telephony.ITelephony; 52 import com.android.internal.telephony.PhoneConstants; 53 import com.android.internal.util.Preconditions; 54 import com.android.internal.util.Protocol; 55 56 import libcore.net.event.NetworkEventDispatcher; 57 58 import java.lang.annotation.Retention; 59 import java.lang.annotation.RetentionPolicy; 60 import java.net.InetAddress; 61 import java.util.ArrayList; 62 import java.util.HashMap; 63 import java.util.List; 64 import java.util.Map; 65 66 /** 67 * Class that answers queries about the state of network connectivity. It also 68 * notifies applications when network connectivity changes. 69 * <p> 70 * The primary responsibilities of this class are to: 71 * <ol> 72 * <li>Monitor network connections (Wi-Fi, GPRS, UMTS, etc.)</li> 73 * <li>Send broadcast intents when network connectivity changes</li> 74 * <li>Attempt to "fail over" to another network when connectivity to a network 75 * is lost</li> 76 * <li>Provide an API that allows applications to query the coarse-grained or fine-grained 77 * state of the available networks</li> 78 * <li>Provide an API that allows applications to request and select networks for their data 79 * traffic</li> 80 * </ol> 81 */ 82 @SystemService(Context.CONNECTIVITY_SERVICE) 83 public class ConnectivityManager { 84 private static final String TAG = "ConnectivityManager"; 85 86 /** 87 * A change in network connectivity has occurred. A default connection has either 88 * been established or lost. The NetworkInfo for the affected network is 89 * sent as an extra; it should be consulted to see what kind of 90 * connectivity event occurred. 91 * <p/> 92 * Apps targeting Android 7.0 (API level 24) and higher do not receive this 93 * broadcast if they declare the broadcast receiver in their manifest. Apps 94 * will still receive broadcasts if they register their 95 * {@link android.content.BroadcastReceiver} with 96 * {@link android.content.Context#registerReceiver Context.registerReceiver()} 97 * and that context is still valid. 98 * <p/> 99 * If this is a connection that was the result of failing over from a 100 * disconnected network, then the FAILOVER_CONNECTION boolean extra is 101 * set to true. 102 * <p/> 103 * For a loss of connectivity, if the connectivity manager is attempting 104 * to connect (or has already connected) to another network, the 105 * NetworkInfo for the new network is also passed as an extra. This lets 106 * any receivers of the broadcast know that they should not necessarily 107 * tell the user that no data traffic will be possible. Instead, the 108 * receiver should expect another broadcast soon, indicating either that 109 * the failover attempt succeeded (and so there is still overall data 110 * connectivity), or that the failover attempt failed, meaning that all 111 * connectivity has been lost. 112 * <p/> 113 * For a disconnect event, the boolean extra EXTRA_NO_CONNECTIVITY 114 * is set to {@code true} if there are no connected networks at all. 115 */ 116 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 117 public static final String CONNECTIVITY_ACTION = "android.net.conn.CONNECTIVITY_CHANGE"; 118 119 /** 120 * A temporary hack until SUPL system can get off the legacy APIS. 121 * They do too many network requests and the long list of apps listening 122 * and waking due to the CONNECTIVITY_ACTION bcast makes it expensive. 123 * Use this bcast intent instead for SUPL requests. 124 * @hide 125 */ 126 public static final String CONNECTIVITY_ACTION_SUPL = 127 "android.net.conn.CONNECTIVITY_CHANGE_SUPL"; 128 129 /** 130 * The device has connected to a network that has presented a captive 131 * portal, which is blocking Internet connectivity. The user was presented 132 * with a notification that network sign in is required, 133 * and the user invoked the notification's action indicating they 134 * desire to sign in to the network. Apps handling this activity should 135 * facilitate signing in to the network. This action includes a 136 * {@link Network} typed extra called {@link #EXTRA_NETWORK} that represents 137 * the network presenting the captive portal; all communication with the 138 * captive portal must be done using this {@code Network} object. 139 * <p/> 140 * This activity includes a {@link CaptivePortal} extra named 141 * {@link #EXTRA_CAPTIVE_PORTAL} that can be used to indicate different 142 * outcomes of the captive portal sign in to the system: 143 * <ul> 144 * <li> When the app handling this action believes the user has signed in to 145 * the network and the captive portal has been dismissed, the app should 146 * call {@link CaptivePortal#reportCaptivePortalDismissed} so the system can 147 * reevaluate the network. If reevaluation finds the network no longer 148 * subject to a captive portal, the network may become the default active 149 * data network. </li> 150 * <li> When the app handling this action believes the user explicitly wants 151 * to ignore the captive portal and the network, the app should call 152 * {@link CaptivePortal#ignoreNetwork}. </li> 153 * </ul> 154 */ 155 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 156 public static final String ACTION_CAPTIVE_PORTAL_SIGN_IN = "android.net.conn.CAPTIVE_PORTAL"; 157 158 /** 159 * The lookup key for a {@link NetworkInfo} object. Retrieve with 160 * {@link android.content.Intent#getParcelableExtra(String)}. 161 * 162 * @deprecated Since {@link NetworkInfo} can vary based on UID, applications 163 * should always obtain network information through 164 * {@link #getActiveNetworkInfo()}. 165 * @see #EXTRA_NETWORK_TYPE 166 */ 167 @Deprecated 168 public static final String EXTRA_NETWORK_INFO = "networkInfo"; 169 170 /** 171 * Network type which triggered a {@link #CONNECTIVITY_ACTION} broadcast. 172 * 173 * @see android.content.Intent#getIntExtra(String, int) 174 */ 175 public static final String EXTRA_NETWORK_TYPE = "networkType"; 176 177 /** 178 * The lookup key for a boolean that indicates whether a connect event 179 * is for a network to which the connectivity manager was failing over 180 * following a disconnect on another network. 181 * Retrieve it with {@link android.content.Intent#getBooleanExtra(String,boolean)}. 182 */ 183 public static final String EXTRA_IS_FAILOVER = "isFailover"; 184 /** 185 * The lookup key for a {@link NetworkInfo} object. This is supplied when 186 * there is another network that it may be possible to connect to. Retrieve with 187 * {@link android.content.Intent#getParcelableExtra(String)}. 188 */ 189 public static final String EXTRA_OTHER_NETWORK_INFO = "otherNetwork"; 190 /** 191 * The lookup key for a boolean that indicates whether there is a 192 * complete lack of connectivity, i.e., no network is available. 193 * Retrieve it with {@link android.content.Intent#getBooleanExtra(String,boolean)}. 194 */ 195 public static final String EXTRA_NO_CONNECTIVITY = "noConnectivity"; 196 /** 197 * The lookup key for a string that indicates why an attempt to connect 198 * to a network failed. The string has no particular structure. It is 199 * intended to be used in notifications presented to users. Retrieve 200 * it with {@link android.content.Intent#getStringExtra(String)}. 201 */ 202 public static final String EXTRA_REASON = "reason"; 203 /** 204 * The lookup key for a string that provides optionally supplied 205 * extra information about the network state. The information 206 * may be passed up from the lower networking layers, and its 207 * meaning may be specific to a particular network type. Retrieve 208 * it with {@link android.content.Intent#getStringExtra(String)}. 209 */ 210 public static final String EXTRA_EXTRA_INFO = "extraInfo"; 211 /** 212 * The lookup key for an int that provides information about 213 * our connection to the internet at large. 0 indicates no connection, 214 * 100 indicates a great connection. Retrieve it with 215 * {@link android.content.Intent#getIntExtra(String, int)}. 216 * {@hide} 217 */ 218 public static final String EXTRA_INET_CONDITION = "inetCondition"; 219 /** 220 * The lookup key for a {@link CaptivePortal} object included with the 221 * {@link #ACTION_CAPTIVE_PORTAL_SIGN_IN} intent. The {@code CaptivePortal} 222 * object can be used to either indicate to the system that the captive 223 * portal has been dismissed or that the user does not want to pursue 224 * signing in to captive portal. Retrieve it with 225 * {@link android.content.Intent#getParcelableExtra(String)}. 226 */ 227 public static final String EXTRA_CAPTIVE_PORTAL = "android.net.extra.CAPTIVE_PORTAL"; 228 229 /** 230 * Key for passing a URL to the captive portal login activity. 231 */ 232 public static final String EXTRA_CAPTIVE_PORTAL_URL = "android.net.extra.CAPTIVE_PORTAL_URL"; 233 234 /** 235 * Key for passing a user agent string to the captive portal login activity. 236 * {@hide} 237 */ 238 public static final String EXTRA_CAPTIVE_PORTAL_USER_AGENT = 239 "android.net.extra.CAPTIVE_PORTAL_USER_AGENT"; 240 241 /** 242 * Broadcast action to indicate the change of data activity status 243 * (idle or active) on a network in a recent period. 244 * The network becomes active when data transmission is started, or 245 * idle if there is no data transmission for a period of time. 246 * {@hide} 247 */ 248 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 249 public static final String ACTION_DATA_ACTIVITY_CHANGE = "android.net.conn.DATA_ACTIVITY_CHANGE"; 250 /** 251 * The lookup key for an enum that indicates the network device type on which this data activity 252 * change happens. 253 * {@hide} 254 */ 255 public static final String EXTRA_DEVICE_TYPE = "deviceType"; 256 /** 257 * The lookup key for a boolean that indicates the device is active or not. {@code true} means 258 * it is actively sending or receiving data and {@code false} means it is idle. 259 * {@hide} 260 */ 261 public static final String EXTRA_IS_ACTIVE = "isActive"; 262 /** 263 * The lookup key for a long that contains the timestamp (nanos) of the radio state change. 264 * {@hide} 265 */ 266 public static final String EXTRA_REALTIME_NS = "tsNanos"; 267 268 /** 269 * Broadcast Action: The setting for background data usage has changed 270 * values. Use {@link #getBackgroundDataSetting()} to get the current value. 271 * <p> 272 * If an application uses the network in the background, it should listen 273 * for this broadcast and stop using the background data if the value is 274 * {@code false}. 275 * <p> 276 * 277 * @deprecated As of {@link VERSION_CODES#ICE_CREAM_SANDWICH}, availability 278 * of background data depends on several combined factors, and 279 * this broadcast is no longer sent. Instead, when background 280 * data is unavailable, {@link #getActiveNetworkInfo()} will now 281 * appear disconnected. During first boot after a platform 282 * upgrade, this broadcast will be sent once if 283 * {@link #getBackgroundDataSetting()} was {@code false} before 284 * the upgrade. 285 */ 286 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 287 @Deprecated 288 public static final String ACTION_BACKGROUND_DATA_SETTING_CHANGED = 289 "android.net.conn.BACKGROUND_DATA_SETTING_CHANGED"; 290 291 /** 292 * Broadcast Action: The network connection may not be good 293 * uses {@code ConnectivityManager.EXTRA_INET_CONDITION} and 294 * {@code ConnectivityManager.EXTRA_NETWORK_INFO} to specify 295 * the network and it's condition. 296 * @hide 297 */ 298 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 299 public static final String INET_CONDITION_ACTION = 300 "android.net.conn.INET_CONDITION_ACTION"; 301 302 /** 303 * Broadcast Action: A tetherable connection has come or gone. 304 * Uses {@code ConnectivityManager.EXTRA_AVAILABLE_TETHER}, 305 * {@code ConnectivityManager.EXTRA_ACTIVE_LOCAL_ONLY}, 306 * {@code ConnectivityManager.EXTRA_ACTIVE_TETHER}, and 307 * {@code ConnectivityManager.EXTRA_ERRORED_TETHER} to indicate 308 * the current state of tethering. Each include a list of 309 * interface names in that state (may be empty). 310 * @hide 311 */ 312 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 313 public static final String ACTION_TETHER_STATE_CHANGED = 314 "android.net.conn.TETHER_STATE_CHANGED"; 315 316 /** 317 * @hide 318 * gives a String[] listing all the interfaces configured for 319 * tethering and currently available for tethering. 320 */ 321 public static final String EXTRA_AVAILABLE_TETHER = "availableArray"; 322 323 /** 324 * @hide 325 * gives a String[] listing all the interfaces currently in local-only 326 * mode (ie, has DHCPv4+IPv6-ULA support and no packet forwarding) 327 */ 328 public static final String EXTRA_ACTIVE_LOCAL_ONLY = "localOnlyArray"; 329 330 /** 331 * @hide 332 * gives a String[] listing all the interfaces currently tethered 333 * (ie, has DHCPv4 support and packets potentially forwarded/NATed) 334 */ 335 public static final String EXTRA_ACTIVE_TETHER = "tetherArray"; 336 337 /** 338 * @hide 339 * gives a String[] listing all the interfaces we tried to tether and 340 * failed. Use {@link #getLastTetherError} to find the error code 341 * for any interfaces listed here. 342 */ 343 public static final String EXTRA_ERRORED_TETHER = "erroredArray"; 344 345 /** 346 * Broadcast Action: The captive portal tracker has finished its test. 347 * Sent only while running Setup Wizard, in lieu of showing a user 348 * notification. 349 * @hide 350 */ 351 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 352 public static final String ACTION_CAPTIVE_PORTAL_TEST_COMPLETED = 353 "android.net.conn.CAPTIVE_PORTAL_TEST_COMPLETED"; 354 /** 355 * The lookup key for a boolean that indicates whether a captive portal was detected. 356 * Retrieve it with {@link android.content.Intent#getBooleanExtra(String,boolean)}. 357 * @hide 358 */ 359 public static final String EXTRA_IS_CAPTIVE_PORTAL = "captivePortal"; 360 361 /** 362 * Action used to display a dialog that asks the user whether to connect to a network that is 363 * not validated. This intent is used to start the dialog in settings via startActivity. 364 * 365 * @hide 366 */ 367 public static final String ACTION_PROMPT_UNVALIDATED = "android.net.conn.PROMPT_UNVALIDATED"; 368 369 /** 370 * Action used to display a dialog that asks the user whether to avoid a network that is no 371 * longer validated. This intent is used to start the dialog in settings via startActivity. 372 * 373 * @hide 374 */ 375 public static final String ACTION_PROMPT_LOST_VALIDATION = 376 "android.net.conn.PROMPT_LOST_VALIDATION"; 377 378 /** 379 * Invalid tethering type. 380 * @see #startTethering(int, OnStartTetheringCallback, boolean) 381 * @hide 382 */ 383 public static final int TETHERING_INVALID = -1; 384 385 /** 386 * Wifi tethering type. 387 * @see #startTethering(int, OnStartTetheringCallback, boolean) 388 * @hide 389 */ 390 @SystemApi 391 public static final int TETHERING_WIFI = 0; 392 393 /** 394 * USB tethering type. 395 * @see #startTethering(int, OnStartTetheringCallback, boolean) 396 * @hide 397 */ 398 @SystemApi 399 public static final int TETHERING_USB = 1; 400 401 /** 402 * Bluetooth tethering type. 403 * @see #startTethering(int, OnStartTetheringCallback, boolean) 404 * @hide 405 */ 406 @SystemApi 407 public static final int TETHERING_BLUETOOTH = 2; 408 409 /** 410 * Extra used for communicating with the TetherService. Includes the type of tethering to 411 * enable if any. 412 * @hide 413 */ 414 public static final String EXTRA_ADD_TETHER_TYPE = "extraAddTetherType"; 415 416 /** 417 * Extra used for communicating with the TetherService. Includes the type of tethering for 418 * which to cancel provisioning. 419 * @hide 420 */ 421 public static final String EXTRA_REM_TETHER_TYPE = "extraRemTetherType"; 422 423 /** 424 * Extra used for communicating with the TetherService. True to schedule a recheck of tether 425 * provisioning. 426 * @hide 427 */ 428 public static final String EXTRA_SET_ALARM = "extraSetAlarm"; 429 430 /** 431 * Tells the TetherService to run a provision check now. 432 * @hide 433 */ 434 public static final String EXTRA_RUN_PROVISION = "extraRunProvision"; 435 436 /** 437 * Extra used for communicating with the TetherService. Contains the {@link ResultReceiver} 438 * which will receive provisioning results. Can be left empty. 439 * @hide 440 */ 441 public static final String EXTRA_PROVISION_CALLBACK = "extraProvisionCallback"; 442 443 /** 444 * The absence of a connection type. 445 * @hide 446 */ 447 public static final int TYPE_NONE = -1; 448 449 /** 450 * The Mobile data connection. When active, all data traffic 451 * will use this network type's interface by default 452 * (it has a default route) 453 */ 454 public static final int TYPE_MOBILE = 0; 455 /** 456 * The WIFI data connection. When active, all data traffic 457 * will use this network type's interface by default 458 * (it has a default route). 459 */ 460 public static final int TYPE_WIFI = 1; 461 /** 462 * An MMS-specific Mobile data connection. This network type may use the 463 * same network interface as {@link #TYPE_MOBILE} or it may use a different 464 * one. This is used by applications needing to talk to the carrier's 465 * Multimedia Messaging Service servers. 466 * 467 * @deprecated Applications should instead use 468 * {@link #requestNetwork(NetworkRequest, NetworkCallback)} to request a network that 469 * provides the {@link NetworkCapabilities#NET_CAPABILITY_MMS} capability. 470 */ 471 @Deprecated 472 public static final int TYPE_MOBILE_MMS = 2; 473 /** 474 * A SUPL-specific Mobile data connection. This network type may use the 475 * same network interface as {@link #TYPE_MOBILE} or it may use a different 476 * one. This is used by applications needing to talk to the carrier's 477 * Secure User Plane Location servers for help locating the device. 478 * 479 * @deprecated Applications should instead use 480 * {@link #requestNetwork(NetworkRequest, NetworkCallback)} to request a network that 481 * provides the {@link NetworkCapabilities#NET_CAPABILITY_SUPL} capability. 482 */ 483 @Deprecated 484 public static final int TYPE_MOBILE_SUPL = 3; 485 /** 486 * A DUN-specific Mobile data connection. This network type may use the 487 * same network interface as {@link #TYPE_MOBILE} or it may use a different 488 * one. This is sometimes by the system when setting up an upstream connection 489 * for tethering so that the carrier is aware of DUN traffic. 490 */ 491 public static final int TYPE_MOBILE_DUN = 4; 492 /** 493 * A High Priority Mobile data connection. This network type uses the 494 * same network interface as {@link #TYPE_MOBILE} but the routing setup 495 * is different. 496 * 497 * @deprecated Applications should instead use 498 * {@link #requestNetwork(NetworkRequest, NetworkCallback)} to request a network that 499 * uses the {@link NetworkCapabilities#TRANSPORT_CELLULAR} transport. 500 */ 501 @Deprecated 502 public static final int TYPE_MOBILE_HIPRI = 5; 503 /** 504 * The WiMAX data connection. When active, all data traffic 505 * will use this network type's interface by default 506 * (it has a default route). 507 */ 508 public static final int TYPE_WIMAX = 6; 509 510 /** 511 * The Bluetooth data connection. When active, all data traffic 512 * will use this network type's interface by default 513 * (it has a default route). 514 */ 515 public static final int TYPE_BLUETOOTH = 7; 516 517 /** 518 * Dummy data connection. This should not be used on shipping devices. 519 */ 520 public static final int TYPE_DUMMY = 8; 521 522 /** 523 * The Ethernet data connection. When active, all data traffic 524 * will use this network type's interface by default 525 * (it has a default route). 526 */ 527 public static final int TYPE_ETHERNET = 9; 528 529 /** 530 * Over the air Administration. 531 * {@hide} 532 */ 533 public static final int TYPE_MOBILE_FOTA = 10; 534 535 /** 536 * IP Multimedia Subsystem. 537 * {@hide} 538 */ 539 public static final int TYPE_MOBILE_IMS = 11; 540 541 /** 542 * Carrier Branded Services. 543 * {@hide} 544 */ 545 public static final int TYPE_MOBILE_CBS = 12; 546 547 /** 548 * A Wi-Fi p2p connection. Only requesting processes will have access to 549 * the peers connected. 550 * {@hide} 551 */ 552 public static final int TYPE_WIFI_P2P = 13; 553 554 /** 555 * The network to use for initially attaching to the network 556 * {@hide} 557 */ 558 public static final int TYPE_MOBILE_IA = 14; 559 560 /** 561 * Emergency PDN connection for emergency services. This 562 * may include IMS and MMS in emergency situations. 563 * {@hide} 564 */ 565 public static final int TYPE_MOBILE_EMERGENCY = 15; 566 567 /** 568 * The network that uses proxy to achieve connectivity. 569 * {@hide} 570 */ 571 public static final int TYPE_PROXY = 16; 572 573 /** 574 * A virtual network using one or more native bearers. 575 * It may or may not be providing security services. 576 */ 577 public static final int TYPE_VPN = 17; 578 579 /** {@hide} */ 580 public static final int MAX_RADIO_TYPE = TYPE_VPN; 581 582 /** {@hide} */ 583 public static final int MAX_NETWORK_TYPE = TYPE_VPN; 584 585 private static final int MIN_NETWORK_TYPE = TYPE_MOBILE; 586 587 /** 588 * If you want to set the default network preference,you can directly 589 * change the networkAttributes array in framework's config.xml. 590 * 591 * @deprecated Since we support so many more networks now, the single 592 * network default network preference can't really express 593 * the hierarchy. Instead, the default is defined by the 594 * networkAttributes in config.xml. You can determine 595 * the current value by calling {@link #getNetworkPreference()} 596 * from an App. 597 */ 598 @Deprecated 599 public static final int DEFAULT_NETWORK_PREFERENCE = TYPE_WIFI; 600 601 /** 602 * @hide 603 */ 604 public static final int REQUEST_ID_UNSET = 0; 605 606 /** 607 * Static unique request used as a tombstone for NetworkCallbacks that have been unregistered. 608 * This allows to distinguish when unregistering NetworkCallbacks those that were never 609 * registered and those that were already unregistered. 610 * @hide 611 */ 612 private static final NetworkRequest ALREADY_UNREGISTERED = 613 new NetworkRequest.Builder().clearCapabilities().build(); 614 615 /** 616 * A NetID indicating no Network is selected. 617 * Keep in sync with bionic/libc/dns/include/resolv_netid.h 618 * @hide 619 */ 620 public static final int NETID_UNSET = 0; 621 622 private final IConnectivityManager mService; 623 /** 624 * A kludge to facilitate static access where a Context pointer isn't available, like in the 625 * case of the static set/getProcessDefaultNetwork methods and from the Network class. 626 * TODO: Remove this after deprecating the static methods in favor of non-static methods or 627 * methods that take a Context argument. 628 */ 629 private static ConnectivityManager sInstance; 630 631 private final Context mContext; 632 633 private INetworkManagementService mNMService; 634 private INetworkPolicyManager mNPManager; 635 636 /** 637 * Tests if a given integer represents a valid network type. 638 * @param networkType the type to be tested 639 * @return a boolean. {@code true} if the type is valid, else {@code false} 640 * @deprecated All APIs accepting a network type are deprecated. There should be no need to 641 * validate a network type. 642 */ 643 @Deprecated isNetworkTypeValid(int networkType)644 public static boolean isNetworkTypeValid(int networkType) { 645 return MIN_NETWORK_TYPE <= networkType && networkType <= MAX_NETWORK_TYPE; 646 } 647 648 /** 649 * Returns a non-localized string representing a given network type. 650 * ONLY used for debugging output. 651 * @param type the type needing naming 652 * @return a String for the given type, or a string version of the type ("87") 653 * if no name is known. 654 * {@hide} 655 */ getNetworkTypeName(int type)656 public static String getNetworkTypeName(int type) { 657 switch (type) { 658 case TYPE_NONE: 659 return "NONE"; 660 case TYPE_MOBILE: 661 return "MOBILE"; 662 case TYPE_WIFI: 663 return "WIFI"; 664 case TYPE_MOBILE_MMS: 665 return "MOBILE_MMS"; 666 case TYPE_MOBILE_SUPL: 667 return "MOBILE_SUPL"; 668 case TYPE_MOBILE_DUN: 669 return "MOBILE_DUN"; 670 case TYPE_MOBILE_HIPRI: 671 return "MOBILE_HIPRI"; 672 case TYPE_WIMAX: 673 return "WIMAX"; 674 case TYPE_BLUETOOTH: 675 return "BLUETOOTH"; 676 case TYPE_DUMMY: 677 return "DUMMY"; 678 case TYPE_ETHERNET: 679 return "ETHERNET"; 680 case TYPE_MOBILE_FOTA: 681 return "MOBILE_FOTA"; 682 case TYPE_MOBILE_IMS: 683 return "MOBILE_IMS"; 684 case TYPE_MOBILE_CBS: 685 return "MOBILE_CBS"; 686 case TYPE_WIFI_P2P: 687 return "WIFI_P2P"; 688 case TYPE_MOBILE_IA: 689 return "MOBILE_IA"; 690 case TYPE_MOBILE_EMERGENCY: 691 return "MOBILE_EMERGENCY"; 692 case TYPE_PROXY: 693 return "PROXY"; 694 case TYPE_VPN: 695 return "VPN"; 696 default: 697 return Integer.toString(type); 698 } 699 } 700 701 /** 702 * Checks if a given type uses the cellular data connection. 703 * This should be replaced in the future by a network property. 704 * @param networkType the type to check 705 * @return a boolean - {@code true} if uses cellular network, else {@code false} 706 * {@hide} 707 */ isNetworkTypeMobile(int networkType)708 public static boolean isNetworkTypeMobile(int networkType) { 709 switch (networkType) { 710 case TYPE_MOBILE: 711 case TYPE_MOBILE_MMS: 712 case TYPE_MOBILE_SUPL: 713 case TYPE_MOBILE_DUN: 714 case TYPE_MOBILE_HIPRI: 715 case TYPE_MOBILE_FOTA: 716 case TYPE_MOBILE_IMS: 717 case TYPE_MOBILE_CBS: 718 case TYPE_MOBILE_IA: 719 case TYPE_MOBILE_EMERGENCY: 720 return true; 721 default: 722 return false; 723 } 724 } 725 726 /** 727 * Checks if the given network type is backed by a Wi-Fi radio. 728 * 729 * @hide 730 */ isNetworkTypeWifi(int networkType)731 public static boolean isNetworkTypeWifi(int networkType) { 732 switch (networkType) { 733 case TYPE_WIFI: 734 case TYPE_WIFI_P2P: 735 return true; 736 default: 737 return false; 738 } 739 } 740 741 /** 742 * Specifies the preferred network type. When the device has more 743 * than one type available the preferred network type will be used. 744 * 745 * @param preference the network type to prefer over all others. It is 746 * unspecified what happens to the old preferred network in the 747 * overall ordering. 748 * @deprecated Functionality has been removed as it no longer makes sense, 749 * with many more than two networks - we'd need an array to express 750 * preference. Instead we use dynamic network properties of 751 * the networks to describe their precedence. 752 */ 753 @Deprecated setNetworkPreference(int preference)754 public void setNetworkPreference(int preference) { 755 } 756 757 /** 758 * Retrieves the current preferred network type. 759 * 760 * @return an integer representing the preferred network type 761 * 762 * @deprecated Functionality has been removed as it no longer makes sense, 763 * with many more than two networks - we'd need an array to express 764 * preference. Instead we use dynamic network properties of 765 * the networks to describe their precedence. 766 */ 767 @Deprecated 768 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getNetworkPreference()769 public int getNetworkPreference() { 770 return TYPE_NONE; 771 } 772 773 /** 774 * Returns details about the currently active default data network. When 775 * connected, this network is the default route for outgoing connections. 776 * You should always check {@link NetworkInfo#isConnected()} before initiating 777 * network traffic. This may return {@code null} when there is no default 778 * network. 779 * 780 * @return a {@link NetworkInfo} object for the current default network 781 * or {@code null} if no default network is currently active 782 */ 783 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getActiveNetworkInfo()784 public NetworkInfo getActiveNetworkInfo() { 785 try { 786 return mService.getActiveNetworkInfo(); 787 } catch (RemoteException e) { 788 throw e.rethrowFromSystemServer(); 789 } 790 } 791 792 /** 793 * Returns a {@link Network} object corresponding to the currently active 794 * default data network. In the event that the current active default data 795 * network disconnects, the returned {@code Network} object will no longer 796 * be usable. This will return {@code null} when there is no default 797 * network. 798 * 799 * @return a {@link Network} object for the current default network or 800 * {@code null} if no default network is currently active 801 */ 802 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getActiveNetwork()803 public Network getActiveNetwork() { 804 try { 805 return mService.getActiveNetwork(); 806 } catch (RemoteException e) { 807 throw e.rethrowFromSystemServer(); 808 } 809 } 810 811 /** 812 * Returns a {@link Network} object corresponding to the currently active 813 * default data network for a specific UID. In the event that the default data 814 * network disconnects, the returned {@code Network} object will no longer 815 * be usable. This will return {@code null} when there is no default 816 * network for the UID. 817 * 818 * @return a {@link Network} object for the current default network for the 819 * given UID or {@code null} if no default network is currently active 820 * 821 * @hide 822 */ 823 @RequiresPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL) getActiveNetworkForUid(int uid)824 public Network getActiveNetworkForUid(int uid) { 825 return getActiveNetworkForUid(uid, false); 826 } 827 828 /** {@hide} */ getActiveNetworkForUid(int uid, boolean ignoreBlocked)829 public Network getActiveNetworkForUid(int uid, boolean ignoreBlocked) { 830 try { 831 return mService.getActiveNetworkForUid(uid, ignoreBlocked); 832 } catch (RemoteException e) { 833 throw e.rethrowFromSystemServer(); 834 } 835 } 836 837 /** 838 * Checks if a VPN app supports always-on mode. 839 * 840 * In order to support the always-on feature, an app has to 841 * <ul> 842 * <li>target {@link VERSION_CODES#N API 24} or above, and 843 * <li>not opt out through the {@link VpnService#SERVICE_META_DATA_SUPPORTS_ALWAYS_ON} 844 * meta-data field. 845 * </ul> 846 * 847 * @param userId The identifier of the user for whom the VPN app is installed. 848 * @param vpnPackage The canonical package name of the VPN app. 849 * @return {@code true} if and only if the VPN app exists and supports always-on mode. 850 * @hide 851 */ isAlwaysOnVpnPackageSupportedForUser(int userId, @Nullable String vpnPackage)852 public boolean isAlwaysOnVpnPackageSupportedForUser(int userId, @Nullable String vpnPackage) { 853 try { 854 return mService.isAlwaysOnVpnPackageSupported(userId, vpnPackage); 855 } catch (RemoteException e) { 856 throw e.rethrowFromSystemServer(); 857 } 858 } 859 860 /** 861 * Configures an always-on VPN connection through a specific application. 862 * This connection is automatically granted and persisted after a reboot. 863 * 864 * <p>The designated package should declare a {@link VpnService} in its 865 * manifest guarded by {@link android.Manifest.permission.BIND_VPN_SERVICE}, 866 * otherwise the call will fail. 867 * 868 * @param userId The identifier of the user to set an always-on VPN for. 869 * @param vpnPackage The package name for an installed VPN app on the device, or {@code null} 870 * to remove an existing always-on VPN configuration. 871 * @param lockdownEnabled {@code true} to disallow networking when the VPN is not connected or 872 * {@code false} otherwise. 873 * @return {@code true} if the package is set as always-on VPN controller; 874 * {@code false} otherwise. 875 * @hide 876 */ setAlwaysOnVpnPackageForUser(int userId, @Nullable String vpnPackage, boolean lockdownEnabled)877 public boolean setAlwaysOnVpnPackageForUser(int userId, @Nullable String vpnPackage, 878 boolean lockdownEnabled) { 879 try { 880 return mService.setAlwaysOnVpnPackage(userId, vpnPackage, lockdownEnabled); 881 } catch (RemoteException e) { 882 throw e.rethrowFromSystemServer(); 883 } 884 } 885 886 /** 887 * Returns the package name of the currently set always-on VPN application. 888 * If there is no always-on VPN set, or the VPN is provided by the system instead 889 * of by an app, {@code null} will be returned. 890 * 891 * @return Package name of VPN controller responsible for always-on VPN, 892 * or {@code null} if none is set. 893 * @hide 894 */ getAlwaysOnVpnPackageForUser(int userId)895 public String getAlwaysOnVpnPackageForUser(int userId) { 896 try { 897 return mService.getAlwaysOnVpnPackage(userId); 898 } catch (RemoteException e) { 899 throw e.rethrowFromSystemServer(); 900 } 901 } 902 903 /** 904 * Returns details about the currently active default data network 905 * for a given uid. This is for internal use only to avoid spying 906 * other apps. 907 * 908 * @return a {@link NetworkInfo} object for the current default network 909 * for the given uid or {@code null} if no default network is 910 * available for the specified uid. 911 * 912 * {@hide} 913 */ 914 @RequiresPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL) getActiveNetworkInfoForUid(int uid)915 public NetworkInfo getActiveNetworkInfoForUid(int uid) { 916 return getActiveNetworkInfoForUid(uid, false); 917 } 918 919 /** {@hide} */ getActiveNetworkInfoForUid(int uid, boolean ignoreBlocked)920 public NetworkInfo getActiveNetworkInfoForUid(int uid, boolean ignoreBlocked) { 921 try { 922 return mService.getActiveNetworkInfoForUid(uid, ignoreBlocked); 923 } catch (RemoteException e) { 924 throw e.rethrowFromSystemServer(); 925 } 926 } 927 928 /** 929 * Returns connection status information about a particular 930 * network type. 931 * 932 * @param networkType integer specifying which networkType in 933 * which you're interested. 934 * @return a {@link NetworkInfo} object for the requested 935 * network type or {@code null} if the type is not 936 * supported by the device. 937 * 938 * @deprecated This method does not support multiple connected networks 939 * of the same type. Use {@link #getAllNetworks} and 940 * {@link #getNetworkInfo(android.net.Network)} instead. 941 */ 942 @Deprecated 943 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getNetworkInfo(int networkType)944 public NetworkInfo getNetworkInfo(int networkType) { 945 try { 946 return mService.getNetworkInfo(networkType); 947 } catch (RemoteException e) { 948 throw e.rethrowFromSystemServer(); 949 } 950 } 951 952 /** 953 * Returns connection status information about a particular 954 * Network. 955 * 956 * @param network {@link Network} specifying which network 957 * in which you're interested. 958 * @return a {@link NetworkInfo} object for the requested 959 * network or {@code null} if the {@code Network} 960 * is not valid. 961 */ 962 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getNetworkInfo(Network network)963 public NetworkInfo getNetworkInfo(Network network) { 964 return getNetworkInfoForUid(network, Process.myUid(), false); 965 } 966 967 /** {@hide} */ getNetworkInfoForUid(Network network, int uid, boolean ignoreBlocked)968 public NetworkInfo getNetworkInfoForUid(Network network, int uid, boolean ignoreBlocked) { 969 try { 970 return mService.getNetworkInfoForUid(network, uid, ignoreBlocked); 971 } catch (RemoteException e) { 972 throw e.rethrowFromSystemServer(); 973 } 974 } 975 976 /** 977 * Returns connection status information about all network 978 * types supported by the device. 979 * 980 * @return an array of {@link NetworkInfo} objects. Check each 981 * {@link NetworkInfo#getType} for which type each applies. 982 * 983 * @deprecated This method does not support multiple connected networks 984 * of the same type. Use {@link #getAllNetworks} and 985 * {@link #getNetworkInfo(android.net.Network)} instead. 986 */ 987 @Deprecated 988 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getAllNetworkInfo()989 public NetworkInfo[] getAllNetworkInfo() { 990 try { 991 return mService.getAllNetworkInfo(); 992 } catch (RemoteException e) { 993 throw e.rethrowFromSystemServer(); 994 } 995 } 996 997 /** 998 * Returns the {@link Network} object currently serving a given type, or 999 * null if the given type is not connected. 1000 * 1001 * @hide 1002 * @deprecated This method does not support multiple connected networks 1003 * of the same type. Use {@link #getAllNetworks} and 1004 * {@link #getNetworkInfo(android.net.Network)} instead. 1005 */ 1006 @Deprecated 1007 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getNetworkForType(int networkType)1008 public Network getNetworkForType(int networkType) { 1009 try { 1010 return mService.getNetworkForType(networkType); 1011 } catch (RemoteException e) { 1012 throw e.rethrowFromSystemServer(); 1013 } 1014 } 1015 1016 /** 1017 * Returns an array of all {@link Network} currently tracked by the 1018 * framework. 1019 * 1020 * @return an array of {@link Network} objects. 1021 */ 1022 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getAllNetworks()1023 public Network[] getAllNetworks() { 1024 try { 1025 return mService.getAllNetworks(); 1026 } catch (RemoteException e) { 1027 throw e.rethrowFromSystemServer(); 1028 } 1029 } 1030 1031 /** 1032 * Returns an array of {@link android.net.NetworkCapabilities} objects, representing 1033 * the Networks that applications run by the given user will use by default. 1034 * @hide 1035 */ getDefaultNetworkCapabilitiesForUser(int userId)1036 public NetworkCapabilities[] getDefaultNetworkCapabilitiesForUser(int userId) { 1037 try { 1038 return mService.getDefaultNetworkCapabilitiesForUser(userId); 1039 } catch (RemoteException e) { 1040 throw e.rethrowFromSystemServer(); 1041 } 1042 } 1043 1044 /** 1045 * Returns the IP information for the current default network. 1046 * 1047 * @return a {@link LinkProperties} object describing the IP info 1048 * for the current default network, or {@code null} if there 1049 * is no current default network. 1050 * 1051 * {@hide} 1052 */ 1053 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getActiveLinkProperties()1054 public LinkProperties getActiveLinkProperties() { 1055 try { 1056 return mService.getActiveLinkProperties(); 1057 } catch (RemoteException e) { 1058 throw e.rethrowFromSystemServer(); 1059 } 1060 } 1061 1062 /** 1063 * Returns the IP information for a given network type. 1064 * 1065 * @param networkType the network type of interest. 1066 * @return a {@link LinkProperties} object describing the IP info 1067 * for the given networkType, or {@code null} if there is 1068 * no current default network. 1069 * 1070 * {@hide} 1071 * @deprecated This method does not support multiple connected networks 1072 * of the same type. Use {@link #getAllNetworks}, 1073 * {@link #getNetworkInfo(android.net.Network)}, and 1074 * {@link #getLinkProperties(android.net.Network)} instead. 1075 */ 1076 @Deprecated 1077 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getLinkProperties(int networkType)1078 public LinkProperties getLinkProperties(int networkType) { 1079 try { 1080 return mService.getLinkPropertiesForType(networkType); 1081 } catch (RemoteException e) { 1082 throw e.rethrowFromSystemServer(); 1083 } 1084 } 1085 1086 /** 1087 * Get the {@link LinkProperties} for the given {@link Network}. This 1088 * will return {@code null} if the network is unknown. 1089 * 1090 * @param network The {@link Network} object identifying the network in question. 1091 * @return The {@link LinkProperties} for the network, or {@code null}. 1092 */ 1093 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getLinkProperties(Network network)1094 public LinkProperties getLinkProperties(Network network) { 1095 try { 1096 return mService.getLinkProperties(network); 1097 } catch (RemoteException e) { 1098 throw e.rethrowFromSystemServer(); 1099 } 1100 } 1101 1102 /** 1103 * Get the {@link android.net.NetworkCapabilities} for the given {@link Network}. This 1104 * will return {@code null} if the network is unknown. 1105 * 1106 * @param network The {@link Network} object identifying the network in question. 1107 * @return The {@link android.net.NetworkCapabilities} for the network, or {@code null}. 1108 */ 1109 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getNetworkCapabilities(Network network)1110 public NetworkCapabilities getNetworkCapabilities(Network network) { 1111 try { 1112 return mService.getNetworkCapabilities(network); 1113 } catch (RemoteException e) { 1114 throw e.rethrowFromSystemServer(); 1115 } 1116 } 1117 1118 /** 1119 * Gets the URL that should be used for resolving whether a captive portal is present. 1120 * 1. This URL should respond with a 204 response to a GET request to indicate no captive 1121 * portal is present. 1122 * 2. This URL must be HTTP as redirect responses are used to find captive portal 1123 * sign-in pages. Captive portals cannot respond to HTTPS requests with redirects. 1124 * 1125 * @hide 1126 */ 1127 @SystemApi 1128 @RequiresPermission(android.Manifest.permission.LOCAL_MAC_ADDRESS) getCaptivePortalServerUrl()1129 public String getCaptivePortalServerUrl() { 1130 try { 1131 return mService.getCaptivePortalServerUrl(); 1132 } catch (RemoteException e) { 1133 throw e.rethrowFromSystemServer(); 1134 } 1135 } 1136 1137 /** 1138 * Tells the underlying networking system that the caller wants to 1139 * begin using the named feature. The interpretation of {@code feature} 1140 * is completely up to each networking implementation. 1141 * 1142 * <p>This method requires the caller to hold either the 1143 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 1144 * or the ability to modify system settings as determined by 1145 * {@link android.provider.Settings.System#canWrite}.</p> 1146 * 1147 * @param networkType specifies which network the request pertains to 1148 * @param feature the name of the feature to be used 1149 * @return an integer value representing the outcome of the request. 1150 * The interpretation of this value is specific to each networking 1151 * implementation+feature combination, except that the value {@code -1} 1152 * always indicates failure. 1153 * 1154 * @deprecated Deprecated in favor of the cleaner 1155 * {@link #requestNetwork(NetworkRequest, NetworkCallback)} API. 1156 * In {@link VERSION_CODES#M}, and above, this method is unsupported and will 1157 * throw {@code UnsupportedOperationException} if called. 1158 * @removed 1159 */ 1160 @Deprecated startUsingNetworkFeature(int networkType, String feature)1161 public int startUsingNetworkFeature(int networkType, String feature) { 1162 checkLegacyRoutingApiAccess(); 1163 NetworkCapabilities netCap = networkCapabilitiesForFeature(networkType, feature); 1164 if (netCap == null) { 1165 Log.d(TAG, "Can't satisfy startUsingNetworkFeature for " + networkType + ", " + 1166 feature); 1167 return PhoneConstants.APN_REQUEST_FAILED; 1168 } 1169 1170 NetworkRequest request = null; 1171 synchronized (sLegacyRequests) { 1172 LegacyRequest l = sLegacyRequests.get(netCap); 1173 if (l != null) { 1174 Log.d(TAG, "renewing startUsingNetworkFeature request " + l.networkRequest); 1175 renewRequestLocked(l); 1176 if (l.currentNetwork != null) { 1177 return PhoneConstants.APN_ALREADY_ACTIVE; 1178 } else { 1179 return PhoneConstants.APN_REQUEST_STARTED; 1180 } 1181 } 1182 1183 request = requestNetworkForFeatureLocked(netCap); 1184 } 1185 if (request != null) { 1186 Log.d(TAG, "starting startUsingNetworkFeature for request " + request); 1187 return PhoneConstants.APN_REQUEST_STARTED; 1188 } else { 1189 Log.d(TAG, " request Failed"); 1190 return PhoneConstants.APN_REQUEST_FAILED; 1191 } 1192 } 1193 1194 /** 1195 * Tells the underlying networking system that the caller is finished 1196 * using the named feature. The interpretation of {@code feature} 1197 * is completely up to each networking implementation. 1198 * 1199 * <p>This method requires the caller to hold either the 1200 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 1201 * or the ability to modify system settings as determined by 1202 * {@link android.provider.Settings.System#canWrite}.</p> 1203 * 1204 * @param networkType specifies which network the request pertains to 1205 * @param feature the name of the feature that is no longer needed 1206 * @return an integer value representing the outcome of the request. 1207 * The interpretation of this value is specific to each networking 1208 * implementation+feature combination, except that the value {@code -1} 1209 * always indicates failure. 1210 * 1211 * @deprecated Deprecated in favor of the cleaner 1212 * {@link #unregisterNetworkCallback(NetworkCallback)} API. 1213 * In {@link VERSION_CODES#M}, and above, this method is unsupported and will 1214 * throw {@code UnsupportedOperationException} if called. 1215 * @removed 1216 */ 1217 @Deprecated stopUsingNetworkFeature(int networkType, String feature)1218 public int stopUsingNetworkFeature(int networkType, String feature) { 1219 checkLegacyRoutingApiAccess(); 1220 NetworkCapabilities netCap = networkCapabilitiesForFeature(networkType, feature); 1221 if (netCap == null) { 1222 Log.d(TAG, "Can't satisfy stopUsingNetworkFeature for " + networkType + ", " + 1223 feature); 1224 return -1; 1225 } 1226 1227 if (removeRequestForFeature(netCap)) { 1228 Log.d(TAG, "stopUsingNetworkFeature for " + networkType + ", " + feature); 1229 } 1230 return 1; 1231 } 1232 networkCapabilitiesForFeature(int networkType, String feature)1233 private NetworkCapabilities networkCapabilitiesForFeature(int networkType, String feature) { 1234 if (networkType == TYPE_MOBILE) { 1235 switch (feature) { 1236 case "enableCBS": 1237 return networkCapabilitiesForType(TYPE_MOBILE_CBS); 1238 case "enableDUN": 1239 case "enableDUNAlways": 1240 return networkCapabilitiesForType(TYPE_MOBILE_DUN); 1241 case "enableFOTA": 1242 return networkCapabilitiesForType(TYPE_MOBILE_FOTA); 1243 case "enableHIPRI": 1244 return networkCapabilitiesForType(TYPE_MOBILE_HIPRI); 1245 case "enableIMS": 1246 return networkCapabilitiesForType(TYPE_MOBILE_IMS); 1247 case "enableMMS": 1248 return networkCapabilitiesForType(TYPE_MOBILE_MMS); 1249 case "enableSUPL": 1250 return networkCapabilitiesForType(TYPE_MOBILE_SUPL); 1251 default: 1252 return null; 1253 } 1254 } else if (networkType == TYPE_WIFI && "p2p".equals(feature)) { 1255 return networkCapabilitiesForType(TYPE_WIFI_P2P); 1256 } 1257 return null; 1258 } 1259 1260 /** 1261 * Guess what the network request was trying to say so that the resulting 1262 * network is accessible via the legacy (deprecated) API such as 1263 * requestRouteToHost. 1264 * 1265 * This means we should try to be fairly precise about transport and 1266 * capability but ignore things such as networkSpecifier. 1267 * If the request has more than one transport or capability it doesn't 1268 * match the old legacy requests (they selected only single transport/capability) 1269 * so this function cannot map the request to a single legacy type and 1270 * the resulting network will not be available to the legacy APIs. 1271 * 1272 * This code is only called from the requestNetwork API (L and above). 1273 * 1274 * Setting a legacy type causes CONNECTIVITY_ACTION broadcasts, which are expensive 1275 * because they wake up lots of apps - see http://b/23350688 . So we currently only 1276 * do this for SUPL requests, which are the only ones that we know need it. If 1277 * omitting these broadcasts causes unacceptable app breakage, then for backwards 1278 * compatibility we can send them: 1279 * 1280 * if (targetSdkVersion < Build.VERSION_CODES.M) && // legacy API unsupported >= M 1281 * targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP)) // requestNetwork not present < L 1282 * 1283 * TODO - This should be removed when the legacy APIs are removed. 1284 */ inferLegacyTypeForNetworkCapabilities(NetworkCapabilities netCap)1285 private int inferLegacyTypeForNetworkCapabilities(NetworkCapabilities netCap) { 1286 if (netCap == null) { 1287 return TYPE_NONE; 1288 } 1289 1290 if (!netCap.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) { 1291 return TYPE_NONE; 1292 } 1293 1294 // Do this only for SUPL, until GnssLocationProvider is fixed. http://b/25876485 . 1295 if (!netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)) { 1296 // NOTE: if this causes app breakage, we should not just comment out this early return; 1297 // instead, we should make this early return conditional on the requesting app's target 1298 // SDK version, as described in the comment above. 1299 return TYPE_NONE; 1300 } 1301 1302 String type = null; 1303 int result = TYPE_NONE; 1304 1305 if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_CBS)) { 1306 type = "enableCBS"; 1307 result = TYPE_MOBILE_CBS; 1308 } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)) { 1309 type = "enableIMS"; 1310 result = TYPE_MOBILE_IMS; 1311 } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA)) { 1312 type = "enableFOTA"; 1313 result = TYPE_MOBILE_FOTA; 1314 } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)) { 1315 type = "enableDUN"; 1316 result = TYPE_MOBILE_DUN; 1317 } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)) { 1318 type = "enableSUPL"; 1319 result = TYPE_MOBILE_SUPL; 1320 // back out this hack for mms as they no longer need this and it's causing 1321 // device slowdowns - b/23350688 (note, supl still needs this) 1322 //} else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)) { 1323 // type = "enableMMS"; 1324 // result = TYPE_MOBILE_MMS; 1325 } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) { 1326 type = "enableHIPRI"; 1327 result = TYPE_MOBILE_HIPRI; 1328 } 1329 if (type != null) { 1330 NetworkCapabilities testCap = networkCapabilitiesForFeature(TYPE_MOBILE, type); 1331 if (testCap.equalsNetCapabilities(netCap) && testCap.equalsTransportTypes(netCap)) { 1332 return result; 1333 } 1334 } 1335 return TYPE_NONE; 1336 } 1337 legacyTypeForNetworkCapabilities(NetworkCapabilities netCap)1338 private int legacyTypeForNetworkCapabilities(NetworkCapabilities netCap) { 1339 if (netCap == null) return TYPE_NONE; 1340 if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_CBS)) { 1341 return TYPE_MOBILE_CBS; 1342 } 1343 if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)) { 1344 return TYPE_MOBILE_IMS; 1345 } 1346 if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA)) { 1347 return TYPE_MOBILE_FOTA; 1348 } 1349 if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)) { 1350 return TYPE_MOBILE_DUN; 1351 } 1352 if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)) { 1353 return TYPE_MOBILE_SUPL; 1354 } 1355 if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)) { 1356 return TYPE_MOBILE_MMS; 1357 } 1358 if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) { 1359 return TYPE_MOBILE_HIPRI; 1360 } 1361 if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_WIFI_P2P)) { 1362 return TYPE_WIFI_P2P; 1363 } 1364 return TYPE_NONE; 1365 } 1366 1367 private static class LegacyRequest { 1368 NetworkCapabilities networkCapabilities; 1369 NetworkRequest networkRequest; 1370 int expireSequenceNumber; 1371 Network currentNetwork; 1372 int delay = -1; 1373 clearDnsBinding()1374 private void clearDnsBinding() { 1375 if (currentNetwork != null) { 1376 currentNetwork = null; 1377 setProcessDefaultNetworkForHostResolution(null); 1378 } 1379 } 1380 1381 NetworkCallback networkCallback = new NetworkCallback() { 1382 @Override 1383 public void onAvailable(Network network) { 1384 currentNetwork = network; 1385 Log.d(TAG, "startUsingNetworkFeature got Network:" + network); 1386 setProcessDefaultNetworkForHostResolution(network); 1387 } 1388 @Override 1389 public void onLost(Network network) { 1390 if (network.equals(currentNetwork)) clearDnsBinding(); 1391 Log.d(TAG, "startUsingNetworkFeature lost Network:" + network); 1392 } 1393 }; 1394 } 1395 1396 private static HashMap<NetworkCapabilities, LegacyRequest> sLegacyRequests = 1397 new HashMap<NetworkCapabilities, LegacyRequest>(); 1398 findRequestForFeature(NetworkCapabilities netCap)1399 private NetworkRequest findRequestForFeature(NetworkCapabilities netCap) { 1400 synchronized (sLegacyRequests) { 1401 LegacyRequest l = sLegacyRequests.get(netCap); 1402 if (l != null) return l.networkRequest; 1403 } 1404 return null; 1405 } 1406 renewRequestLocked(LegacyRequest l)1407 private void renewRequestLocked(LegacyRequest l) { 1408 l.expireSequenceNumber++; 1409 Log.d(TAG, "renewing request to seqNum " + l.expireSequenceNumber); 1410 sendExpireMsgForFeature(l.networkCapabilities, l.expireSequenceNumber, l.delay); 1411 } 1412 expireRequest(NetworkCapabilities netCap, int sequenceNum)1413 private void expireRequest(NetworkCapabilities netCap, int sequenceNum) { 1414 int ourSeqNum = -1; 1415 synchronized (sLegacyRequests) { 1416 LegacyRequest l = sLegacyRequests.get(netCap); 1417 if (l == null) return; 1418 ourSeqNum = l.expireSequenceNumber; 1419 if (l.expireSequenceNumber == sequenceNum) removeRequestForFeature(netCap); 1420 } 1421 Log.d(TAG, "expireRequest with " + ourSeqNum + ", " + sequenceNum); 1422 } 1423 requestNetworkForFeatureLocked(NetworkCapabilities netCap)1424 private NetworkRequest requestNetworkForFeatureLocked(NetworkCapabilities netCap) { 1425 int delay = -1; 1426 int type = legacyTypeForNetworkCapabilities(netCap); 1427 try { 1428 delay = mService.getRestoreDefaultNetworkDelay(type); 1429 } catch (RemoteException e) { 1430 throw e.rethrowFromSystemServer(); 1431 } 1432 LegacyRequest l = new LegacyRequest(); 1433 l.networkCapabilities = netCap; 1434 l.delay = delay; 1435 l.expireSequenceNumber = 0; 1436 l.networkRequest = sendRequestForNetwork( 1437 netCap, l.networkCallback, 0, REQUEST, type, getDefaultHandler()); 1438 if (l.networkRequest == null) return null; 1439 sLegacyRequests.put(netCap, l); 1440 sendExpireMsgForFeature(netCap, l.expireSequenceNumber, delay); 1441 return l.networkRequest; 1442 } 1443 sendExpireMsgForFeature(NetworkCapabilities netCap, int seqNum, int delay)1444 private void sendExpireMsgForFeature(NetworkCapabilities netCap, int seqNum, int delay) { 1445 if (delay >= 0) { 1446 Log.d(TAG, "sending expire msg with seqNum " + seqNum + " and delay " + delay); 1447 CallbackHandler handler = getDefaultHandler(); 1448 Message msg = handler.obtainMessage(EXPIRE_LEGACY_REQUEST, seqNum, 0, netCap); 1449 handler.sendMessageDelayed(msg, delay); 1450 } 1451 } 1452 removeRequestForFeature(NetworkCapabilities netCap)1453 private boolean removeRequestForFeature(NetworkCapabilities netCap) { 1454 final LegacyRequest l; 1455 synchronized (sLegacyRequests) { 1456 l = sLegacyRequests.remove(netCap); 1457 } 1458 if (l == null) return false; 1459 unregisterNetworkCallback(l.networkCallback); 1460 l.clearDnsBinding(); 1461 return true; 1462 } 1463 1464 private static final SparseIntArray sLegacyTypeToTransport = new SparseIntArray(); 1465 static { sLegacyTypeToTransport.put(TYPE_MOBILE, NetworkCapabilities.TRANSPORT_CELLULAR)1466 sLegacyTypeToTransport.put(TYPE_MOBILE, NetworkCapabilities.TRANSPORT_CELLULAR); sLegacyTypeToTransport.put(TYPE_MOBILE_CBS, NetworkCapabilities.TRANSPORT_CELLULAR)1467 sLegacyTypeToTransport.put(TYPE_MOBILE_CBS, NetworkCapabilities.TRANSPORT_CELLULAR); sLegacyTypeToTransport.put(TYPE_MOBILE_DUN, NetworkCapabilities.TRANSPORT_CELLULAR)1468 sLegacyTypeToTransport.put(TYPE_MOBILE_DUN, NetworkCapabilities.TRANSPORT_CELLULAR); sLegacyTypeToTransport.put(TYPE_MOBILE_FOTA, NetworkCapabilities.TRANSPORT_CELLULAR)1469 sLegacyTypeToTransport.put(TYPE_MOBILE_FOTA, NetworkCapabilities.TRANSPORT_CELLULAR); sLegacyTypeToTransport.put(TYPE_MOBILE_HIPRI, NetworkCapabilities.TRANSPORT_CELLULAR)1470 sLegacyTypeToTransport.put(TYPE_MOBILE_HIPRI, NetworkCapabilities.TRANSPORT_CELLULAR); sLegacyTypeToTransport.put(TYPE_MOBILE_IMS, NetworkCapabilities.TRANSPORT_CELLULAR)1471 sLegacyTypeToTransport.put(TYPE_MOBILE_IMS, NetworkCapabilities.TRANSPORT_CELLULAR); sLegacyTypeToTransport.put(TYPE_MOBILE_MMS, NetworkCapabilities.TRANSPORT_CELLULAR)1472 sLegacyTypeToTransport.put(TYPE_MOBILE_MMS, NetworkCapabilities.TRANSPORT_CELLULAR); sLegacyTypeToTransport.put(TYPE_MOBILE_SUPL, NetworkCapabilities.TRANSPORT_CELLULAR)1473 sLegacyTypeToTransport.put(TYPE_MOBILE_SUPL, NetworkCapabilities.TRANSPORT_CELLULAR); sLegacyTypeToTransport.put(TYPE_WIFI, NetworkCapabilities.TRANSPORT_WIFI)1474 sLegacyTypeToTransport.put(TYPE_WIFI, NetworkCapabilities.TRANSPORT_WIFI); sLegacyTypeToTransport.put(TYPE_WIFI_P2P, NetworkCapabilities.TRANSPORT_WIFI)1475 sLegacyTypeToTransport.put(TYPE_WIFI_P2P, NetworkCapabilities.TRANSPORT_WIFI); sLegacyTypeToTransport.put(TYPE_BLUETOOTH, NetworkCapabilities.TRANSPORT_BLUETOOTH)1476 sLegacyTypeToTransport.put(TYPE_BLUETOOTH, NetworkCapabilities.TRANSPORT_BLUETOOTH); sLegacyTypeToTransport.put(TYPE_ETHERNET, NetworkCapabilities.TRANSPORT_ETHERNET)1477 sLegacyTypeToTransport.put(TYPE_ETHERNET, NetworkCapabilities.TRANSPORT_ETHERNET); 1478 } 1479 1480 private static final SparseIntArray sLegacyTypeToCapability = new SparseIntArray(); 1481 static { sLegacyTypeToCapability.put(TYPE_MOBILE_CBS, NetworkCapabilities.NET_CAPABILITY_CBS)1482 sLegacyTypeToCapability.put(TYPE_MOBILE_CBS, NetworkCapabilities.NET_CAPABILITY_CBS); sLegacyTypeToCapability.put(TYPE_MOBILE_DUN, NetworkCapabilities.NET_CAPABILITY_DUN)1483 sLegacyTypeToCapability.put(TYPE_MOBILE_DUN, NetworkCapabilities.NET_CAPABILITY_DUN); sLegacyTypeToCapability.put(TYPE_MOBILE_FOTA, NetworkCapabilities.NET_CAPABILITY_FOTA)1484 sLegacyTypeToCapability.put(TYPE_MOBILE_FOTA, NetworkCapabilities.NET_CAPABILITY_FOTA); sLegacyTypeToCapability.put(TYPE_MOBILE_IMS, NetworkCapabilities.NET_CAPABILITY_IMS)1485 sLegacyTypeToCapability.put(TYPE_MOBILE_IMS, NetworkCapabilities.NET_CAPABILITY_IMS); sLegacyTypeToCapability.put(TYPE_MOBILE_MMS, NetworkCapabilities.NET_CAPABILITY_MMS)1486 sLegacyTypeToCapability.put(TYPE_MOBILE_MMS, NetworkCapabilities.NET_CAPABILITY_MMS); sLegacyTypeToCapability.put(TYPE_MOBILE_SUPL, NetworkCapabilities.NET_CAPABILITY_SUPL)1487 sLegacyTypeToCapability.put(TYPE_MOBILE_SUPL, NetworkCapabilities.NET_CAPABILITY_SUPL); sLegacyTypeToCapability.put(TYPE_WIFI_P2P, NetworkCapabilities.NET_CAPABILITY_WIFI_P2P)1488 sLegacyTypeToCapability.put(TYPE_WIFI_P2P, NetworkCapabilities.NET_CAPABILITY_WIFI_P2P); 1489 } 1490 1491 /** 1492 * Given a legacy type (TYPE_WIFI, ...) returns a NetworkCapabilities 1493 * instance suitable for registering a request or callback. Throws an 1494 * IllegalArgumentException if no mapping from the legacy type to 1495 * NetworkCapabilities is known. 1496 * 1497 * @hide 1498 */ networkCapabilitiesForType(int type)1499 public static NetworkCapabilities networkCapabilitiesForType(int type) { 1500 final NetworkCapabilities nc = new NetworkCapabilities(); 1501 1502 // Map from type to transports. 1503 final int NOT_FOUND = -1; 1504 final int transport = sLegacyTypeToTransport.get(type, NOT_FOUND); 1505 Preconditions.checkArgument(transport != NOT_FOUND, "unknown legacy type: " + type); 1506 nc.addTransportType(transport); 1507 1508 // Map from type to capabilities. 1509 nc.addCapability(sLegacyTypeToCapability.get( 1510 type, NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1511 nc.maybeMarkCapabilitiesRestricted(); 1512 return nc; 1513 } 1514 1515 /** @hide */ 1516 public static class PacketKeepaliveCallback { 1517 /** The requested keepalive was successfully started. */ onStarted()1518 public void onStarted() {} 1519 /** The keepalive was successfully stopped. */ onStopped()1520 public void onStopped() {} 1521 /** An error occurred. */ onError(int error)1522 public void onError(int error) {} 1523 } 1524 1525 /** 1526 * Allows applications to request that the system periodically send specific packets on their 1527 * behalf, using hardware offload to save battery power. 1528 * 1529 * To request that the system send keepalives, call one of the methods that return a 1530 * {@link ConnectivityManager.PacketKeepalive} object, such as {@link #startNattKeepalive}, 1531 * passing in a non-null callback. If the callback is successfully started, the callback's 1532 * {@code onStarted} method will be called. If an error occurs, {@code onError} will be called, 1533 * specifying one of the {@code ERROR_*} constants in this class. 1534 * 1535 * To stop an existing keepalive, call {@link stop}. The system will call {@code onStopped} if 1536 * the operation was successfull or {@code onError} if an error occurred. 1537 * 1538 * @hide 1539 */ 1540 public class PacketKeepalive { 1541 1542 private static final String TAG = "PacketKeepalive"; 1543 1544 /** @hide */ 1545 public static final int SUCCESS = 0; 1546 1547 /** @hide */ 1548 public static final int NO_KEEPALIVE = -1; 1549 1550 /** @hide */ 1551 public static final int BINDER_DIED = -10; 1552 1553 /** The specified {@code Network} is not connected. */ 1554 public static final int ERROR_INVALID_NETWORK = -20; 1555 /** The specified IP addresses are invalid. For example, the specified source IP address is 1556 * not configured on the specified {@code Network}. */ 1557 public static final int ERROR_INVALID_IP_ADDRESS = -21; 1558 /** The requested port is invalid. */ 1559 public static final int ERROR_INVALID_PORT = -22; 1560 /** The packet length is invalid (e.g., too long). */ 1561 public static final int ERROR_INVALID_LENGTH = -23; 1562 /** The packet transmission interval is invalid (e.g., too short). */ 1563 public static final int ERROR_INVALID_INTERVAL = -24; 1564 1565 /** The hardware does not support this request. */ 1566 public static final int ERROR_HARDWARE_UNSUPPORTED = -30; 1567 /** The hardware returned an error. */ 1568 public static final int ERROR_HARDWARE_ERROR = -31; 1569 1570 public static final int NATT_PORT = 4500; 1571 1572 private final Network mNetwork; 1573 private final PacketKeepaliveCallback mCallback; 1574 private final Looper mLooper; 1575 private final Messenger mMessenger; 1576 1577 private volatile Integer mSlot; 1578 stopLooper()1579 void stopLooper() { 1580 mLooper.quit(); 1581 } 1582 stop()1583 public void stop() { 1584 try { 1585 mService.stopKeepalive(mNetwork, mSlot); 1586 } catch (RemoteException e) { 1587 Log.e(TAG, "Error stopping packet keepalive: ", e); 1588 stopLooper(); 1589 } 1590 } 1591 PacketKeepalive(Network network, PacketKeepaliveCallback callback)1592 private PacketKeepalive(Network network, PacketKeepaliveCallback callback) { 1593 Preconditions.checkNotNull(network, "network cannot be null"); 1594 Preconditions.checkNotNull(callback, "callback cannot be null"); 1595 mNetwork = network; 1596 mCallback = callback; 1597 HandlerThread thread = new HandlerThread(TAG); 1598 thread.start(); 1599 mLooper = thread.getLooper(); 1600 mMessenger = new Messenger(new Handler(mLooper) { 1601 @Override 1602 public void handleMessage(Message message) { 1603 switch (message.what) { 1604 case NetworkAgent.EVENT_PACKET_KEEPALIVE: 1605 int error = message.arg2; 1606 try { 1607 if (error == SUCCESS) { 1608 if (mSlot == null) { 1609 mSlot = message.arg1; 1610 mCallback.onStarted(); 1611 } else { 1612 mSlot = null; 1613 stopLooper(); 1614 mCallback.onStopped(); 1615 } 1616 } else { 1617 stopLooper(); 1618 mCallback.onError(error); 1619 } 1620 } catch (Exception e) { 1621 Log.e(TAG, "Exception in keepalive callback(" + error + ")", e); 1622 } 1623 break; 1624 default: 1625 Log.e(TAG, "Unhandled message " + Integer.toHexString(message.what)); 1626 break; 1627 } 1628 } 1629 }); 1630 } 1631 } 1632 1633 /** 1634 * Starts an IPsec NAT-T keepalive packet with the specified parameters. 1635 * 1636 * @hide 1637 */ startNattKeepalive( Network network, int intervalSeconds, PacketKeepaliveCallback callback, InetAddress srcAddr, int srcPort, InetAddress dstAddr)1638 public PacketKeepalive startNattKeepalive( 1639 Network network, int intervalSeconds, PacketKeepaliveCallback callback, 1640 InetAddress srcAddr, int srcPort, InetAddress dstAddr) { 1641 final PacketKeepalive k = new PacketKeepalive(network, callback); 1642 try { 1643 mService.startNattKeepalive(network, intervalSeconds, k.mMessenger, new Binder(), 1644 srcAddr.getHostAddress(), srcPort, dstAddr.getHostAddress()); 1645 } catch (RemoteException e) { 1646 Log.e(TAG, "Error starting packet keepalive: ", e); 1647 k.stopLooper(); 1648 return null; 1649 } 1650 return k; 1651 } 1652 1653 /** 1654 * Ensure that a network route exists to deliver traffic to the specified 1655 * host via the specified network interface. An attempt to add a route that 1656 * already exists is ignored, but treated as successful. 1657 * 1658 * <p>This method requires the caller to hold either the 1659 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 1660 * or the ability to modify system settings as determined by 1661 * {@link android.provider.Settings.System#canWrite}.</p> 1662 * 1663 * @param networkType the type of the network over which traffic to the specified 1664 * host is to be routed 1665 * @param hostAddress the IP address of the host to which the route is desired 1666 * @return {@code true} on success, {@code false} on failure 1667 * 1668 * @deprecated Deprecated in favor of the 1669 * {@link #requestNetwork(NetworkRequest, NetworkCallback)}, 1670 * {@link #bindProcessToNetwork} and {@link Network#getSocketFactory} API. 1671 * In {@link VERSION_CODES#M}, and above, this method is unsupported and will 1672 * throw {@code UnsupportedOperationException} if called. 1673 * @removed 1674 */ 1675 @Deprecated requestRouteToHost(int networkType, int hostAddress)1676 public boolean requestRouteToHost(int networkType, int hostAddress) { 1677 return requestRouteToHostAddress(networkType, NetworkUtils.intToInetAddress(hostAddress)); 1678 } 1679 1680 /** 1681 * Ensure that a network route exists to deliver traffic to the specified 1682 * host via the specified network interface. An attempt to add a route that 1683 * already exists is ignored, but treated as successful. 1684 * 1685 * <p>This method requires the caller to hold either the 1686 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 1687 * or the ability to modify system settings as determined by 1688 * {@link android.provider.Settings.System#canWrite}.</p> 1689 * 1690 * @param networkType the type of the network over which traffic to the specified 1691 * host is to be routed 1692 * @param hostAddress the IP address of the host to which the route is desired 1693 * @return {@code true} on success, {@code false} on failure 1694 * @hide 1695 * @deprecated Deprecated in favor of the {@link #requestNetwork} and 1696 * {@link #bindProcessToNetwork} API. 1697 */ 1698 @Deprecated requestRouteToHostAddress(int networkType, InetAddress hostAddress)1699 public boolean requestRouteToHostAddress(int networkType, InetAddress hostAddress) { 1700 checkLegacyRoutingApiAccess(); 1701 try { 1702 return mService.requestRouteToHostAddress(networkType, hostAddress.getAddress()); 1703 } catch (RemoteException e) { 1704 throw e.rethrowFromSystemServer(); 1705 } 1706 } 1707 1708 /** 1709 * Returns the value of the setting for background data usage. If false, 1710 * applications should not use the network if the application is not in the 1711 * foreground. Developers should respect this setting, and check the value 1712 * of this before performing any background data operations. 1713 * <p> 1714 * All applications that have background services that use the network 1715 * should listen to {@link #ACTION_BACKGROUND_DATA_SETTING_CHANGED}. 1716 * <p> 1717 * @deprecated As of {@link VERSION_CODES#ICE_CREAM_SANDWICH}, availability of 1718 * background data depends on several combined factors, and this method will 1719 * always return {@code true}. Instead, when background data is unavailable, 1720 * {@link #getActiveNetworkInfo()} will now appear disconnected. 1721 * 1722 * @return Whether background data usage is allowed. 1723 */ 1724 @Deprecated getBackgroundDataSetting()1725 public boolean getBackgroundDataSetting() { 1726 // assume that background data is allowed; final authority is 1727 // NetworkInfo which may be blocked. 1728 return true; 1729 } 1730 1731 /** 1732 * Sets the value of the setting for background data usage. 1733 * 1734 * @param allowBackgroundData Whether an application should use data while 1735 * it is in the background. 1736 * 1737 * @attr ref android.Manifest.permission#CHANGE_BACKGROUND_DATA_SETTING 1738 * @see #getBackgroundDataSetting() 1739 * @hide 1740 */ 1741 @Deprecated setBackgroundDataSetting(boolean allowBackgroundData)1742 public void setBackgroundDataSetting(boolean allowBackgroundData) { 1743 // ignored 1744 } 1745 1746 /** {@hide} */ 1747 @Deprecated getActiveNetworkQuotaInfo()1748 public NetworkQuotaInfo getActiveNetworkQuotaInfo() { 1749 try { 1750 return mService.getActiveNetworkQuotaInfo(); 1751 } catch (RemoteException e) { 1752 throw e.rethrowFromSystemServer(); 1753 } 1754 } 1755 1756 /** 1757 * @hide 1758 * @deprecated Talk to TelephonyManager directly 1759 */ 1760 @Deprecated getMobileDataEnabled()1761 public boolean getMobileDataEnabled() { 1762 IBinder b = ServiceManager.getService(Context.TELEPHONY_SERVICE); 1763 if (b != null) { 1764 try { 1765 ITelephony it = ITelephony.Stub.asInterface(b); 1766 int subId = SubscriptionManager.getDefaultDataSubscriptionId(); 1767 Log.d("ConnectivityManager", "getMobileDataEnabled()+ subId=" + subId); 1768 boolean retVal = it.getDataEnabled(subId); 1769 Log.d("ConnectivityManager", "getMobileDataEnabled()- subId=" + subId 1770 + " retVal=" + retVal); 1771 return retVal; 1772 } catch (RemoteException e) { 1773 throw e.rethrowFromSystemServer(); 1774 } 1775 } 1776 Log.d("ConnectivityManager", "getMobileDataEnabled()- remote exception retVal=false"); 1777 return false; 1778 } 1779 1780 /** 1781 * Callback for use with {@link ConnectivityManager#addDefaultNetworkActiveListener} 1782 * to find out when the system default network has gone in to a high power state. 1783 */ 1784 public interface OnNetworkActiveListener { 1785 /** 1786 * Called on the main thread of the process to report that the current data network 1787 * has become active, and it is now a good time to perform any pending network 1788 * operations. Note that this listener only tells you when the network becomes 1789 * active; if at any other time you want to know whether it is active (and thus okay 1790 * to initiate network traffic), you can retrieve its instantaneous state with 1791 * {@link ConnectivityManager#isDefaultNetworkActive}. 1792 */ onNetworkActive()1793 public void onNetworkActive(); 1794 } 1795 getNetworkManagementService()1796 private INetworkManagementService getNetworkManagementService() { 1797 synchronized (this) { 1798 if (mNMService != null) { 1799 return mNMService; 1800 } 1801 IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE); 1802 mNMService = INetworkManagementService.Stub.asInterface(b); 1803 return mNMService; 1804 } 1805 } 1806 1807 private final ArrayMap<OnNetworkActiveListener, INetworkActivityListener> 1808 mNetworkActivityListeners 1809 = new ArrayMap<OnNetworkActiveListener, INetworkActivityListener>(); 1810 1811 /** 1812 * Start listening to reports when the system's default data network is active, meaning it is 1813 * a good time to perform network traffic. Use {@link #isDefaultNetworkActive()} 1814 * to determine the current state of the system's default network after registering the 1815 * listener. 1816 * <p> 1817 * If the process default network has been set with 1818 * {@link ConnectivityManager#bindProcessToNetwork} this function will not 1819 * reflect the process's default, but the system default. 1820 * 1821 * @param l The listener to be told when the network is active. 1822 */ addDefaultNetworkActiveListener(final OnNetworkActiveListener l)1823 public void addDefaultNetworkActiveListener(final OnNetworkActiveListener l) { 1824 INetworkActivityListener rl = new INetworkActivityListener.Stub() { 1825 @Override 1826 public void onNetworkActive() throws RemoteException { 1827 l.onNetworkActive(); 1828 } 1829 }; 1830 1831 try { 1832 getNetworkManagementService().registerNetworkActivityListener(rl); 1833 mNetworkActivityListeners.put(l, rl); 1834 } catch (RemoteException e) { 1835 throw e.rethrowFromSystemServer(); 1836 } 1837 } 1838 1839 /** 1840 * Remove network active listener previously registered with 1841 * {@link #addDefaultNetworkActiveListener}. 1842 * 1843 * @param l Previously registered listener. 1844 */ removeDefaultNetworkActiveListener(OnNetworkActiveListener l)1845 public void removeDefaultNetworkActiveListener(OnNetworkActiveListener l) { 1846 INetworkActivityListener rl = mNetworkActivityListeners.get(l); 1847 Preconditions.checkArgument(rl != null, "Listener was not registered."); 1848 try { 1849 getNetworkManagementService().unregisterNetworkActivityListener(rl); 1850 } catch (RemoteException e) { 1851 throw e.rethrowFromSystemServer(); 1852 } 1853 } 1854 1855 /** 1856 * Return whether the data network is currently active. An active network means that 1857 * it is currently in a high power state for performing data transmission. On some 1858 * types of networks, it may be expensive to move and stay in such a state, so it is 1859 * more power efficient to batch network traffic together when the radio is already in 1860 * this state. This method tells you whether right now is currently a good time to 1861 * initiate network traffic, as the network is already active. 1862 */ isDefaultNetworkActive()1863 public boolean isDefaultNetworkActive() { 1864 try { 1865 return getNetworkManagementService().isNetworkActive(); 1866 } catch (RemoteException e) { 1867 throw e.rethrowFromSystemServer(); 1868 } 1869 } 1870 1871 /** 1872 * {@hide} 1873 */ ConnectivityManager(Context context, IConnectivityManager service)1874 public ConnectivityManager(Context context, IConnectivityManager service) { 1875 mContext = Preconditions.checkNotNull(context, "missing context"); 1876 mService = Preconditions.checkNotNull(service, "missing IConnectivityManager"); 1877 sInstance = this; 1878 } 1879 1880 /** {@hide} */ from(Context context)1881 public static ConnectivityManager from(Context context) { 1882 return (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); 1883 } 1884 1885 /* TODO: These permissions checks don't belong in client-side code. Move them to 1886 * services.jar, possibly in com.android.server.net. */ 1887 1888 /** {@hide} */ checkChangePermission(Context context)1889 public static final boolean checkChangePermission(Context context) { 1890 int uid = Binder.getCallingUid(); 1891 return Settings.checkAndNoteChangeNetworkStateOperation(context, uid, Settings 1892 .getPackageNameForUid(context, uid), false /* throwException */); 1893 } 1894 1895 /** {@hide} */ enforceChangePermission(Context context)1896 public static final void enforceChangePermission(Context context) { 1897 int uid = Binder.getCallingUid(); 1898 Settings.checkAndNoteChangeNetworkStateOperation(context, uid, Settings 1899 .getPackageNameForUid(context, uid), true /* throwException */); 1900 } 1901 1902 /** {@hide} */ enforceTetherChangePermission(Context context, String callingPkg)1903 public static final void enforceTetherChangePermission(Context context, String callingPkg) { 1904 Preconditions.checkNotNull(context, "Context cannot be null"); 1905 Preconditions.checkNotNull(callingPkg, "callingPkg cannot be null"); 1906 1907 if (context.getResources().getStringArray( 1908 com.android.internal.R.array.config_mobile_hotspot_provision_app).length == 2) { 1909 // Have a provisioning app - must only let system apps (which check this app) 1910 // turn on tethering 1911 context.enforceCallingOrSelfPermission( 1912 android.Manifest.permission.TETHER_PRIVILEGED, "ConnectivityService"); 1913 } else { 1914 int uid = Binder.getCallingUid(); 1915 // If callingPkg's uid is not same as Binder.getCallingUid(), 1916 // AppOpsService throws SecurityException. 1917 Settings.checkAndNoteWriteSettingsOperation(context, uid, callingPkg, 1918 true /* throwException */); 1919 } 1920 } 1921 1922 /** 1923 * @deprecated - use getSystemService. This is a kludge to support static access in certain 1924 * situations where a Context pointer is unavailable. 1925 * @hide 1926 */ 1927 @Deprecated getInstanceOrNull()1928 static ConnectivityManager getInstanceOrNull() { 1929 return sInstance; 1930 } 1931 1932 /** 1933 * @deprecated - use getSystemService. This is a kludge to support static access in certain 1934 * situations where a Context pointer is unavailable. 1935 * @hide 1936 */ 1937 @Deprecated getInstance()1938 private static ConnectivityManager getInstance() { 1939 if (getInstanceOrNull() == null) { 1940 throw new IllegalStateException("No ConnectivityManager yet constructed"); 1941 } 1942 return getInstanceOrNull(); 1943 } 1944 1945 /** 1946 * Get the set of tetherable, available interfaces. This list is limited by 1947 * device configuration and current interface existence. 1948 * 1949 * @return an array of 0 or more Strings of tetherable interface names. 1950 * 1951 * {@hide} 1952 */ 1953 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getTetherableIfaces()1954 public String[] getTetherableIfaces() { 1955 try { 1956 return mService.getTetherableIfaces(); 1957 } catch (RemoteException e) { 1958 throw e.rethrowFromSystemServer(); 1959 } 1960 } 1961 1962 /** 1963 * Get the set of tethered interfaces. 1964 * 1965 * @return an array of 0 or more String of currently tethered interface names. 1966 * 1967 * {@hide} 1968 */ 1969 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getTetheredIfaces()1970 public String[] getTetheredIfaces() { 1971 try { 1972 return mService.getTetheredIfaces(); 1973 } catch (RemoteException e) { 1974 throw e.rethrowFromSystemServer(); 1975 } 1976 } 1977 1978 /** 1979 * Get the set of interface names which attempted to tether but 1980 * failed. Re-attempting to tether may cause them to reset to the Tethered 1981 * state. Alternatively, causing the interface to be destroyed and recreated 1982 * may cause them to reset to the available state. 1983 * {@link ConnectivityManager#getLastTetherError} can be used to get more 1984 * information on the cause of the errors. 1985 * 1986 * @return an array of 0 or more String indicating the interface names 1987 * which failed to tether. 1988 * 1989 * {@hide} 1990 */ 1991 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getTetheringErroredIfaces()1992 public String[] getTetheringErroredIfaces() { 1993 try { 1994 return mService.getTetheringErroredIfaces(); 1995 } catch (RemoteException e) { 1996 throw e.rethrowFromSystemServer(); 1997 } 1998 } 1999 2000 /** 2001 * Get the set of tethered dhcp ranges. 2002 * 2003 * @return an array of 0 or more {@code String} of tethered dhcp ranges. 2004 * {@hide} 2005 */ getTetheredDhcpRanges()2006 public String[] getTetheredDhcpRanges() { 2007 try { 2008 return mService.getTetheredDhcpRanges(); 2009 } catch (RemoteException e) { 2010 throw e.rethrowFromSystemServer(); 2011 } 2012 } 2013 2014 /** 2015 * Attempt to tether the named interface. This will setup a dhcp server 2016 * on the interface, forward and NAT IP packets and forward DNS requests 2017 * to the best active upstream network interface. Note that if no upstream 2018 * IP network interface is available, dhcp will still run and traffic will be 2019 * allowed between the tethered devices and this device, though upstream net 2020 * access will of course fail until an upstream network interface becomes 2021 * active. 2022 * 2023 * <p>This method requires the caller to hold either the 2024 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 2025 * or the ability to modify system settings as determined by 2026 * {@link android.provider.Settings.System#canWrite}.</p> 2027 * 2028 * <p>WARNING: New clients should not use this function. The only usages should be in PanService 2029 * and WifiStateMachine which need direct access. All other clients should use 2030 * {@link #startTethering} and {@link #stopTethering} which encapsulate proper provisioning 2031 * logic.</p> 2032 * 2033 * @param iface the interface name to tether. 2034 * @return error a {@code TETHER_ERROR} value indicating success or failure type 2035 * 2036 * {@hide} 2037 */ tether(String iface)2038 public int tether(String iface) { 2039 try { 2040 String pkgName = mContext.getOpPackageName(); 2041 Log.i(TAG, "tether caller:" + pkgName); 2042 return mService.tether(iface, pkgName); 2043 } catch (RemoteException e) { 2044 throw e.rethrowFromSystemServer(); 2045 } 2046 } 2047 2048 /** 2049 * Stop tethering the named interface. 2050 * 2051 * <p>This method requires the caller to hold either the 2052 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 2053 * or the ability to modify system settings as determined by 2054 * {@link android.provider.Settings.System#canWrite}.</p> 2055 * 2056 * <p>WARNING: New clients should not use this function. The only usages should be in PanService 2057 * and WifiStateMachine which need direct access. All other clients should use 2058 * {@link #startTethering} and {@link #stopTethering} which encapsulate proper provisioning 2059 * logic.</p> 2060 * 2061 * @param iface the interface name to untether. 2062 * @return error a {@code TETHER_ERROR} value indicating success or failure type 2063 * 2064 * {@hide} 2065 */ untether(String iface)2066 public int untether(String iface) { 2067 try { 2068 String pkgName = mContext.getOpPackageName(); 2069 Log.i(TAG, "untether caller:" + pkgName); 2070 return mService.untether(iface, pkgName); 2071 } catch (RemoteException e) { 2072 throw e.rethrowFromSystemServer(); 2073 } 2074 } 2075 2076 /** 2077 * Check if the device allows for tethering. It may be disabled via 2078 * {@code ro.tether.denied} system property, Settings.TETHER_SUPPORTED or 2079 * due to device configuration. 2080 * 2081 * <p>If this app does not have permission to use this API, it will always 2082 * return false rather than throw an exception.</p> 2083 * 2084 * <p>If the device has a hotspot provisioning app, the caller is required to hold the 2085 * {@link android.Manifest.permission.TETHER_PRIVILEGED} permission.</p> 2086 * 2087 * <p>Otherwise, this method requires the caller to hold the ability to modify system 2088 * settings as determined by {@link android.provider.Settings.System#canWrite}.</p> 2089 * 2090 * @return a boolean - {@code true} indicating Tethering is supported. 2091 * 2092 * {@hide} 2093 */ 2094 @SystemApi 2095 @RequiresPermission(anyOf = {android.Manifest.permission.TETHER_PRIVILEGED, 2096 android.Manifest.permission.WRITE_SETTINGS}) isTetheringSupported()2097 public boolean isTetheringSupported() { 2098 String pkgName = mContext.getOpPackageName(); 2099 try { 2100 return mService.isTetheringSupported(pkgName); 2101 } catch (SecurityException e) { 2102 // This API is not available to this caller, but for backward-compatibility 2103 // this will just return false instead of throwing. 2104 return false; 2105 } catch (RemoteException e) { 2106 throw e.rethrowFromSystemServer(); 2107 } 2108 } 2109 2110 /** 2111 * Callback for use with {@link #startTethering} to find out whether tethering succeeded. 2112 * @hide 2113 */ 2114 @SystemApi 2115 public static abstract class OnStartTetheringCallback { 2116 /** 2117 * Called when tethering has been successfully started. 2118 */ onTetheringStarted()2119 public void onTetheringStarted() {}; 2120 2121 /** 2122 * Called when starting tethering failed. 2123 */ onTetheringFailed()2124 public void onTetheringFailed() {}; 2125 } 2126 2127 /** 2128 * Convenient overload for 2129 * {@link #startTethering(int, boolean, OnStartTetheringCallback, Handler)} which passes a null 2130 * handler to run on the current thread's {@link Looper}. 2131 * @hide 2132 */ 2133 @SystemApi 2134 @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) startTethering(int type, boolean showProvisioningUi, final OnStartTetheringCallback callback)2135 public void startTethering(int type, boolean showProvisioningUi, 2136 final OnStartTetheringCallback callback) { 2137 startTethering(type, showProvisioningUi, callback, null); 2138 } 2139 2140 /** 2141 * Runs tether provisioning for the given type if needed and then starts tethering if 2142 * the check succeeds. If no carrier provisioning is required for tethering, tethering is 2143 * enabled immediately. If provisioning fails, tethering will not be enabled. It also 2144 * schedules tether provisioning re-checks if appropriate. 2145 * 2146 * @param type The type of tethering to start. Must be one of 2147 * {@link ConnectivityManager.TETHERING_WIFI}, 2148 * {@link ConnectivityManager.TETHERING_USB}, or 2149 * {@link ConnectivityManager.TETHERING_BLUETOOTH}. 2150 * @param showProvisioningUi a boolean indicating to show the provisioning app UI if there 2151 * is one. This should be true the first time this function is called and also any time 2152 * the user can see this UI. It gives users information from their carrier about the 2153 * check failing and how they can sign up for tethering if possible. 2154 * @param callback an {@link OnStartTetheringCallback} which will be called to notify the caller 2155 * of the result of trying to tether. 2156 * @param handler {@link Handler} to specify the thread upon which the callback will be invoked. 2157 * @hide 2158 */ 2159 @SystemApi 2160 @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) startTethering(int type, boolean showProvisioningUi, final OnStartTetheringCallback callback, Handler handler)2161 public void startTethering(int type, boolean showProvisioningUi, 2162 final OnStartTetheringCallback callback, Handler handler) { 2163 Preconditions.checkNotNull(callback, "OnStartTetheringCallback cannot be null."); 2164 2165 ResultReceiver wrappedCallback = new ResultReceiver(handler) { 2166 @Override 2167 protected void onReceiveResult(int resultCode, Bundle resultData) { 2168 if (resultCode == TETHER_ERROR_NO_ERROR) { 2169 callback.onTetheringStarted(); 2170 } else { 2171 callback.onTetheringFailed(); 2172 } 2173 } 2174 }; 2175 2176 try { 2177 String pkgName = mContext.getOpPackageName(); 2178 Log.i(TAG, "startTethering caller:" + pkgName); 2179 mService.startTethering(type, wrappedCallback, showProvisioningUi, pkgName); 2180 } catch (RemoteException e) { 2181 Log.e(TAG, "Exception trying to start tethering.", e); 2182 wrappedCallback.send(TETHER_ERROR_SERVICE_UNAVAIL, null); 2183 } 2184 } 2185 2186 /** 2187 * Stops tethering for the given type. Also cancels any provisioning rechecks for that type if 2188 * applicable. 2189 * 2190 * @param type The type of tethering to stop. Must be one of 2191 * {@link ConnectivityManager.TETHERING_WIFI}, 2192 * {@link ConnectivityManager.TETHERING_USB}, or 2193 * {@link ConnectivityManager.TETHERING_BLUETOOTH}. 2194 * @hide 2195 */ 2196 @SystemApi 2197 @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) stopTethering(int type)2198 public void stopTethering(int type) { 2199 try { 2200 String pkgName = mContext.getOpPackageName(); 2201 Log.i(TAG, "stopTethering caller:" + pkgName); 2202 mService.stopTethering(type, pkgName); 2203 } catch (RemoteException e) { 2204 throw e.rethrowFromSystemServer(); 2205 } 2206 } 2207 2208 /** 2209 * Get the list of regular expressions that define any tetherable 2210 * USB network interfaces. If USB tethering is not supported by the 2211 * device, this list should be empty. 2212 * 2213 * @return an array of 0 or more regular expression Strings defining 2214 * what interfaces are considered tetherable usb interfaces. 2215 * 2216 * {@hide} 2217 */ 2218 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getTetherableUsbRegexs()2219 public String[] getTetherableUsbRegexs() { 2220 try { 2221 return mService.getTetherableUsbRegexs(); 2222 } catch (RemoteException e) { 2223 throw e.rethrowFromSystemServer(); 2224 } 2225 } 2226 2227 /** 2228 * Get the list of regular expressions that define any tetherable 2229 * Wifi network interfaces. If Wifi tethering is not supported by the 2230 * device, this list should be empty. 2231 * 2232 * @return an array of 0 or more regular expression Strings defining 2233 * what interfaces are considered tetherable wifi interfaces. 2234 * 2235 * {@hide} 2236 */ 2237 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getTetherableWifiRegexs()2238 public String[] getTetherableWifiRegexs() { 2239 try { 2240 return mService.getTetherableWifiRegexs(); 2241 } catch (RemoteException e) { 2242 throw e.rethrowFromSystemServer(); 2243 } 2244 } 2245 2246 /** 2247 * Get the list of regular expressions that define any tetherable 2248 * Bluetooth network interfaces. If Bluetooth tethering is not supported by the 2249 * device, this list should be empty. 2250 * 2251 * @return an array of 0 or more regular expression Strings defining 2252 * what interfaces are considered tetherable bluetooth interfaces. 2253 * 2254 * {@hide} 2255 */ 2256 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getTetherableBluetoothRegexs()2257 public String[] getTetherableBluetoothRegexs() { 2258 try { 2259 return mService.getTetherableBluetoothRegexs(); 2260 } catch (RemoteException e) { 2261 throw e.rethrowFromSystemServer(); 2262 } 2263 } 2264 2265 /** 2266 * Attempt to both alter the mode of USB and Tethering of USB. A 2267 * utility method to deal with some of the complexity of USB - will 2268 * attempt to switch to Rndis and subsequently tether the resulting 2269 * interface on {@code true} or turn off tethering and switch off 2270 * Rndis on {@code false}. 2271 * 2272 * <p>This method requires the caller to hold either the 2273 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 2274 * or the ability to modify system settings as determined by 2275 * {@link android.provider.Settings.System#canWrite}.</p> 2276 * 2277 * @param enable a boolean - {@code true} to enable tethering 2278 * @return error a {@code TETHER_ERROR} value indicating success or failure type 2279 * 2280 * {@hide} 2281 */ setUsbTethering(boolean enable)2282 public int setUsbTethering(boolean enable) { 2283 try { 2284 String pkgName = mContext.getOpPackageName(); 2285 Log.i(TAG, "setUsbTethering caller:" + pkgName); 2286 return mService.setUsbTethering(enable, pkgName); 2287 } catch (RemoteException e) { 2288 throw e.rethrowFromSystemServer(); 2289 } 2290 } 2291 2292 /** {@hide} */ 2293 public static final int TETHER_ERROR_NO_ERROR = 0; 2294 /** {@hide} */ 2295 public static final int TETHER_ERROR_UNKNOWN_IFACE = 1; 2296 /** {@hide} */ 2297 public static final int TETHER_ERROR_SERVICE_UNAVAIL = 2; 2298 /** {@hide} */ 2299 public static final int TETHER_ERROR_UNSUPPORTED = 3; 2300 /** {@hide} */ 2301 public static final int TETHER_ERROR_UNAVAIL_IFACE = 4; 2302 /** {@hide} */ 2303 public static final int TETHER_ERROR_MASTER_ERROR = 5; 2304 /** {@hide} */ 2305 public static final int TETHER_ERROR_TETHER_IFACE_ERROR = 6; 2306 /** {@hide} */ 2307 public static final int TETHER_ERROR_UNTETHER_IFACE_ERROR = 7; 2308 /** {@hide} */ 2309 public static final int TETHER_ERROR_ENABLE_NAT_ERROR = 8; 2310 /** {@hide} */ 2311 public static final int TETHER_ERROR_DISABLE_NAT_ERROR = 9; 2312 /** {@hide} */ 2313 public static final int TETHER_ERROR_IFACE_CFG_ERROR = 10; 2314 /** {@hide} */ 2315 public static final int TETHER_ERROR_PROVISION_FAILED = 11; 2316 2317 /** 2318 * Get a more detailed error code after a Tethering or Untethering 2319 * request asynchronously failed. 2320 * 2321 * @param iface The name of the interface of interest 2322 * @return error The error code of the last error tethering or untethering the named 2323 * interface 2324 * 2325 * {@hide} 2326 */ 2327 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getLastTetherError(String iface)2328 public int getLastTetherError(String iface) { 2329 try { 2330 return mService.getLastTetherError(iface); 2331 } catch (RemoteException e) { 2332 throw e.rethrowFromSystemServer(); 2333 } 2334 } 2335 2336 /** 2337 * Report network connectivity status. This is currently used only 2338 * to alter status bar UI. 2339 * <p>This method requires the caller to hold the permission 2340 * {@link android.Manifest.permission#STATUS_BAR}. 2341 * 2342 * @param networkType The type of network you want to report on 2343 * @param percentage The quality of the connection 0 is bad, 100 is good 2344 * {@hide} 2345 */ reportInetCondition(int networkType, int percentage)2346 public void reportInetCondition(int networkType, int percentage) { 2347 try { 2348 mService.reportInetCondition(networkType, percentage); 2349 } catch (RemoteException e) { 2350 throw e.rethrowFromSystemServer(); 2351 } 2352 } 2353 2354 /** 2355 * Report a problem network to the framework. This provides a hint to the system 2356 * that there might be connectivity problems on this network and may cause 2357 * the framework to re-evaluate network connectivity and/or switch to another 2358 * network. 2359 * 2360 * @param network The {@link Network} the application was attempting to use 2361 * or {@code null} to indicate the current default network. 2362 * @deprecated Use {@link #reportNetworkConnectivity} which allows reporting both 2363 * working and non-working connectivity. 2364 */ 2365 @Deprecated reportBadNetwork(Network network)2366 public void reportBadNetwork(Network network) { 2367 try { 2368 // One of these will be ignored because it matches system's current state. 2369 // The other will trigger the necessary reevaluation. 2370 mService.reportNetworkConnectivity(network, true); 2371 mService.reportNetworkConnectivity(network, false); 2372 } catch (RemoteException e) { 2373 throw e.rethrowFromSystemServer(); 2374 } 2375 } 2376 2377 /** 2378 * Report to the framework whether a network has working connectivity. 2379 * This provides a hint to the system that a particular network is providing 2380 * working connectivity or not. In response the framework may re-evaluate 2381 * the network's connectivity and might take further action thereafter. 2382 * 2383 * @param network The {@link Network} the application was attempting to use 2384 * or {@code null} to indicate the current default network. 2385 * @param hasConnectivity {@code true} if the application was able to successfully access the 2386 * Internet using {@code network} or {@code false} if not. 2387 */ reportNetworkConnectivity(Network network, boolean hasConnectivity)2388 public void reportNetworkConnectivity(Network network, boolean hasConnectivity) { 2389 try { 2390 mService.reportNetworkConnectivity(network, hasConnectivity); 2391 } catch (RemoteException e) { 2392 throw e.rethrowFromSystemServer(); 2393 } 2394 } 2395 2396 /** 2397 * Set a network-independent global http proxy. This is not normally what you want 2398 * for typical HTTP proxies - they are general network dependent. However if you're 2399 * doing something unusual like general internal filtering this may be useful. On 2400 * a private network where the proxy is not accessible, you may break HTTP using this. 2401 * 2402 * @param p A {@link ProxyInfo} object defining the new global 2403 * HTTP proxy. A {@code null} value will clear the global HTTP proxy. 2404 * @hide 2405 */ 2406 @RequiresPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL) setGlobalProxy(ProxyInfo p)2407 public void setGlobalProxy(ProxyInfo p) { 2408 try { 2409 mService.setGlobalProxy(p); 2410 } catch (RemoteException e) { 2411 throw e.rethrowFromSystemServer(); 2412 } 2413 } 2414 2415 /** 2416 * Retrieve any network-independent global HTTP proxy. 2417 * 2418 * @return {@link ProxyInfo} for the current global HTTP proxy or {@code null} 2419 * if no global HTTP proxy is set. 2420 * @hide 2421 */ getGlobalProxy()2422 public ProxyInfo getGlobalProxy() { 2423 try { 2424 return mService.getGlobalProxy(); 2425 } catch (RemoteException e) { 2426 throw e.rethrowFromSystemServer(); 2427 } 2428 } 2429 2430 /** 2431 * Retrieve the global HTTP proxy, or if no global HTTP proxy is set, a 2432 * network-specific HTTP proxy. If {@code network} is null, the 2433 * network-specific proxy returned is the proxy of the default active 2434 * network. 2435 * 2436 * @return {@link ProxyInfo} for the current global HTTP proxy, or if no 2437 * global HTTP proxy is set, {@code ProxyInfo} for {@code network}, 2438 * or when {@code network} is {@code null}, 2439 * the {@code ProxyInfo} for the default active network. Returns 2440 * {@code null} when no proxy applies or the caller doesn't have 2441 * permission to use {@code network}. 2442 * @hide 2443 */ getProxyForNetwork(Network network)2444 public ProxyInfo getProxyForNetwork(Network network) { 2445 try { 2446 return mService.getProxyForNetwork(network); 2447 } catch (RemoteException e) { 2448 throw e.rethrowFromSystemServer(); 2449 } 2450 } 2451 2452 /** 2453 * Get the current default HTTP proxy settings. If a global proxy is set it will be returned, 2454 * otherwise if this process is bound to a {@link Network} using 2455 * {@link #bindProcessToNetwork} then that {@code Network}'s proxy is returned, otherwise 2456 * the default network's proxy is returned. 2457 * 2458 * @return the {@link ProxyInfo} for the current HTTP proxy, or {@code null} if no 2459 * HTTP proxy is active. 2460 */ getDefaultProxy()2461 public ProxyInfo getDefaultProxy() { 2462 return getProxyForNetwork(getBoundNetworkForProcess()); 2463 } 2464 2465 /** 2466 * Returns true if the hardware supports the given network type 2467 * else it returns false. This doesn't indicate we have coverage 2468 * or are authorized onto a network, just whether or not the 2469 * hardware supports it. For example a GSM phone without a SIM 2470 * should still return {@code true} for mobile data, but a wifi only 2471 * tablet would return {@code false}. 2472 * 2473 * @param networkType The network type we'd like to check 2474 * @return {@code true} if supported, else {@code false} 2475 * 2476 * @hide 2477 */ 2478 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) isNetworkSupported(int networkType)2479 public boolean isNetworkSupported(int networkType) { 2480 try { 2481 return mService.isNetworkSupported(networkType); 2482 } catch (RemoteException e) { 2483 throw e.rethrowFromSystemServer(); 2484 } 2485 } 2486 2487 /** 2488 * Returns if the currently active data network is metered. A network is 2489 * classified as metered when the user is sensitive to heavy data usage on 2490 * that connection due to monetary costs, data limitations or 2491 * battery/performance issues. You should check this before doing large 2492 * data transfers, and warn the user or delay the operation until another 2493 * network is available. 2494 * 2495 * @return {@code true} if large transfers should be avoided, otherwise 2496 * {@code false}. 2497 */ 2498 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) isActiveNetworkMetered()2499 public boolean isActiveNetworkMetered() { 2500 try { 2501 return mService.isActiveNetworkMetered(); 2502 } catch (RemoteException e) { 2503 throw e.rethrowFromSystemServer(); 2504 } 2505 } 2506 2507 /** 2508 * Returns if the active data network for the given UID is metered. A network 2509 * is classified as metered when the user is sensitive to heavy data usage on 2510 * that connection due to monetary costs, data limitations or 2511 * battery/performance issues. You should check this before doing large 2512 * data transfers, and warn the user or delay the operation until another 2513 * network is available. 2514 * 2515 * @return {@code true} if large transfers should be avoided, otherwise 2516 * {@code false}. 2517 * 2518 * @hide 2519 */ 2520 @RequiresPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL) isActiveNetworkMeteredForUid(int uid)2521 public boolean isActiveNetworkMeteredForUid(int uid) { 2522 try { 2523 return mService.isActiveNetworkMeteredForUid(uid); 2524 } catch (RemoteException e) { 2525 throw e.rethrowFromSystemServer(); 2526 } 2527 } 2528 2529 /** 2530 * If the LockdownVpn mechanism is enabled, updates the vpn 2531 * with a reload of its profile. 2532 * 2533 * @return a boolean with {@code} indicating success 2534 * 2535 * <p>This method can only be called by the system UID 2536 * {@hide} 2537 */ updateLockdownVpn()2538 public boolean updateLockdownVpn() { 2539 try { 2540 return mService.updateLockdownVpn(); 2541 } catch (RemoteException e) { 2542 throw e.rethrowFromSystemServer(); 2543 } 2544 } 2545 2546 /** 2547 * Check mobile provisioning. 2548 * 2549 * @param suggestedTimeOutMs, timeout in milliseconds 2550 * 2551 * @return time out that will be used, maybe less that suggestedTimeOutMs 2552 * -1 if an error. 2553 * 2554 * {@hide} 2555 */ checkMobileProvisioning(int suggestedTimeOutMs)2556 public int checkMobileProvisioning(int suggestedTimeOutMs) { 2557 int timeOutMs = -1; 2558 try { 2559 timeOutMs = mService.checkMobileProvisioning(suggestedTimeOutMs); 2560 } catch (RemoteException e) { 2561 throw e.rethrowFromSystemServer(); 2562 } 2563 return timeOutMs; 2564 } 2565 2566 /** 2567 * Get the mobile provisioning url. 2568 * {@hide} 2569 */ getMobileProvisioningUrl()2570 public String getMobileProvisioningUrl() { 2571 try { 2572 return mService.getMobileProvisioningUrl(); 2573 } catch (RemoteException e) { 2574 throw e.rethrowFromSystemServer(); 2575 } 2576 } 2577 2578 /** 2579 * Set sign in error notification to visible or in visible 2580 * 2581 * @param visible 2582 * @param networkType 2583 * 2584 * {@hide} 2585 * @deprecated Doesn't properly deal with multiple connected networks of the same type. 2586 */ 2587 @Deprecated setProvisioningNotificationVisible(boolean visible, int networkType, String action)2588 public void setProvisioningNotificationVisible(boolean visible, int networkType, 2589 String action) { 2590 try { 2591 mService.setProvisioningNotificationVisible(visible, networkType, action); 2592 } catch (RemoteException e) { 2593 throw e.rethrowFromSystemServer(); 2594 } 2595 } 2596 2597 /** 2598 * Set the value for enabling/disabling airplane mode 2599 * 2600 * @param enable whether to enable airplane mode or not 2601 * 2602 * @hide 2603 */ 2604 @RequiresPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL) setAirplaneMode(boolean enable)2605 public void setAirplaneMode(boolean enable) { 2606 try { 2607 mService.setAirplaneMode(enable); 2608 } catch (RemoteException e) { 2609 throw e.rethrowFromSystemServer(); 2610 } 2611 } 2612 2613 /** {@hide} */ registerNetworkFactory(Messenger messenger, String name)2614 public void registerNetworkFactory(Messenger messenger, String name) { 2615 try { 2616 mService.registerNetworkFactory(messenger, name); 2617 } catch (RemoteException e) { 2618 throw e.rethrowFromSystemServer(); 2619 } 2620 } 2621 2622 /** {@hide} */ unregisterNetworkFactory(Messenger messenger)2623 public void unregisterNetworkFactory(Messenger messenger) { 2624 try { 2625 mService.unregisterNetworkFactory(messenger); 2626 } catch (RemoteException e) { 2627 throw e.rethrowFromSystemServer(); 2628 } 2629 } 2630 2631 /** 2632 * @hide 2633 * Register a NetworkAgent with ConnectivityService. 2634 * @return NetID corresponding to NetworkAgent. 2635 */ registerNetworkAgent(Messenger messenger, NetworkInfo ni, LinkProperties lp, NetworkCapabilities nc, int score, NetworkMisc misc)2636 public int registerNetworkAgent(Messenger messenger, NetworkInfo ni, LinkProperties lp, 2637 NetworkCapabilities nc, int score, NetworkMisc misc) { 2638 try { 2639 return mService.registerNetworkAgent(messenger, ni, lp, nc, score, misc); 2640 } catch (RemoteException e) { 2641 throw e.rethrowFromSystemServer(); 2642 } 2643 } 2644 2645 /** 2646 * Base class for {@code NetworkRequest} callbacks. Used for notifications about network 2647 * changes. Should be extended by applications wanting notifications. 2648 * 2649 * A {@code NetworkCallback} is registered by calling 2650 * {@link #requestNetwork(NetworkRequest, NetworkCallback)}, 2651 * {@link #registerNetworkCallback(NetworkRequest, NetworkCallback)}, 2652 * or {@link #registerDefaultNetworkCallback(NetworkCallback). A {@code NetworkCallback} is 2653 * unregistered by calling {@link #unregisterNetworkCallback(NetworkCallback)}. 2654 * A {@code NetworkCallback} should be registered at most once at any time. 2655 * A {@code NetworkCallback} that has been unregistered can be registered again. 2656 */ 2657 public static class NetworkCallback { 2658 /** 2659 * Called when the framework connects to a new network to evaluate whether it satisfies this 2660 * request. If evaluation succeeds, this callback may be followed by an {@link #onAvailable} 2661 * callback. There is no guarantee that this new network will satisfy any requests, or that 2662 * the network will stay connected for longer than the time necessary to evaluate it. 2663 * <p> 2664 * Most applications <b>should not</b> act on this callback, and should instead use 2665 * {@link #onAvailable}. This callback is intended for use by applications that can assist 2666 * the framework in properly evaluating the network — for example, an application that 2667 * can automatically log in to a captive portal without user intervention. 2668 * 2669 * @param network The {@link Network} of the network that is being evaluated. 2670 * 2671 * @hide 2672 */ onPreCheck(Network network)2673 public void onPreCheck(Network network) {} 2674 2675 /** 2676 * Called when the framework connects and has declared a new network ready for use. 2677 * This callback may be called more than once if the {@link Network} that is 2678 * satisfying the request changes. 2679 * 2680 * @param network The {@link Network} of the satisfying network. 2681 */ onAvailable(Network network)2682 public void onAvailable(Network network) {} 2683 2684 /** 2685 * Called when the network is about to be disconnected. Often paired with an 2686 * {@link NetworkCallback#onAvailable} call with the new replacement network 2687 * for graceful handover. This may not be called if we have a hard loss 2688 * (loss without warning). This may be followed by either a 2689 * {@link NetworkCallback#onLost} call or a 2690 * {@link NetworkCallback#onAvailable} call for this network depending 2691 * on whether we lose or regain it. 2692 * 2693 * @param network The {@link Network} that is about to be disconnected. 2694 * @param maxMsToLive The time in ms the framework will attempt to keep the 2695 * network connected. Note that the network may suffer a 2696 * hard loss at any time. 2697 */ onLosing(Network network, int maxMsToLive)2698 public void onLosing(Network network, int maxMsToLive) {} 2699 2700 /** 2701 * Called when the framework has a hard loss of the network or when the 2702 * graceful failure ends. 2703 * 2704 * @param network The {@link Network} lost. 2705 */ onLost(Network network)2706 public void onLost(Network network) {} 2707 2708 /** 2709 * Called if no network is found in the timeout time specified in 2710 * {@link #requestNetwork(NetworkRequest, NetworkCallback, int)} call. This callback is not 2711 * called for the version of {@link #requestNetwork(NetworkRequest, NetworkCallback)} 2712 * without timeout. When this callback is invoked the associated 2713 * {@link NetworkRequest} will have already been removed and released, as if 2714 * {@link #unregisterNetworkCallback(NetworkCallback)} had been called. 2715 */ onUnavailable()2716 public void onUnavailable() {} 2717 2718 /** 2719 * Called when the network the framework connected to for this request 2720 * changes capabilities but still satisfies the stated need. 2721 * 2722 * @param network The {@link Network} whose capabilities have changed. 2723 * @param networkCapabilities The new {@link android.net.NetworkCapabilities} for this network. 2724 */ onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities)2725 public void onCapabilitiesChanged(Network network, 2726 NetworkCapabilities networkCapabilities) {} 2727 2728 /** 2729 * Called when the network the framework connected to for this request 2730 * changes {@link LinkProperties}. 2731 * 2732 * @param network The {@link Network} whose link properties have changed. 2733 * @param linkProperties The new {@link LinkProperties} for this network. 2734 */ onLinkPropertiesChanged(Network network, LinkProperties linkProperties)2735 public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {} 2736 2737 /** 2738 * Called when the network the framework connected to for this request 2739 * goes into {@link NetworkInfo.DetailedState.SUSPENDED}. 2740 * This generally means that while the TCP connections are still live, 2741 * temporarily network data fails to transfer. Specifically this is used 2742 * on cellular networks to mask temporary outages when driving through 2743 * a tunnel, etc. 2744 * @hide 2745 */ onNetworkSuspended(Network network)2746 public void onNetworkSuspended(Network network) {} 2747 2748 /** 2749 * Called when the network the framework connected to for this request 2750 * returns from a {@link NetworkInfo.DetailedState.SUSPENDED} state. 2751 * This should always be preceeded by a matching {@code onNetworkSuspended} 2752 * call. 2753 * @hide 2754 */ onNetworkResumed(Network network)2755 public void onNetworkResumed(Network network) {} 2756 2757 private NetworkRequest networkRequest; 2758 } 2759 2760 /** 2761 * Constant error codes used by ConnectivityService to communicate about failures and errors 2762 * across a Binder boundary. 2763 * @hide 2764 */ 2765 public interface Errors { 2766 static int TOO_MANY_REQUESTS = 1; 2767 } 2768 2769 /** @hide */ 2770 public static class TooManyRequestsException extends RuntimeException {} 2771 convertServiceException(ServiceSpecificException e)2772 private static RuntimeException convertServiceException(ServiceSpecificException e) { 2773 switch (e.errorCode) { 2774 case Errors.TOO_MANY_REQUESTS: 2775 return new TooManyRequestsException(); 2776 default: 2777 Log.w(TAG, "Unknown service error code " + e.errorCode); 2778 return new RuntimeException(e); 2779 } 2780 } 2781 2782 private static final int BASE = Protocol.BASE_CONNECTIVITY_MANAGER; 2783 /** @hide */ 2784 public static final int CALLBACK_PRECHECK = BASE + 1; 2785 /** @hide */ 2786 public static final int CALLBACK_AVAILABLE = BASE + 2; 2787 /** @hide arg1 = TTL */ 2788 public static final int CALLBACK_LOSING = BASE + 3; 2789 /** @hide */ 2790 public static final int CALLBACK_LOST = BASE + 4; 2791 /** @hide */ 2792 public static final int CALLBACK_UNAVAIL = BASE + 5; 2793 /** @hide */ 2794 public static final int CALLBACK_CAP_CHANGED = BASE + 6; 2795 /** @hide */ 2796 public static final int CALLBACK_IP_CHANGED = BASE + 7; 2797 /** @hide obj = NetworkCapabilities, arg1 = seq number */ 2798 private static final int EXPIRE_LEGACY_REQUEST = BASE + 8; 2799 /** @hide */ 2800 public static final int CALLBACK_SUSPENDED = BASE + 9; 2801 /** @hide */ 2802 public static final int CALLBACK_RESUMED = BASE + 10; 2803 2804 /** @hide */ getCallbackName(int whichCallback)2805 public static String getCallbackName(int whichCallback) { 2806 switch (whichCallback) { 2807 case CALLBACK_PRECHECK: return "CALLBACK_PRECHECK"; 2808 case CALLBACK_AVAILABLE: return "CALLBACK_AVAILABLE"; 2809 case CALLBACK_LOSING: return "CALLBACK_LOSING"; 2810 case CALLBACK_LOST: return "CALLBACK_LOST"; 2811 case CALLBACK_UNAVAIL: return "CALLBACK_UNAVAIL"; 2812 case CALLBACK_CAP_CHANGED: return "CALLBACK_CAP_CHANGED"; 2813 case CALLBACK_IP_CHANGED: return "CALLBACK_IP_CHANGED"; 2814 case EXPIRE_LEGACY_REQUEST: return "EXPIRE_LEGACY_REQUEST"; 2815 case CALLBACK_SUSPENDED: return "CALLBACK_SUSPENDED"; 2816 case CALLBACK_RESUMED: return "CALLBACK_RESUMED"; 2817 default: 2818 return Integer.toString(whichCallback); 2819 } 2820 } 2821 2822 private class CallbackHandler extends Handler { 2823 private static final String TAG = "ConnectivityManager.CallbackHandler"; 2824 private static final boolean DBG = false; 2825 CallbackHandler(Looper looper)2826 CallbackHandler(Looper looper) { 2827 super(looper); 2828 } 2829 CallbackHandler(Handler handler)2830 CallbackHandler(Handler handler) { 2831 this(Preconditions.checkNotNull(handler, "Handler cannot be null.").getLooper()); 2832 } 2833 2834 @Override handleMessage(Message message)2835 public void handleMessage(Message message) { 2836 if (message.what == EXPIRE_LEGACY_REQUEST) { 2837 expireRequest((NetworkCapabilities) message.obj, message.arg1); 2838 return; 2839 } 2840 2841 final NetworkRequest request = getObject(message, NetworkRequest.class); 2842 final Network network = getObject(message, Network.class); 2843 final NetworkCallback callback; 2844 synchronized (sCallbacks) { 2845 callback = sCallbacks.get(request); 2846 } 2847 if (DBG) { 2848 Log.d(TAG, getCallbackName(message.what) + " for network " + network); 2849 } 2850 if (callback == null) { 2851 Log.w(TAG, "callback not found for " + getCallbackName(message.what) + " message"); 2852 return; 2853 } 2854 2855 switch (message.what) { 2856 case CALLBACK_PRECHECK: { 2857 callback.onPreCheck(network); 2858 break; 2859 } 2860 case CALLBACK_AVAILABLE: { 2861 callback.onAvailable(network); 2862 break; 2863 } 2864 case CALLBACK_LOSING: { 2865 callback.onLosing(network, message.arg1); 2866 break; 2867 } 2868 case CALLBACK_LOST: { 2869 callback.onLost(network); 2870 break; 2871 } 2872 case CALLBACK_UNAVAIL: { 2873 callback.onUnavailable(); 2874 break; 2875 } 2876 case CALLBACK_CAP_CHANGED: { 2877 NetworkCapabilities cap = getObject(message, NetworkCapabilities.class); 2878 callback.onCapabilitiesChanged(network, cap); 2879 break; 2880 } 2881 case CALLBACK_IP_CHANGED: { 2882 LinkProperties lp = getObject(message, LinkProperties.class); 2883 callback.onLinkPropertiesChanged(network, lp); 2884 break; 2885 } 2886 case CALLBACK_SUSPENDED: { 2887 callback.onNetworkSuspended(network); 2888 break; 2889 } 2890 case CALLBACK_RESUMED: { 2891 callback.onNetworkResumed(network); 2892 break; 2893 } 2894 } 2895 } 2896 getObject(Message msg, Class<T> c)2897 private <T> T getObject(Message msg, Class<T> c) { 2898 return (T) msg.getData().getParcelable(c.getSimpleName()); 2899 } 2900 } 2901 getDefaultHandler()2902 private CallbackHandler getDefaultHandler() { 2903 synchronized (sCallbacks) { 2904 if (sCallbackHandler == null) { 2905 sCallbackHandler = new CallbackHandler(ConnectivityThread.getInstanceLooper()); 2906 } 2907 return sCallbackHandler; 2908 } 2909 } 2910 2911 private static final HashMap<NetworkRequest, NetworkCallback> sCallbacks = new HashMap<>(); 2912 private static CallbackHandler sCallbackHandler; 2913 2914 private static final int LISTEN = 1; 2915 private static final int REQUEST = 2; 2916 sendRequestForNetwork(NetworkCapabilities need, NetworkCallback callback, int timeoutMs, int action, int legacyType, CallbackHandler handler)2917 private NetworkRequest sendRequestForNetwork(NetworkCapabilities need, NetworkCallback callback, 2918 int timeoutMs, int action, int legacyType, CallbackHandler handler) { 2919 checkCallbackNotNull(callback); 2920 Preconditions.checkArgument(action == REQUEST || need != null, "null NetworkCapabilities"); 2921 final NetworkRequest request; 2922 try { 2923 synchronized(sCallbacks) { 2924 if (callback.networkRequest != null 2925 && callback.networkRequest != ALREADY_UNREGISTERED) { 2926 // TODO: throw exception instead and enforce 1:1 mapping of callbacks 2927 // and requests (http://b/20701525). 2928 Log.e(TAG, "NetworkCallback was already registered"); 2929 } 2930 Messenger messenger = new Messenger(handler); 2931 Binder binder = new Binder(); 2932 if (action == LISTEN) { 2933 request = mService.listenForNetwork(need, messenger, binder); 2934 } else { 2935 request = mService.requestNetwork( 2936 need, messenger, timeoutMs, binder, legacyType); 2937 } 2938 if (request != null) { 2939 sCallbacks.put(request, callback); 2940 } 2941 callback.networkRequest = request; 2942 } 2943 } catch (RemoteException e) { 2944 throw e.rethrowFromSystemServer(); 2945 } catch (ServiceSpecificException e) { 2946 throw convertServiceException(e); 2947 } 2948 return request; 2949 } 2950 2951 /** 2952 * Helper function to request a network with a particular legacy type. 2953 * 2954 * This is temporarily public @hide so it can be called by system code that uses the 2955 * NetworkRequest API to request networks but relies on CONNECTIVITY_ACTION broadcasts for 2956 * instead network notifications. 2957 * 2958 * TODO: update said system code to rely on NetworkCallbacks and make this method private. 2959 * 2960 * @hide 2961 */ requestNetwork(NetworkRequest request, NetworkCallback networkCallback, int timeoutMs, int legacyType, Handler handler)2962 public void requestNetwork(NetworkRequest request, NetworkCallback networkCallback, 2963 int timeoutMs, int legacyType, Handler handler) { 2964 CallbackHandler cbHandler = new CallbackHandler(handler); 2965 NetworkCapabilities nc = request.networkCapabilities; 2966 sendRequestForNetwork(nc, networkCallback, timeoutMs, REQUEST, legacyType, cbHandler); 2967 } 2968 2969 /** 2970 * Request a network to satisfy a set of {@link android.net.NetworkCapabilities}. 2971 * 2972 * This {@link NetworkRequest} will live until released via 2973 * {@link #unregisterNetworkCallback(NetworkCallback)} or the calling application exits. A 2974 * version of the method which takes a timeout is 2975 * {@link #requestNetwork(NetworkRequest, NetworkCallback, int)}. 2976 * Status of the request can be followed by listening to the various 2977 * callbacks described in {@link NetworkCallback}. The {@link Network} 2978 * can be used to direct traffic to the network. 2979 * <p>It is presently unsupported to request a network with mutable 2980 * {@link NetworkCapabilities} such as 2981 * {@link NetworkCapabilities#NET_CAPABILITY_VALIDATED} or 2982 * {@link NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL} 2983 * as these {@code NetworkCapabilities} represent states that a particular 2984 * network may never attain, and whether a network will attain these states 2985 * is unknown prior to bringing up the network so the framework does not 2986 * know how to go about satisfing a request with these capabilities. 2987 * 2988 * <p>This method requires the caller to hold either the 2989 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 2990 * or the ability to modify system settings as determined by 2991 * {@link android.provider.Settings.System#canWrite}.</p> 2992 * 2993 * @param request {@link NetworkRequest} describing this request. 2994 * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note 2995 * the callback must not be shared - it uniquely specifies this request. 2996 * The callback is invoked on the default internal Handler. 2997 * @throws IllegalArgumentException if {@code request} specifies any mutable 2998 * {@code NetworkCapabilities}. 2999 */ requestNetwork(NetworkRequest request, NetworkCallback networkCallback)3000 public void requestNetwork(NetworkRequest request, NetworkCallback networkCallback) { 3001 requestNetwork(request, networkCallback, getDefaultHandler()); 3002 } 3003 3004 /** 3005 * Request a network to satisfy a set of {@link android.net.NetworkCapabilities}. 3006 * 3007 * This {@link NetworkRequest} will live until released via 3008 * {@link #unregisterNetworkCallback(NetworkCallback)} or the calling application exits. A 3009 * version of the method which takes a timeout is 3010 * {@link #requestNetwork(NetworkRequest, NetworkCallback, int)}. 3011 * Status of the request can be followed by listening to the various 3012 * callbacks described in {@link NetworkCallback}. The {@link Network} 3013 * can be used to direct traffic to the network. 3014 * <p>It is presently unsupported to request a network with mutable 3015 * {@link NetworkCapabilities} such as 3016 * {@link NetworkCapabilities#NET_CAPABILITY_VALIDATED} or 3017 * {@link NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL} 3018 * as these {@code NetworkCapabilities} represent states that a particular 3019 * network may never attain, and whether a network will attain these states 3020 * is unknown prior to bringing up the network so the framework does not 3021 * know how to go about satisfing a request with these capabilities. 3022 * 3023 * <p>This method requires the caller to hold either the 3024 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 3025 * or the ability to modify system settings as determined by 3026 * {@link android.provider.Settings.System#canWrite}.</p> 3027 * 3028 * @param request {@link NetworkRequest} describing this request. 3029 * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note 3030 * the callback must not be shared - it uniquely specifies this request. 3031 * @param handler {@link Handler} to specify the thread upon which the callback will be invoked. 3032 * @throws IllegalArgumentException if {@code request} specifies any mutable 3033 * {@code NetworkCapabilities}. 3034 */ requestNetwork( NetworkRequest request, NetworkCallback networkCallback, Handler handler)3035 public void requestNetwork( 3036 NetworkRequest request, NetworkCallback networkCallback, Handler handler) { 3037 int legacyType = inferLegacyTypeForNetworkCapabilities(request.networkCapabilities); 3038 CallbackHandler cbHandler = new CallbackHandler(handler); 3039 requestNetwork(request, networkCallback, 0, legacyType, cbHandler); 3040 } 3041 3042 /** 3043 * Request a network to satisfy a set of {@link android.net.NetworkCapabilities}, limited 3044 * by a timeout. 3045 * 3046 * This function behaves identically to the non-timed-out version 3047 * {@link #requestNetwork(NetworkRequest, NetworkCallback)}, but if a suitable network 3048 * is not found within the given time (in milliseconds) the 3049 * {@link NetworkCallback#onUnavailable()} callback is called. The request can still be 3050 * released normally by calling {@link #unregisterNetworkCallback(NetworkCallback)} but does 3051 * not have to be released if timed-out (it is automatically released). Unregistering a 3052 * request that timed out is not an error. 3053 * 3054 * <p>Do not use this method to poll for the existence of specific networks (e.g. with a small 3055 * timeout) - {@link #registerNetworkCallback(NetworkRequest, NetworkCallback)} is provided 3056 * for that purpose. Calling this method will attempt to bring up the requested network. 3057 * 3058 * <p>This method requires the caller to hold either the 3059 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 3060 * or the ability to modify system settings as determined by 3061 * {@link android.provider.Settings.System#canWrite}.</p> 3062 * 3063 * @param request {@link NetworkRequest} describing this request. 3064 * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note 3065 * the callback must not be shared - it uniquely specifies this request. 3066 * @param timeoutMs The time in milliseconds to attempt looking for a suitable network 3067 * before {@link NetworkCallback#onUnavailable()} is called. The timeout must 3068 * be a positive value (i.e. >0). 3069 */ requestNetwork(NetworkRequest request, NetworkCallback networkCallback, int timeoutMs)3070 public void requestNetwork(NetworkRequest request, NetworkCallback networkCallback, 3071 int timeoutMs) { 3072 checkTimeout(timeoutMs); 3073 int legacyType = inferLegacyTypeForNetworkCapabilities(request.networkCapabilities); 3074 requestNetwork(request, networkCallback, timeoutMs, legacyType, getDefaultHandler()); 3075 } 3076 3077 /** 3078 * Request a network to satisfy a set of {@link android.net.NetworkCapabilities}, limited 3079 * by a timeout. 3080 * 3081 * This function behaves identically to the non-timedout version, but if a suitable 3082 * network is not found within the given time (in milliseconds) the 3083 * {@link NetworkCallback#onUnavailable} callback is called. The request can still be 3084 * released normally by calling {@link #unregisterNetworkCallback(NetworkCallback)} but does 3085 * not have to be released if timed-out (it is automatically released). Unregistering a 3086 * request that timed out is not an error. 3087 * 3088 * <p>Do not use this method to poll for the existence of specific networks (e.g. with a small 3089 * timeout) - {@link #registerNetworkCallback(NetworkRequest, NetworkCallback)} is provided 3090 * for that purpose. Calling this method will attempt to bring up the requested network. 3091 * 3092 * <p>This method requires the caller to hold either the 3093 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 3094 * or the ability to modify system settings as determined by 3095 * {@link android.provider.Settings.System#canWrite}.</p> 3096 * 3097 * @param request {@link NetworkRequest} describing this request. 3098 * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note 3099 * the callback must not be shared - it uniquely specifies this request. 3100 * @param handler {@link Handler} to specify the thread upon which the callback will be invoked. 3101 * @param timeoutMs The time in milliseconds to attempt looking for a suitable network 3102 * before {@link NetworkCallback#onUnavailable} is called. 3103 */ requestNetwork(NetworkRequest request, NetworkCallback networkCallback, Handler handler, int timeoutMs)3104 public void requestNetwork(NetworkRequest request, NetworkCallback networkCallback, 3105 Handler handler, int timeoutMs) { 3106 checkTimeout(timeoutMs); 3107 int legacyType = inferLegacyTypeForNetworkCapabilities(request.networkCapabilities); 3108 CallbackHandler cbHandler = new CallbackHandler(handler); 3109 requestNetwork(request, networkCallback, timeoutMs, legacyType, cbHandler); 3110 } 3111 3112 /** 3113 * The lookup key for a {@link Network} object included with the intent after 3114 * successfully finding a network for the applications request. Retrieve it with 3115 * {@link android.content.Intent#getParcelableExtra(String)}. 3116 * <p> 3117 * Note that if you intend to invoke {@link Network#openConnection(java.net.URL)} 3118 * then you must get a ConnectivityManager instance before doing so. 3119 */ 3120 public static final String EXTRA_NETWORK = "android.net.extra.NETWORK"; 3121 3122 /** 3123 * The lookup key for a {@link NetworkRequest} object included with the intent after 3124 * successfully finding a network for the applications request. Retrieve it with 3125 * {@link android.content.Intent#getParcelableExtra(String)}. 3126 */ 3127 public static final String EXTRA_NETWORK_REQUEST = "android.net.extra.NETWORK_REQUEST"; 3128 3129 3130 /** 3131 * Request a network to satisfy a set of {@link android.net.NetworkCapabilities}. 3132 * 3133 * This function behaves identically to the version that takes a NetworkCallback, but instead 3134 * of {@link NetworkCallback} a {@link PendingIntent} is used. This means 3135 * the request may outlive the calling application and get called back when a suitable 3136 * network is found. 3137 * <p> 3138 * The operation is an Intent broadcast that goes to a broadcast receiver that 3139 * you registered with {@link Context#registerReceiver} or through the 3140 * <receiver> tag in an AndroidManifest.xml file 3141 * <p> 3142 * The operation Intent is delivered with two extras, a {@link Network} typed 3143 * extra called {@link #EXTRA_NETWORK} and a {@link NetworkRequest} 3144 * typed extra called {@link #EXTRA_NETWORK_REQUEST} containing 3145 * the original requests parameters. It is important to create a new, 3146 * {@link NetworkCallback} based request before completing the processing of the 3147 * Intent to reserve the network or it will be released shortly after the Intent 3148 * is processed. 3149 * <p> 3150 * If there is already a request for this Intent registered (with the equality of 3151 * two Intents defined by {@link Intent#filterEquals}), then it will be removed and 3152 * replaced by this one, effectively releasing the previous {@link NetworkRequest}. 3153 * <p> 3154 * The request may be released normally by calling 3155 * {@link #releaseNetworkRequest(android.app.PendingIntent)}. 3156 * <p>It is presently unsupported to request a network with either 3157 * {@link NetworkCapabilities#NET_CAPABILITY_VALIDATED} or 3158 * {@link NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL} 3159 * as these {@code NetworkCapabilities} represent states that a particular 3160 * network may never attain, and whether a network will attain these states 3161 * is unknown prior to bringing up the network so the framework does not 3162 * know how to go about satisfing a request with these capabilities. 3163 * 3164 * <p>This method requires the caller to hold either the 3165 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission 3166 * or the ability to modify system settings as determined by 3167 * {@link android.provider.Settings.System#canWrite}.</p> 3168 * 3169 * @param request {@link NetworkRequest} describing this request. 3170 * @param operation Action to perform when the network is available (corresponds 3171 * to the {@link NetworkCallback#onAvailable} call. Typically 3172 * comes from {@link PendingIntent#getBroadcast}. Cannot be null. 3173 * @throws IllegalArgumentException if {@code request} contains either 3174 * {@link NetworkCapabilities#NET_CAPABILITY_VALIDATED} or 3175 * {@link NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL}. 3176 */ requestNetwork(NetworkRequest request, PendingIntent operation)3177 public void requestNetwork(NetworkRequest request, PendingIntent operation) { 3178 checkPendingIntentNotNull(operation); 3179 try { 3180 mService.pendingRequestForNetwork(request.networkCapabilities, operation); 3181 } catch (RemoteException e) { 3182 throw e.rethrowFromSystemServer(); 3183 } catch (ServiceSpecificException e) { 3184 throw convertServiceException(e); 3185 } 3186 } 3187 3188 /** 3189 * Removes a request made via {@link #requestNetwork(NetworkRequest, android.app.PendingIntent)} 3190 * <p> 3191 * This method has the same behavior as 3192 * {@link #unregisterNetworkCallback(android.app.PendingIntent)} with respect to 3193 * releasing network resources and disconnecting. 3194 * 3195 * @param operation A PendingIntent equal (as defined by {@link Intent#filterEquals}) to the 3196 * PendingIntent passed to 3197 * {@link #requestNetwork(NetworkRequest, android.app.PendingIntent)} with the 3198 * corresponding NetworkRequest you'd like to remove. Cannot be null. 3199 */ releaseNetworkRequest(PendingIntent operation)3200 public void releaseNetworkRequest(PendingIntent operation) { 3201 checkPendingIntentNotNull(operation); 3202 try { 3203 mService.releasePendingNetworkRequest(operation); 3204 } catch (RemoteException e) { 3205 throw e.rethrowFromSystemServer(); 3206 } 3207 } 3208 checkPendingIntentNotNull(PendingIntent intent)3209 private static void checkPendingIntentNotNull(PendingIntent intent) { 3210 Preconditions.checkNotNull(intent, "PendingIntent cannot be null."); 3211 } 3212 checkCallbackNotNull(NetworkCallback callback)3213 private static void checkCallbackNotNull(NetworkCallback callback) { 3214 Preconditions.checkNotNull(callback, "null NetworkCallback"); 3215 } 3216 checkTimeout(int timeoutMs)3217 private static void checkTimeout(int timeoutMs) { 3218 Preconditions.checkArgumentPositive(timeoutMs, "timeoutMs must be strictly positive."); 3219 } 3220 3221 /** 3222 * Registers to receive notifications about all networks which satisfy the given 3223 * {@link NetworkRequest}. The callbacks will continue to be called until 3224 * either the application exits or link #unregisterNetworkCallback(NetworkCallback)} is called. 3225 * 3226 * @param request {@link NetworkRequest} describing this request. 3227 * @param networkCallback The {@link NetworkCallback} that the system will call as suitable 3228 * networks change state. 3229 * The callback is invoked on the default internal Handler. 3230 */ 3231 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) registerNetworkCallback(NetworkRequest request, NetworkCallback networkCallback)3232 public void registerNetworkCallback(NetworkRequest request, NetworkCallback networkCallback) { 3233 registerNetworkCallback(request, networkCallback, getDefaultHandler()); 3234 } 3235 3236 /** 3237 * Registers to receive notifications about all networks which satisfy the given 3238 * {@link NetworkRequest}. The callbacks will continue to be called until 3239 * either the application exits or link #unregisterNetworkCallback(NetworkCallback)} is called. 3240 * 3241 * @param request {@link NetworkRequest} describing this request. 3242 * @param networkCallback The {@link NetworkCallback} that the system will call as suitable 3243 * networks change state. 3244 * @param handler {@link Handler} to specify the thread upon which the callback will be invoked. 3245 */ 3246 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) registerNetworkCallback( NetworkRequest request, NetworkCallback networkCallback, Handler handler)3247 public void registerNetworkCallback( 3248 NetworkRequest request, NetworkCallback networkCallback, Handler handler) { 3249 CallbackHandler cbHandler = new CallbackHandler(handler); 3250 NetworkCapabilities nc = request.networkCapabilities; 3251 sendRequestForNetwork(nc, networkCallback, 0, LISTEN, TYPE_NONE, cbHandler); 3252 } 3253 3254 /** 3255 * Registers a PendingIntent to be sent when a network is available which satisfies the given 3256 * {@link NetworkRequest}. 3257 * 3258 * This function behaves identically to the version that takes a NetworkCallback, but instead 3259 * of {@link NetworkCallback} a {@link PendingIntent} is used. This means 3260 * the request may outlive the calling application and get called back when a suitable 3261 * network is found. 3262 * <p> 3263 * The operation is an Intent broadcast that goes to a broadcast receiver that 3264 * you registered with {@link Context#registerReceiver} or through the 3265 * <receiver> tag in an AndroidManifest.xml file 3266 * <p> 3267 * The operation Intent is delivered with two extras, a {@link Network} typed 3268 * extra called {@link #EXTRA_NETWORK} and a {@link NetworkRequest} 3269 * typed extra called {@link #EXTRA_NETWORK_REQUEST} containing 3270 * the original requests parameters. 3271 * <p> 3272 * If there is already a request for this Intent registered (with the equality of 3273 * two Intents defined by {@link Intent#filterEquals}), then it will be removed and 3274 * replaced by this one, effectively releasing the previous {@link NetworkRequest}. 3275 * <p> 3276 * The request may be released normally by calling 3277 * {@link #unregisterNetworkCallback(android.app.PendingIntent)}. 3278 * @param request {@link NetworkRequest} describing this request. 3279 * @param operation Action to perform when the network is available (corresponds 3280 * to the {@link NetworkCallback#onAvailable} call. Typically 3281 * comes from {@link PendingIntent#getBroadcast}. Cannot be null. 3282 */ 3283 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) registerNetworkCallback(NetworkRequest request, PendingIntent operation)3284 public void registerNetworkCallback(NetworkRequest request, PendingIntent operation) { 3285 checkPendingIntentNotNull(operation); 3286 try { 3287 mService.pendingListenForNetwork(request.networkCapabilities, operation); 3288 } catch (RemoteException e) { 3289 throw e.rethrowFromSystemServer(); 3290 } catch (ServiceSpecificException e) { 3291 throw convertServiceException(e); 3292 } 3293 } 3294 3295 /** 3296 * Registers to receive notifications about changes in the system default network. The callbacks 3297 * will continue to be called until either the application exits or 3298 * {@link #unregisterNetworkCallback(NetworkCallback)} is called. 3299 * 3300 * @param networkCallback The {@link NetworkCallback} that the system will call as the 3301 * system default network changes. 3302 * The callback is invoked on the default internal Handler. 3303 */ 3304 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) registerDefaultNetworkCallback(NetworkCallback networkCallback)3305 public void registerDefaultNetworkCallback(NetworkCallback networkCallback) { 3306 registerDefaultNetworkCallback(networkCallback, getDefaultHandler()); 3307 } 3308 3309 /** 3310 * Registers to receive notifications about changes in the system default network. The callbacks 3311 * will continue to be called until either the application exits or 3312 * {@link #unregisterNetworkCallback(NetworkCallback)} is called. 3313 * 3314 * @param networkCallback The {@link NetworkCallback} that the system will call as the 3315 * system default network changes. 3316 * @param handler {@link Handler} to specify the thread upon which the callback will be invoked. 3317 */ 3318 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) registerDefaultNetworkCallback(NetworkCallback networkCallback, Handler handler)3319 public void registerDefaultNetworkCallback(NetworkCallback networkCallback, Handler handler) { 3320 // This works because if the NetworkCapabilities are null, 3321 // ConnectivityService takes them from the default request. 3322 // 3323 // Since the capabilities are exactly the same as the default request's 3324 // capabilities, this request is guaranteed, at all times, to be 3325 // satisfied by the same network, if any, that satisfies the default 3326 // request, i.e., the system default network. 3327 NetworkCapabilities nullCapabilities = null; 3328 CallbackHandler cbHandler = new CallbackHandler(handler); 3329 sendRequestForNetwork(nullCapabilities, networkCallback, 0, REQUEST, TYPE_NONE, cbHandler); 3330 } 3331 3332 /** 3333 * Requests bandwidth update for a given {@link Network} and returns whether the update request 3334 * is accepted by ConnectivityService. Once accepted, ConnectivityService will poll underlying 3335 * network connection for updated bandwidth information. The caller will be notified via 3336 * {@link ConnectivityManager.NetworkCallback} if there is an update. Notice that this 3337 * method assumes that the caller has previously called 3338 * {@link #registerNetworkCallback(NetworkRequest, NetworkCallback)} to listen for network 3339 * changes. 3340 * 3341 * @param network {@link Network} specifying which network you're interested. 3342 * @return {@code true} on success, {@code false} if the {@link Network} is no longer valid. 3343 */ requestBandwidthUpdate(Network network)3344 public boolean requestBandwidthUpdate(Network network) { 3345 try { 3346 return mService.requestBandwidthUpdate(network); 3347 } catch (RemoteException e) { 3348 throw e.rethrowFromSystemServer(); 3349 } 3350 } 3351 3352 /** 3353 * Unregisters a {@code NetworkCallback} and possibly releases networks originating from 3354 * {@link #requestNetwork(NetworkRequest, NetworkCallback)} and 3355 * {@link #registerNetworkCallback(NetworkRequest, NetworkCallback)} calls. 3356 * If the given {@code NetworkCallback} had previously been used with 3357 * {@code #requestNetwork}, any networks that had been connected to only to satisfy that request 3358 * will be disconnected. 3359 * 3360 * Notifications that would have triggered that {@code NetworkCallback} will immediately stop 3361 * triggering it as soon as this call returns. 3362 * 3363 * @param networkCallback The {@link NetworkCallback} used when making the request. 3364 */ unregisterNetworkCallback(NetworkCallback networkCallback)3365 public void unregisterNetworkCallback(NetworkCallback networkCallback) { 3366 checkCallbackNotNull(networkCallback); 3367 final List<NetworkRequest> reqs = new ArrayList<>(); 3368 // Find all requests associated to this callback and stop callback triggers immediately. 3369 // Callback is reusable immediately. http://b/20701525, http://b/35921499. 3370 synchronized (sCallbacks) { 3371 Preconditions.checkArgument(networkCallback.networkRequest != null, 3372 "NetworkCallback was not registered"); 3373 Preconditions.checkArgument(networkCallback.networkRequest != ALREADY_UNREGISTERED, 3374 "NetworkCallback was already unregistered"); 3375 for (Map.Entry<NetworkRequest, NetworkCallback> e : sCallbacks.entrySet()) { 3376 if (e.getValue() == networkCallback) { 3377 reqs.add(e.getKey()); 3378 } 3379 } 3380 // TODO: throw exception if callback was registered more than once (http://b/20701525). 3381 for (NetworkRequest r : reqs) { 3382 try { 3383 mService.releaseNetworkRequest(r); 3384 } catch (RemoteException e) { 3385 throw e.rethrowFromSystemServer(); 3386 } 3387 // Only remove mapping if rpc was successful. 3388 sCallbacks.remove(r); 3389 } 3390 networkCallback.networkRequest = ALREADY_UNREGISTERED; 3391 } 3392 } 3393 3394 /** 3395 * Unregisters a callback previously registered via 3396 * {@link #registerNetworkCallback(NetworkRequest, android.app.PendingIntent)}. 3397 * 3398 * @param operation A PendingIntent equal (as defined by {@link Intent#filterEquals}) to the 3399 * PendingIntent passed to 3400 * {@link #registerNetworkCallback(NetworkRequest, android.app.PendingIntent)}. 3401 * Cannot be null. 3402 */ unregisterNetworkCallback(PendingIntent operation)3403 public void unregisterNetworkCallback(PendingIntent operation) { 3404 checkPendingIntentNotNull(operation); 3405 releaseNetworkRequest(operation); 3406 } 3407 3408 /** 3409 * Informs the system whether it should switch to {@code network} regardless of whether it is 3410 * validated or not. If {@code accept} is true, and the network was explicitly selected by the 3411 * user (e.g., by selecting a Wi-Fi network in the Settings app), then the network will become 3412 * the system default network regardless of any other network that's currently connected. If 3413 * {@code always} is true, then the choice is remembered, so that the next time the user 3414 * connects to this network, the system will switch to it. 3415 * 3416 * @param network The network to accept. 3417 * @param accept Whether to accept the network even if unvalidated. 3418 * @param always Whether to remember this choice in the future. 3419 * 3420 * @hide 3421 */ 3422 @RequiresPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL) setAcceptUnvalidated(Network network, boolean accept, boolean always)3423 public void setAcceptUnvalidated(Network network, boolean accept, boolean always) { 3424 try { 3425 mService.setAcceptUnvalidated(network, accept, always); 3426 } catch (RemoteException e) { 3427 throw e.rethrowFromSystemServer(); 3428 } 3429 } 3430 3431 /** 3432 * Informs the system to penalize {@code network}'s score when it becomes unvalidated. This is 3433 * only meaningful if the system is configured not to penalize such networks, e.g., if the 3434 * {@code config_networkAvoidBadWifi} configuration variable is set to 0 and the {@code 3435 * NETWORK_AVOID_BAD_WIFI setting is unset}. 3436 * 3437 * @param network The network to accept. 3438 * 3439 * @hide 3440 */ 3441 @RequiresPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL) setAvoidUnvalidated(Network network)3442 public void setAvoidUnvalidated(Network network) { 3443 try { 3444 mService.setAvoidUnvalidated(network); 3445 } catch (RemoteException e) { 3446 throw e.rethrowFromSystemServer(); 3447 } 3448 } 3449 3450 /** 3451 * Requests that the system open the captive portal app on the specified network. 3452 * 3453 * @param network The network to log into. 3454 * 3455 * @hide 3456 */ 3457 @RequiresPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL) startCaptivePortalApp(Network network)3458 public void startCaptivePortalApp(Network network) { 3459 try { 3460 mService.startCaptivePortalApp(network); 3461 } catch (RemoteException e) { 3462 throw e.rethrowFromSystemServer(); 3463 } 3464 } 3465 3466 /** 3467 * It is acceptable to briefly use multipath data to provide seamless connectivity for 3468 * time-sensitive user-facing operations when the system default network is temporarily 3469 * unresponsive. The amount of data should be limited (less than one megabyte for every call to 3470 * this method), and the operation should be infrequent to ensure that data usage is limited. 3471 * 3472 * An example of such an operation might be a time-sensitive foreground activity, such as a 3473 * voice command, that the user is performing while walking out of range of a Wi-Fi network. 3474 */ 3475 public static final int MULTIPATH_PREFERENCE_HANDOVER = 1 << 0; 3476 3477 /** 3478 * It is acceptable to use small amounts of multipath data on an ongoing basis to provide 3479 * a backup channel for traffic that is primarily going over another network. 3480 * 3481 * An example might be maintaining backup connections to peers or servers for the purpose of 3482 * fast fallback if the default network is temporarily unresponsive or disconnects. The traffic 3483 * on backup paths should be negligible compared to the traffic on the main path. 3484 */ 3485 public static final int MULTIPATH_PREFERENCE_RELIABILITY = 1 << 1; 3486 3487 /** 3488 * It is acceptable to use metered data to improve network latency and performance. 3489 */ 3490 public static final int MULTIPATH_PREFERENCE_PERFORMANCE = 1 << 2; 3491 3492 /** 3493 * Return value to use for unmetered networks. On such networks we currently set all the flags 3494 * to true. 3495 * @hide 3496 */ 3497 public static final int MULTIPATH_PREFERENCE_UNMETERED = 3498 MULTIPATH_PREFERENCE_HANDOVER | 3499 MULTIPATH_PREFERENCE_RELIABILITY | 3500 MULTIPATH_PREFERENCE_PERFORMANCE; 3501 3502 /** @hide */ 3503 @Retention(RetentionPolicy.SOURCE) 3504 @IntDef(flag = true, value = { 3505 MULTIPATH_PREFERENCE_HANDOVER, 3506 MULTIPATH_PREFERENCE_RELIABILITY, 3507 MULTIPATH_PREFERENCE_PERFORMANCE, 3508 }) 3509 public @interface MultipathPreference { 3510 } 3511 3512 /** 3513 * Provides a hint to the calling application on whether it is desirable to use the 3514 * multinetwork APIs (e.g., {@link Network#openConnection}, {@link Network#bindSocket}, etc.) 3515 * for multipath data transfer on this network when it is not the system default network. 3516 * Applications desiring to use multipath network protocols should call this method before 3517 * each such operation. 3518 * 3519 * @param network The network on which the application desires to use multipath data. 3520 * If {@code null}, this method will return the a preference that will generally 3521 * apply to metered networks. 3522 * @return a bitwise OR of zero or more of the {@code MULTIPATH_PREFERENCE_*} constants. 3523 */ 3524 @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) getMultipathPreference(Network network)3525 public @MultipathPreference int getMultipathPreference(Network network) { 3526 try { 3527 return mService.getMultipathPreference(network); 3528 } catch (RemoteException e) { 3529 throw e.rethrowFromSystemServer(); 3530 } 3531 } 3532 3533 /** 3534 * Resets all connectivity manager settings back to factory defaults. 3535 * @hide 3536 */ factoryReset()3537 public void factoryReset() { 3538 try { 3539 mService.factoryReset(); 3540 } catch (RemoteException e) { 3541 throw e.rethrowFromSystemServer(); 3542 } 3543 } 3544 3545 /** 3546 * Binds the current process to {@code network}. All Sockets created in the future 3547 * (and not explicitly bound via a bound SocketFactory from 3548 * {@link Network#getSocketFactory() Network.getSocketFactory()}) will be bound to 3549 * {@code network}. All host name resolutions will be limited to {@code network} as well. 3550 * Note that if {@code network} ever disconnects, all Sockets created in this way will cease to 3551 * work and all host name resolutions will fail. This is by design so an application doesn't 3552 * accidentally use Sockets it thinks are still bound to a particular {@link Network}. 3553 * To clear binding pass {@code null} for {@code network}. Using individually bound 3554 * Sockets created by Network.getSocketFactory().createSocket() and 3555 * performing network-specific host name resolutions via 3556 * {@link Network#getAllByName Network.getAllByName} is preferred to calling 3557 * {@code bindProcessToNetwork}. 3558 * 3559 * @param network The {@link Network} to bind the current process to, or {@code null} to clear 3560 * the current binding. 3561 * @return {@code true} on success, {@code false} if the {@link Network} is no longer valid. 3562 */ bindProcessToNetwork(Network network)3563 public boolean bindProcessToNetwork(Network network) { 3564 // Forcing callers to call thru non-static function ensures ConnectivityManager 3565 // instantiated. 3566 return setProcessDefaultNetwork(network); 3567 } 3568 3569 /** 3570 * Binds the current process to {@code network}. All Sockets created in the future 3571 * (and not explicitly bound via a bound SocketFactory from 3572 * {@link Network#getSocketFactory() Network.getSocketFactory()}) will be bound to 3573 * {@code network}. All host name resolutions will be limited to {@code network} as well. 3574 * Note that if {@code network} ever disconnects, all Sockets created in this way will cease to 3575 * work and all host name resolutions will fail. This is by design so an application doesn't 3576 * accidentally use Sockets it thinks are still bound to a particular {@link Network}. 3577 * To clear binding pass {@code null} for {@code network}. Using individually bound 3578 * Sockets created by Network.getSocketFactory().createSocket() and 3579 * performing network-specific host name resolutions via 3580 * {@link Network#getAllByName Network.getAllByName} is preferred to calling 3581 * {@code setProcessDefaultNetwork}. 3582 * 3583 * @param network The {@link Network} to bind the current process to, or {@code null} to clear 3584 * the current binding. 3585 * @return {@code true} on success, {@code false} if the {@link Network} is no longer valid. 3586 * @deprecated This function can throw {@link IllegalStateException}. Use 3587 * {@link #bindProcessToNetwork} instead. {@code bindProcessToNetwork} 3588 * is a direct replacement. 3589 */ 3590 @Deprecated setProcessDefaultNetwork(Network network)3591 public static boolean setProcessDefaultNetwork(Network network) { 3592 int netId = (network == null) ? NETID_UNSET : network.netId; 3593 if (netId == NetworkUtils.getBoundNetworkForProcess()) { 3594 return true; 3595 } 3596 if (NetworkUtils.bindProcessToNetwork(netId)) { 3597 // Set HTTP proxy system properties to match network. 3598 // TODO: Deprecate this static method and replace it with a non-static version. 3599 try { 3600 Proxy.setHttpProxySystemProperty(getInstance().getDefaultProxy()); 3601 } catch (SecurityException e) { 3602 // The process doesn't have ACCESS_NETWORK_STATE, so we can't fetch the proxy. 3603 Log.e(TAG, "Can't set proxy properties", e); 3604 } 3605 // Must flush DNS cache as new network may have different DNS resolutions. 3606 InetAddress.clearDnsCache(); 3607 // Must flush socket pool as idle sockets will be bound to previous network and may 3608 // cause subsequent fetches to be performed on old network. 3609 NetworkEventDispatcher.getInstance().onNetworkConfigurationChanged(); 3610 return true; 3611 } else { 3612 return false; 3613 } 3614 } 3615 3616 /** 3617 * Returns the {@link Network} currently bound to this process via 3618 * {@link #bindProcessToNetwork}, or {@code null} if no {@link Network} is explicitly bound. 3619 * 3620 * @return {@code Network} to which this process is bound, or {@code null}. 3621 */ getBoundNetworkForProcess()3622 public Network getBoundNetworkForProcess() { 3623 // Forcing callers to call thru non-static function ensures ConnectivityManager 3624 // instantiated. 3625 return getProcessDefaultNetwork(); 3626 } 3627 3628 /** 3629 * Returns the {@link Network} currently bound to this process via 3630 * {@link #bindProcessToNetwork}, or {@code null} if no {@link Network} is explicitly bound. 3631 * 3632 * @return {@code Network} to which this process is bound, or {@code null}. 3633 * @deprecated Using this function can lead to other functions throwing 3634 * {@link IllegalStateException}. Use {@link #getBoundNetworkForProcess} instead. 3635 * {@code getBoundNetworkForProcess} is a direct replacement. 3636 */ 3637 @Deprecated getProcessDefaultNetwork()3638 public static Network getProcessDefaultNetwork() { 3639 int netId = NetworkUtils.getBoundNetworkForProcess(); 3640 if (netId == NETID_UNSET) return null; 3641 return new Network(netId); 3642 } 3643 unsupportedStartingFrom(int version)3644 private void unsupportedStartingFrom(int version) { 3645 if (Process.myUid() == Process.SYSTEM_UID) { 3646 // The getApplicationInfo() call we make below is not supported in system context, and 3647 // we want to allow the system to use these APIs anyway. 3648 return; 3649 } 3650 3651 if (mContext.getApplicationInfo().targetSdkVersion >= version) { 3652 throw new UnsupportedOperationException( 3653 "This method is not supported in target SDK version " + version + " and above"); 3654 } 3655 } 3656 3657 // Checks whether the calling app can use the legacy routing API (startUsingNetworkFeature, 3658 // stopUsingNetworkFeature, requestRouteToHost), and if not throw UnsupportedOperationException. 3659 // TODO: convert the existing system users (Tethering, GnssLocationProvider) to the new APIs and 3660 // remove these exemptions. Note that this check is not secure, and apps can still access these 3661 // functions by accessing ConnectivityService directly. However, it should be clear that doing 3662 // so is unsupported and may break in the future. http://b/22728205 checkLegacyRoutingApiAccess()3663 private void checkLegacyRoutingApiAccess() { 3664 if (mContext.checkCallingOrSelfPermission("com.android.permission.INJECT_OMADM_SETTINGS") 3665 == PackageManager.PERMISSION_GRANTED) { 3666 return; 3667 } 3668 3669 unsupportedStartingFrom(VERSION_CODES.M); 3670 } 3671 3672 /** 3673 * Binds host resolutions performed by this process to {@code network}. 3674 * {@link #bindProcessToNetwork} takes precedence over this setting. 3675 * 3676 * @param network The {@link Network} to bind host resolutions from the current process to, or 3677 * {@code null} to clear the current binding. 3678 * @return {@code true} on success, {@code false} if the {@link Network} is no longer valid. 3679 * @hide 3680 * @deprecated This is strictly for legacy usage to support {@link #startUsingNetworkFeature}. 3681 */ 3682 @Deprecated setProcessDefaultNetworkForHostResolution(Network network)3683 public static boolean setProcessDefaultNetworkForHostResolution(Network network) { 3684 return NetworkUtils.bindProcessToNetworkForHostResolution( 3685 network == null ? NETID_UNSET : network.netId); 3686 } 3687 3688 /** 3689 * Device is not restricting metered network activity while application is running on 3690 * background. 3691 */ 3692 public static final int RESTRICT_BACKGROUND_STATUS_DISABLED = 1; 3693 3694 /** 3695 * Device is restricting metered network activity while application is running on background, 3696 * but application is allowed to bypass it. 3697 * <p> 3698 * In this state, application should take action to mitigate metered network access. 3699 * For example, a music streaming application should switch to a low-bandwidth bitrate. 3700 */ 3701 public static final int RESTRICT_BACKGROUND_STATUS_WHITELISTED = 2; 3702 3703 /** 3704 * Device is restricting metered network activity while application is running on background. 3705 * <p> 3706 * In this state, application should not try to use the network while running on background, 3707 * because it would be denied. 3708 */ 3709 public static final int RESTRICT_BACKGROUND_STATUS_ENABLED = 3; 3710 3711 /** 3712 * A change in the background metered network activity restriction has occurred. 3713 * <p> 3714 * Applications should call {@link #getRestrictBackgroundStatus()} to check if the restriction 3715 * applies to them. 3716 * <p> 3717 * This is only sent to registered receivers, not manifest receivers. 3718 */ 3719 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 3720 public static final String ACTION_RESTRICT_BACKGROUND_CHANGED = 3721 "android.net.conn.RESTRICT_BACKGROUND_CHANGED"; 3722 3723 /** @hide */ 3724 @Retention(RetentionPolicy.SOURCE) 3725 @IntDef(flag = false, value = { 3726 RESTRICT_BACKGROUND_STATUS_DISABLED, 3727 RESTRICT_BACKGROUND_STATUS_WHITELISTED, 3728 RESTRICT_BACKGROUND_STATUS_ENABLED, 3729 }) 3730 public @interface RestrictBackgroundStatus { 3731 } 3732 getNetworkPolicyManager()3733 private INetworkPolicyManager getNetworkPolicyManager() { 3734 synchronized (this) { 3735 if (mNPManager != null) { 3736 return mNPManager; 3737 } 3738 mNPManager = INetworkPolicyManager.Stub.asInterface(ServiceManager 3739 .getService(Context.NETWORK_POLICY_SERVICE)); 3740 return mNPManager; 3741 } 3742 } 3743 3744 /** 3745 * Determines if the calling application is subject to metered network restrictions while 3746 * running on background. 3747 * 3748 * @return {@link #RESTRICT_BACKGROUND_STATUS_DISABLED}, 3749 * {@link #RESTRICT_BACKGROUND_STATUS_ENABLED}, 3750 * or {@link #RESTRICT_BACKGROUND_STATUS_WHITELISTED} 3751 */ getRestrictBackgroundStatus()3752 public @RestrictBackgroundStatus int getRestrictBackgroundStatus() { 3753 try { 3754 return getNetworkPolicyManager().getRestrictBackgroundByCaller(); 3755 } catch (RemoteException e) { 3756 throw e.rethrowFromSystemServer(); 3757 } 3758 } 3759 } 3760