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