1 /* 2 * Copyright 2021 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 17 package com.android.internal.telephony.data; 18 19 import static android.telephony.TelephonyManager.HAL_SERVICE_DATA; 20 21 import android.annotation.CallbackExecutor; 22 import android.annotation.IntDef; 23 import android.annotation.NonNull; 24 import android.annotation.Nullable; 25 import android.content.Intent; 26 import android.net.ConnectivityManager; 27 import android.net.LinkAddress; 28 import android.net.LinkProperties; 29 import android.net.NetworkAgent; 30 import android.net.NetworkAgentConfig; 31 import android.net.NetworkCapabilities; 32 import android.net.NetworkProvider; 33 import android.net.NetworkRequest; 34 import android.net.NetworkScore; 35 import android.net.ProxyInfo; 36 import android.net.RouteInfo; 37 import android.net.TelephonyNetworkSpecifier; 38 import android.net.Uri; 39 import android.net.vcn.VcnManager; 40 import android.net.vcn.VcnManager.VcnNetworkPolicyChangeListener; 41 import android.net.vcn.VcnNetworkPolicyResult; 42 import android.os.AsyncResult; 43 import android.os.Looper; 44 import android.os.Message; 45 import android.os.Process; 46 import android.os.SystemClock; 47 import android.provider.Telephony; 48 import android.telephony.AccessNetworkConstants; 49 import android.telephony.AccessNetworkConstants.AccessNetworkType; 50 import android.telephony.AccessNetworkConstants.TransportType; 51 import android.telephony.Annotation.DataFailureCause; 52 import android.telephony.Annotation.DataState; 53 import android.telephony.Annotation.NetCapability; 54 import android.telephony.Annotation.NetworkType; 55 import android.telephony.Annotation.ValidationStatus; 56 import android.telephony.AnomalyReporter; 57 import android.telephony.CarrierConfigManager; 58 import android.telephony.DataFailCause; 59 import android.telephony.DataSpecificRegistrationInfo; 60 import android.telephony.LinkCapacityEstimate; 61 import android.telephony.NetworkRegistrationInfo; 62 import android.telephony.PcoData; 63 import android.telephony.PreciseDataConnectionState; 64 import android.telephony.ServiceState; 65 import android.telephony.SubscriptionManager; 66 import android.telephony.SubscriptionPlan; 67 import android.telephony.TelephonyDisplayInfo; 68 import android.telephony.TelephonyManager; 69 import android.telephony.data.ApnSetting; 70 import android.telephony.data.DataCallResponse; 71 import android.telephony.data.DataCallResponse.HandoverFailureMode; 72 import android.telephony.data.DataCallResponse.LinkStatus; 73 import android.telephony.data.DataProfile; 74 import android.telephony.data.DataService; 75 import android.telephony.data.DataServiceCallback; 76 import android.telephony.data.NetworkSliceInfo; 77 import android.telephony.data.Qos; 78 import android.telephony.data.QosBearerSession; 79 import android.telephony.data.TrafficDescriptor; 80 import android.telephony.data.TrafficDescriptor.OsAppId; 81 import android.text.TextUtils; 82 import android.util.ArrayMap; 83 import android.util.IndentingPrintWriter; 84 import android.util.LocalLog; 85 import android.util.SparseArray; 86 import android.util.SparseIntArray; 87 88 import com.android.internal.telephony.CarrierSignalAgent; 89 import com.android.internal.telephony.CommandsInterface; 90 import com.android.internal.telephony.Phone; 91 import com.android.internal.telephony.PhoneConstants; 92 import com.android.internal.telephony.PhoneFactory; 93 import com.android.internal.telephony.RIL; 94 import com.android.internal.telephony.data.AccessNetworksManager.AccessNetworksManagerCallback; 95 import com.android.internal.telephony.data.DataConfigManager.DataConfigManagerCallback; 96 import com.android.internal.telephony.data.DataEvaluation.DataAllowedReason; 97 import com.android.internal.telephony.data.DataNetworkController.NetworkRequestList; 98 import com.android.internal.telephony.data.DataRetryManager.DataHandoverRetryEntry; 99 import com.android.internal.telephony.data.DataRetryManager.DataRetryEntry; 100 import com.android.internal.telephony.data.DataSettingsManager.DataSettingsManagerCallback; 101 import com.android.internal.telephony.data.LinkBandwidthEstimator.LinkBandwidthEstimatorCallback; 102 import com.android.internal.telephony.data.PhoneSwitcher.PhoneSwitcherCallback; 103 import com.android.internal.telephony.data.TelephonyNetworkAgent.TelephonyNetworkAgentCallback; 104 import com.android.internal.telephony.flags.FeatureFlags; 105 import com.android.internal.telephony.metrics.DataCallSessionStats; 106 import com.android.internal.telephony.metrics.DataNetworkValidationStats; 107 import com.android.internal.telephony.metrics.TelephonyMetrics; 108 import com.android.internal.telephony.satellite.SatelliteController; 109 import com.android.internal.util.ArrayUtils; 110 import com.android.internal.util.FunctionalUtils; 111 import com.android.internal.util.IState; 112 import com.android.internal.util.State; 113 import com.android.internal.util.StateMachine; 114 import com.android.net.module.util.LinkPropertiesUtils; 115 import com.android.net.module.util.NetUtils; 116 import com.android.net.module.util.NetworkCapabilitiesUtils; 117 import com.android.telephony.Rlog; 118 119 import java.io.FileDescriptor; 120 import java.io.PrintWriter; 121 import java.math.BigInteger; 122 import java.net.InetAddress; 123 import java.util.ArrayList; 124 import java.util.Arrays; 125 import java.util.Collections; 126 import java.util.Comparator; 127 import java.util.HashSet; 128 import java.util.List; 129 import java.util.ListIterator; 130 import java.util.Map; 131 import java.util.Objects; 132 import java.util.Set; 133 import java.util.UUID; 134 import java.util.concurrent.Executor; 135 import java.util.concurrent.TimeUnit; 136 import java.util.function.Consumer; 137 import java.util.stream.Collectors; 138 139 /** 140 * DataNetwork class represents a single PDN (Packet Data Network). 141 * <p> 142 * The life cycle of a data network starts from {@link ConnectingState}. If setup data request 143 * succeeds, then it enters {@link ConnectedState}, otherwise it enters 144 * {@link DisconnectedState}. 145 * <p> 146 * When data network is in {@link ConnectingState}, it can enter {@link HandoverState} if handover 147 * between IWLAN and cellular occurs. After handover completes or fails, it return back to 148 * {@link ConnectedState}. When the data network is about to be disconnected, it first enters 149 * {@link DisconnectingState} when performing graceful tear down or when sending the data 150 * deactivation request. At the end, it enters {@link DisconnectedState} when {@link DataService} 151 * notifies data disconnected. Note that an unsolicited disconnected event from {@link DataService} 152 * or any vendor HAL failure response can immediately move data network from {@link ConnectedState} 153 * to {@link DisconnectedState}. {@link DisconnectedState} is the final state of a data network. 154 * <p> 155 * State machine diagram: 156 * <p> 157 * 158 * ┌─────────┐ 159 * │Handover │ 160 * └─▲────┬──┘ 161 * │ │ 162 * ┌───────────┐ ┌─┴────▼──┐ ┌──────────────┐ 163 * │Connecting ├────────►Connected├────────►Disconnecting │ 164 * └─────┬─────┘ └────┬────┘ └───────┬──────┘ 165 * │ │ │ 166 * │ ┌─────▼──────┐ │ 167 * └─────────────►Disconnected◄──────────────┘ 168 * └────────────┘ 169 * 170 */ 171 public class DataNetwork extends StateMachine { 172 private static final boolean VDBG = false; 173 /** Event for data config updated. */ 174 private static final int EVENT_DATA_CONFIG_UPDATED = 1; 175 176 /** Event for attaching a network request. */ 177 private static final int EVENT_ATTACH_NETWORK_REQUEST = 2; 178 179 /** Event for detaching a network request. */ 180 private static final int EVENT_DETACH_NETWORK_REQUEST = 3; 181 182 /** Event when detect radio not available. */ 183 private static final int EVENT_RADIO_NOT_AVAILABLE = 4; 184 185 /** Event for allocating PDU session id response. */ 186 private static final int EVENT_ALLOCATE_PDU_SESSION_ID_RESPONSE = 5; 187 188 /** Event for setup data network response. */ 189 private static final int EVENT_SETUP_DATA_NETWORK_RESPONSE = 6; 190 191 /** Event for tearing down data network. */ 192 private static final int EVENT_TEAR_DOWN_NETWORK = 7; 193 194 /** Event triggered by {@link DataServiceCallback#onDataCallListChanged(List)}. */ 195 private static final int EVENT_DATA_STATE_CHANGED = 8; 196 197 /** Data network service state changed event. */ 198 private static final int EVENT_SERVICE_STATE_CHANGED = 9; 199 200 /** Event for detaching all network requests. */ 201 private static final int EVENT_DETACH_ALL_NETWORK_REQUESTS = 10; 202 203 /** Event for bandwidth estimation from the modem changed. */ 204 private static final int EVENT_BANDWIDTH_ESTIMATE_FROM_MODEM_CHANGED = 11; 205 206 /** Event to report anomaly {@link #EVENT_NOTIFY_HANDOVER_CANCELLED_RESPONSE} not received. */ 207 private static final int EVENT_CANCEL_HANDOVER_NO_RESPONSE = 12; 208 209 /** Event for display info changed. This is for getting 5G NSA or mmwave information. */ 210 private static final int EVENT_DISPLAY_INFO_CHANGED = 13; 211 212 /** Event for setup data call (for handover) response from the data service. */ 213 private static final int EVENT_HANDOVER_RESPONSE = 15; 214 215 /** Event for subscription plan changed or unmetered/congested override set. */ 216 private static final int EVENT_SUBSCRIPTION_PLAN_OVERRIDE = 16; 217 218 /** Event for PCO data received from network. */ 219 private static final int EVENT_PCO_DATA_RECEIVED = 17; 220 221 /** Event for carrier privileged UIDs changed. */ 222 private static final int EVENT_CARRIER_PRIVILEGED_UIDS_CHANGED = 18; 223 224 /** Event for deactivate data network response. */ 225 private static final int EVENT_DEACTIVATE_DATA_NETWORK_RESPONSE = 19; 226 227 /** 228 * Event for data network stuck in transient (i.e. connecting/disconnecting/handover) state for 229 * too long time. Timeout value specified in 230 * {@link DataConfigManager#getAnomalyNetworkConnectingTimeoutMs()}, 231 * {@link DataConfigManager#getAnomalyNetworkDisconnectingTimeoutMs()}, 232 * {@link DataConfigManager#getNetworkHandoverTimeoutMs()}. 233 */ 234 private static final int EVENT_STUCK_IN_TRANSIENT_STATE = 20; 235 236 /** 237 * Event for waiting for tearing down condition met. This will cause data network entering 238 * disconnecting state. 239 */ 240 private static final int EVENT_WAITING_FOR_TEARING_DOWN_CONDITION_MET = 21; 241 242 /** Event for call started. */ 243 private static final int EVENT_VOICE_CALL_STARTED = 22; 244 245 /** Event for call ended. */ 246 private static final int EVENT_VOICE_CALL_ENDED = 23; 247 248 /** Event for CSS indicator changed. */ 249 private static final int EVENT_CSS_INDICATOR_CHANGED = 24; 250 251 /** 252 * Event for notifying source transport that handover is about to be initiated on target 253 * transport. 254 */ 255 private static final int EVENT_NOTIFY_HANDOVER_STARTED = 25; 256 257 /** 258 * Event for the response of notifying source transport that handover is about to be initiated 259 * on target transport. 260 */ 261 private static final int EVENT_NOTIFY_HANDOVER_STARTED_RESPONSE = 26; 262 263 /** 264 * Event for the response of notifying source transport that handover is cancelled/failed on the 265 * target transport. 266 */ 267 private static final int EVENT_NOTIFY_HANDOVER_CANCELLED_RESPONSE = 27; 268 269 /** Event for data network validation request from the AccessNetworksManager. */ 270 private static final int EVENT_DATA_NETWORK_VALIDATION_REQUESTED = 28; 271 272 /** Event for response to data network validation request. */ 273 private static final int EVENT_DATA_NETWORK_VALIDATION_RESPONSE = 29; 274 275 /** Event for preferred data subscription changed. */ 276 private static final int EVENT_PREFERRED_DATA_SUBSCRIPTION_CHANGED = 30; 277 278 /** Invalid context id. */ 279 private static final int INVALID_CID = -1; 280 281 @IntDef(prefix = {"TEAR_DOWN_REASON_"}, 282 value = { 283 TEAR_DOWN_REASON_NONE, 284 TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED, 285 TEAR_DOWN_REASON_SIM_REMOVAL, 286 TEAR_DOWN_REASON_AIRPLANE_MODE_ON, 287 TEAR_DOWN_REASON_DATA_DISABLED, 288 TEAR_DOWN_REASON_NO_LIVE_REQUEST, 289 TEAR_DOWN_REASON_RAT_NOT_ALLOWED, 290 TEAR_DOWN_REASON_ROAMING_DISABLED, 291 TEAR_DOWN_REASON_CONCURRENT_VOICE_DATA_NOT_ALLOWED, 292 TEAR_DOWN_REASON_SERVICE_OPTION_NOT_SUPPORTED, 293 TEAR_DOWN_REASON_DATA_SERVICE_NOT_READY, 294 TEAR_DOWN_REASON_POWER_OFF_BY_CARRIER, 295 TEAR_DOWN_REASON_DATA_STALL, 296 TEAR_DOWN_REASON_HANDOVER_FAILED, 297 TEAR_DOWN_REASON_HANDOVER_NOT_ALLOWED, 298 TEAR_DOWN_REASON_VCN_REQUESTED, 299 TEAR_DOWN_REASON_VOPS_NOT_SUPPORTED, 300 TEAR_DOWN_REASON_DEFAULT_DATA_UNSELECTED, 301 TEAR_DOWN_REASON_NOT_IN_SERVICE, 302 TEAR_DOWN_REASON_DATA_CONFIG_NOT_READY, 303 TEAR_DOWN_REASON_PENDING_TEAR_DOWN_ALL, 304 TEAR_DOWN_REASON_NO_SUITABLE_DATA_PROFILE, 305 TEAR_DOWN_REASON_CDMA_EMERGENCY_CALLBACK_MODE, 306 TEAR_DOWN_REASON_RETRY_SCHEDULED, 307 TEAR_DOWN_REASON_DATA_THROTTLED, 308 TEAR_DOWN_REASON_DATA_PROFILE_INVALID, 309 TEAR_DOWN_REASON_DATA_PROFILE_NOT_PREFERRED, 310 TEAR_DOWN_REASON_NOT_ALLOWED_BY_POLICY, 311 TEAR_DOWN_REASON_ILLEGAL_STATE, 312 TEAR_DOWN_REASON_ONLY_ALLOWED_SINGLE_NETWORK, 313 TEAR_DOWN_REASON_PREFERRED_DATA_SWITCHED, 314 TEAR_DOWN_REASON_DATA_LIMIT_REACHED, 315 TEAR_DOWN_REASON_DATA_NETWORK_TRANSPORT_NOT_ALLOWED, 316 }) 317 public @interface TearDownReason {} 318 319 /** Data network was not torn down. */ 320 public static final int TEAR_DOWN_REASON_NONE = 0; 321 322 /** Data network tear down requested by connectivity service. */ 323 public static final int TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED = 1; 324 325 /** Data network tear down due to SIM removal. */ 326 public static final int TEAR_DOWN_REASON_SIM_REMOVAL = 2; 327 328 /** Data network tear down due to airplane mode turned on. */ 329 public static final int TEAR_DOWN_REASON_AIRPLANE_MODE_ON = 3; 330 331 /** Data network tear down due to data disabled (by user, policy, carrier, etc...). */ 332 public static final int TEAR_DOWN_REASON_DATA_DISABLED = 4; 333 334 /** Data network tear down due to no live network request. */ 335 public static final int TEAR_DOWN_REASON_NO_LIVE_REQUEST = 5; 336 337 /** Data network tear down due to current RAT is not allowed by the data profile. */ 338 public static final int TEAR_DOWN_REASON_RAT_NOT_ALLOWED = 6; 339 340 /** Data network tear down due to data roaming not enabled. */ 341 public static final int TEAR_DOWN_REASON_ROAMING_DISABLED = 7; 342 343 /** Data network tear down due to concurrent voice/data not allowed. */ 344 public static final int TEAR_DOWN_REASON_CONCURRENT_VOICE_DATA_NOT_ALLOWED = 8; 345 346 /** Data network tear down due to service option is not supported. */ 347 public static final int TEAR_DOWN_REASON_SERVICE_OPTION_NOT_SUPPORTED = 9; 348 349 /** Data network tear down due to data service unbound. */ 350 public static final int TEAR_DOWN_REASON_DATA_SERVICE_NOT_READY = 10; 351 352 /** Data network tear down due to radio turned off by the carrier. */ 353 public static final int TEAR_DOWN_REASON_POWER_OFF_BY_CARRIER = 11; 354 355 /** Data network tear down due to data stall. */ 356 public static final int TEAR_DOWN_REASON_DATA_STALL = 12; 357 358 /** Data network tear down due to handover failed. */ 359 public static final int TEAR_DOWN_REASON_HANDOVER_FAILED = 13; 360 361 /** Data network tear down due to handover not allowed. */ 362 public static final int TEAR_DOWN_REASON_HANDOVER_NOT_ALLOWED = 14; 363 364 /** Data network tear down due to VCN service requested. */ 365 public static final int TEAR_DOWN_REASON_VCN_REQUESTED = 15; 366 367 /** Data network tear down due to VOPS no longer supported. */ 368 public static final int TEAR_DOWN_REASON_VOPS_NOT_SUPPORTED = 16; 369 370 /** Data network tear down due to default data unselected. */ 371 public static final int TEAR_DOWN_REASON_DEFAULT_DATA_UNSELECTED = 17; 372 373 /** Data network tear down due to device not in service. */ 374 public static final int TEAR_DOWN_REASON_NOT_IN_SERVICE = 18; 375 376 /** Data network tear down due to data config not ready. */ 377 public static final int TEAR_DOWN_REASON_DATA_CONFIG_NOT_READY = 19; 378 379 /** Data network tear down due to tear down all pending. */ 380 public static final int TEAR_DOWN_REASON_PENDING_TEAR_DOWN_ALL = 20; 381 382 /** Data network tear down due to no suitable data profile. */ 383 public static final int TEAR_DOWN_REASON_NO_SUITABLE_DATA_PROFILE = 21; 384 385 /** Data network tear down due to CDMA ECBM. */ 386 public static final int TEAR_DOWN_REASON_CDMA_EMERGENCY_CALLBACK_MODE = 22; 387 388 /** Data network tear down due to retry scheduled. */ 389 public static final int TEAR_DOWN_REASON_RETRY_SCHEDULED = 23; 390 391 /** Data network tear down due to data throttled. */ 392 public static final int TEAR_DOWN_REASON_DATA_THROTTLED = 24; 393 394 /** Data network tear down due to data profile invalid. */ 395 public static final int TEAR_DOWN_REASON_DATA_PROFILE_INVALID = 25; 396 397 /** Data network tear down due to data profile not preferred. */ 398 public static final int TEAR_DOWN_REASON_DATA_PROFILE_NOT_PREFERRED = 26; 399 400 /** Data network tear down due to handover not allowed by policy. */ 401 public static final int TEAR_DOWN_REASON_NOT_ALLOWED_BY_POLICY = 27; 402 403 /** Data network tear down due to illegal state. */ 404 public static final int TEAR_DOWN_REASON_ILLEGAL_STATE = 28; 405 406 /** Data network tear down due to only allowed single network. */ 407 public static final int TEAR_DOWN_REASON_ONLY_ALLOWED_SINGLE_NETWORK = 29; 408 409 /** Data network tear down due to preferred data switched to another phone. */ 410 public static final int TEAR_DOWN_REASON_PREFERRED_DATA_SWITCHED = 30; 411 412 /** Data network tear down due to bootstrap sim data limit reached. */ 413 public static final int TEAR_DOWN_REASON_DATA_LIMIT_REACHED = 31; 414 415 /** Data network tear down due to current data network transport mismatch. */ 416 public static final int TEAR_DOWN_REASON_DATA_NETWORK_TRANSPORT_NOT_ALLOWED = 32; 417 418 //********************************************************************************************// 419 // WHENEVER ADD A NEW TEAR DOWN REASON, PLEASE UPDATE DataDeactivateReasonEnum in enums.proto // 420 //********************************************************************************************// 421 422 @IntDef(prefix = {"BANDWIDTH_SOURCE_"}, 423 value = { 424 BANDWIDTH_SOURCE_UNKNOWN, 425 BANDWIDTH_SOURCE_MODEM, 426 BANDWIDTH_SOURCE_CARRIER_CONFIG, 427 BANDWIDTH_SOURCE_BANDWIDTH_ESTIMATOR, 428 }) 429 public @interface BandwidthEstimationSource {} 430 431 /** Indicates the bandwidth estimation source is unknown. This must be a configuration error. */ 432 public static final int BANDWIDTH_SOURCE_UNKNOWN = 0; 433 434 /** Indicates the bandwidth estimation source is from the modem. */ 435 public static final int BANDWIDTH_SOURCE_MODEM = 1; 436 437 /** Indicates the bandwidth estimation source is from the static carrier config. */ 438 public static final int BANDWIDTH_SOURCE_CARRIER_CONFIG = 2; 439 440 /** Indicates the bandwidth estimation source is from {@link LinkBandwidthEstimator}. */ 441 public static final int BANDWIDTH_SOURCE_BANDWIDTH_ESTIMATOR = 3; 442 443 /** 444 * The capabilities that are allowed to changed dynamically during the life cycle of network. 445 * This is copied from {@code NetworkCapabilities#MUTABLE_CAPABILITIES}. There is no plan to 446 * make this a connectivity manager API since in the future, immutable network capabilities 447 * would be allowed to changed dynamically. (i.e. not immutable anymore.) 448 */ 449 private static final List<Integer> MUTABLE_CAPABILITIES = List.of( 450 NetworkCapabilities.NET_CAPABILITY_TRUSTED, 451 NetworkCapabilities.NET_CAPABILITY_VALIDATED, 452 NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL, 453 NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING, 454 NetworkCapabilities.NET_CAPABILITY_FOREGROUND, 455 NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED, 456 NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED, 457 NetworkCapabilities.NET_CAPABILITY_PARTIAL_CONNECTIVITY, 458 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED, 459 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED, 460 NetworkCapabilities.NET_CAPABILITY_HEAD_UNIT, 461 // Connectivity service will support NOT_METERED as a mutable and requestable 462 // capability. 463 NetworkCapabilities.NET_CAPABILITY_NOT_METERED, 464 // Dynamically add and remove MMTEL capability when network transition between VoPS 465 // and non-VoPS network if the request is not MMTEL. For MMTEL, we retain the capability 466 // to prevent immediate tear down. 467 NetworkCapabilities.NET_CAPABILITY_MMTEL, 468 // Dynamically add and remove MMS capability depending on QNS's preference if there is 469 // a transport specific APN alternative. 470 NetworkCapabilities.NET_CAPABILITY_MMS 471 ); 472 473 /** The parent state. Any messages not handled by the child state fallback to this. */ 474 private final DefaultState mDefaultState = new DefaultState(); 475 476 /** 477 * The connecting state. This is the initial state of a data network. 478 * 479 * @see DataNetwork for the state machine diagram. 480 */ 481 private final ConnectingState mConnectingState = new ConnectingState(); 482 483 /** 484 * The connected state. This is the state when data network becomes usable. 485 * 486 * @see DataNetwork for the state machine diagram. 487 */ 488 private final ConnectedState mConnectedState = new ConnectedState(); 489 490 /** 491 * The handover state. This is the state when data network handover between IWLAN and cellular. 492 * 493 * @see DataNetwork for the state machine diagram. 494 */ 495 private final HandoverState mHandoverState = new HandoverState(); 496 497 /** 498 * The disconnecting state. This is the state when data network is about to be disconnected. 499 * The network is still usable in this state, but the clients should be prepared to lose the 500 * network in any moment. This state is particular useful for IMS graceful tear down, where 501 * the network enters disconnecting state while waiting for IMS de-registration signal. 502 * 503 * @see DataNetwork for the state machine diagram. 504 */ 505 private final DisconnectingState mDisconnectingState = new DisconnectingState(); 506 507 /** 508 * The disconnected state. This is the final state of a data network. 509 * 510 * @see DataNetwork for the state machine diagram. 511 */ 512 private final DisconnectedState mDisconnectedState = new DisconnectedState(); 513 514 /** The phone instance. */ 515 @NonNull 516 private final Phone mPhone; 517 518 /** Feature flags */ 519 @NonNull 520 private final FeatureFlags mFlags; 521 522 /** 523 * The subscription id. This is assigned when the network is created, and not supposed to 524 * change afterwards. 525 */ 526 private final int mSubId; 527 528 /** The network score of this network. */ 529 @NonNull 530 private NetworkScore mNetworkScore; 531 532 /** 533 * Indicates that 534 * {@link DataService.DataServiceProvider#deactivateDataCall(int, int, DataServiceCallback)} 535 * has been called. This flag can be only changed from {@code false} to {@code true}. 536 */ 537 private boolean mInvokedDataDeactivation = false; 538 539 /** 540 * Indicates that if the data network has ever entered {@link ConnectedState}. 541 */ 542 private boolean mEverConnected = false; 543 544 /** RIL interface. */ 545 @NonNull 546 private final CommandsInterface mRil; 547 548 /** Local log. */ 549 private final LocalLog mLocalLog = new LocalLog(128); 550 551 /** The callback to receives data network state update. */ 552 @NonNull 553 private final DataNetworkCallback mDataNetworkCallback; 554 555 /** The log tag. */ 556 private String mLogTag; 557 558 /** Metrics of per data network connection. */ 559 private final DataCallSessionStats mDataCallSessionStats; 560 561 /** Metrics of per data network validation. */ 562 @NonNull 563 private final DataNetworkValidationStats mDataNetworkValidationStats; 564 565 /** 566 * The unique context id assigned by the data service in {@link DataCallResponse#getId()}. One 567 * for {@link AccessNetworkConstants#TRANSPORT_TYPE_WWAN} and one for 568 * {@link AccessNetworkConstants#TRANSPORT_TYPE_WLAN}. The reason for storing both is that 569 * during handover, both cid will be used. 570 */ 571 private final SparseIntArray mCid = new SparseIntArray(2); 572 573 /** 574 * The initial network agent id. The network agent can be re-created due to immutable capability 575 * changed. This is to preserve the initial network agent id so the id in the logging tag won't 576 * change for the entire life cycle of data network. 577 */ 578 private int mInitialNetworkAgentId; 579 580 /** PDU session id. */ 581 private int mPduSessionId = DataCallResponse.PDU_SESSION_ID_NOT_SET; 582 583 /** 584 * Data service managers for accessing {@link AccessNetworkConstants#TRANSPORT_TYPE_WWAN} and 585 * {@link AccessNetworkConstants#TRANSPORT_TYPE_WLAN} data services. 586 */ 587 @NonNull 588 private final SparseArray<DataServiceManager> mDataServiceManagers; 589 590 /** Access networks manager. */ 591 @NonNull 592 private final AccessNetworksManager mAccessNetworksManager; 593 594 /** Data network controller. */ 595 @NonNull 596 private final DataNetworkController mDataNetworkController; 597 598 /** Phone switcher which is responsible to determine which phone to route network request. */ 599 @NonNull 600 private final PhoneSwitcher mPhoneSwitcher; 601 602 /** Data network controller callback. */ 603 @NonNull 604 private final DataNetworkController.DataNetworkControllerCallback 605 mDataNetworkControllerCallback; 606 607 /** Data settings manager callback. */ 608 @NonNull 609 private DataSettingsManagerCallback mDataSettingsManagerCallback; 610 611 /** Data config manager. */ 612 @NonNull 613 private final DataConfigManager mDataConfigManager; 614 615 /** VCN manager. */ 616 @Nullable 617 private final VcnManager mVcnManager; 618 619 /** VCN policy changed listener. */ 620 @Nullable 621 private VcnNetworkPolicyChangeListener mVcnPolicyChangeListener; 622 623 /** The network agent associated with this data network. */ 624 @NonNull 625 private TelephonyNetworkAgent mNetworkAgent; 626 627 /** QOS callback tracker. This is only created after network connected on WWAN. */ 628 @Nullable 629 private QosCallbackTracker mQosCallbackTracker; 630 631 /** NAT keepalive tracker. */ 632 @Nullable 633 private KeepaliveTracker mKeepaliveTracker; 634 635 /** The data profile used to establish this data network. */ 636 @NonNull 637 private DataProfile mDataProfile; 638 639 /** 640 * The data profile used for data handover. Some carriers might use different data profile 641 * between IWLAN and cellular. Only set before handover started. 642 */ 643 @Nullable 644 private DataProfile mHandoverDataProfile; 645 646 /** The network capabilities of this data network. */ 647 @NonNull 648 private NetworkCapabilities mNetworkCapabilities; 649 650 /** The matched traffic descriptor returned from setup data call request. */ 651 @NonNull 652 private final List<TrafficDescriptor> mTrafficDescriptors = new ArrayList<>(); 653 654 /** The link properties of this data network. */ 655 @NonNull 656 private LinkProperties mLinkProperties; 657 658 /** The network slice info. */ 659 @Nullable 660 private NetworkSliceInfo mNetworkSliceInfo; 661 662 /** The link status (i.e. RRC state). */ 663 @LinkStatus 664 private int mLinkStatus = DataCallResponse.LINK_STATUS_UNKNOWN; 665 666 /** The network bandwidth. */ 667 @NonNull 668 private NetworkBandwidth mNetworkBandwidth = new NetworkBandwidth(14, 14); 669 670 /** The TCP buffer sizes config. */ 671 @NonNull 672 private String mTcpBufferSizes; 673 674 /** The telephony display info. */ 675 @NonNull 676 private TelephonyDisplayInfo mTelephonyDisplayInfo; 677 678 /** Whether {@link NetworkCapabilities#NET_CAPABILITY_TEMPORARILY_NOT_METERED} is supported. */ 679 private boolean mTempNotMeteredSupported = false; 680 681 /** Whether the current data network is temporarily not metered. */ 682 private boolean mTempNotMetered = false; 683 684 /** Whether the current data network is congested. */ 685 private boolean mCongested = false; 686 687 /** 688 * Whether the current data network is on preferred data modem. 689 * 690 * @see PhoneSwitcher#getPreferredDataPhoneId() 691 */ 692 private boolean mOnPreferredDataPhone; 693 694 /** The network requests associated with this data network */ 695 @NonNull 696 private final NetworkRequestList mAttachedNetworkRequestList = 697 new NetworkRequestList(); 698 699 /** 700 * The latest data call response received from either 701 * {@link DataServiceCallback#onSetupDataCallComplete(int, DataCallResponse)} or 702 * {@link DataServiceCallback#onDataCallListChanged(List)}. The very first update must be 703 * from {@link DataServiceCallback#onSetupDataCallComplete(int, DataCallResponse)}. 704 */ 705 @Nullable 706 private DataCallResponse mDataCallResponse = null; 707 708 /** 709 * The fail cause from either setup data failure or unsolicited disconnect reported by data 710 * service. 711 */ 712 @DataFailureCause 713 private int mFailCause = DataFailCause.NONE; 714 715 /** 716 * The tear down reason if the data call is voluntarily deactivated, not due to failure. 717 */ 718 @TearDownReason 719 private int mTearDownReason = TEAR_DOWN_REASON_NONE; 720 721 /** 722 * The retry delay in milliseconds from setup data failure. 723 */ 724 private long mRetryDelayMillis = DataCallResponse.RETRY_DURATION_UNDEFINED; 725 726 /** 727 * Indicates if data network is suspended. Note this is slightly different from the 728 * {@link TelephonyManager#DATA_SUSPENDED}, which is only possible when data network is in 729 * connected state. This flag reflects to the 730 * {@link NetworkCapabilities#NET_CAPABILITY_NOT_SUSPENDED} which can happen when data network 731 * is in connected or disconnecting state. 732 */ 733 private boolean mSuspended = false; 734 735 /** 736 * The current transport of the data network. For handover, the current transport will be set 737 * after handover completes. 738 */ 739 @TransportType 740 private int mTransport; 741 742 /** 743 * The last known data network type. 744 */ 745 @NetworkType 746 private int mLastKnownDataNetworkType; 747 748 /** 749 * The last known roaming state of this data network. 750 */ 751 private boolean mLastKnownRoamingState; 752 753 /** 754 * The non-terrestrial status 755 */ 756 private final boolean mIsSatellite; 757 758 /** The reason that why setting up this data network is allowed. */ 759 @NonNull 760 private final DataAllowedReason mDataAllowedReason; 761 762 /** 763 * PCO (Protocol Configuration Options) data received from the network. The first key is the 764 * cid of the PCO data, the second key is the PCO id, the value is the PCO data. 765 */ 766 @NonNull 767 private final Map<Integer, Map<Integer, PcoData>> mPcoData = new ArrayMap<>(); 768 769 /** The QOS bearer sessions. */ 770 @NonNull 771 private final List<QosBearerSession> mQosBearerSessions = new ArrayList<>(); 772 773 /** The QOS for the Default Bearer, should be non-null on LTE and NR */ 774 @Nullable 775 private Qos mDefaultQos; 776 777 /** 778 * The UIDs of packages that have carrier privilege. 779 */ 780 @NonNull 781 private int[] mAdministratorUids = new int[0]; 782 783 /** Carrier privileges callback to monitor administrator UID change. */ 784 @Nullable 785 private TelephonyManager.CarrierPrivilegesCallback mCarrierPrivilegesCallback; 786 787 /** 788 * Carrier service package uid. This UID will not change through the life cycle of data network. 789 */ 790 private int mCarrierServicePackageUid = Process.INVALID_UID; 791 792 /** 793 * Link bandwidth estimator callback for receiving latest link bandwidth information. 794 */ 795 @Nullable 796 private LinkBandwidthEstimatorCallback mLinkBandwidthEstimatorCallback; 797 798 /** 799 * Data config callback for carrier config update. 800 */ 801 @Nullable 802 private DataConfigManagerCallback mDataConfigManagerCallback; 803 804 /** 805 * Network validation status for this data network. If the data service provider does not 806 * support the network validation feature, should be UNSUPPORTED. 807 */ 808 @PreciseDataConnectionState.NetworkValidationStatus 809 private int mNetworkValidationStatus = 810 PreciseDataConnectionState.NETWORK_VALIDATION_UNSUPPORTED; 811 812 /** 813 * Callback used to respond to a network validation request to determine whether the request is 814 * successfully submitted. If the request has been submitted, change it to null. 815 */ 816 @Nullable 817 private Consumer<Integer> mNetworkValidationResultCodeCallback; 818 819 /** 820 * Callback used to listen QNS preference changes. 821 */ 822 @Nullable 823 private AccessNetworksManagerCallback mAccessNetworksManagerCallback; 824 825 /** 826 * PreciseDataConnectionState, the most recently notified. If it has never been notified, it is 827 * null. 828 */ 829 @Nullable 830 private PreciseDataConnectionState mPreciseDataConnectionState; 831 832 /** 833 * Callback to listen event from {@link PhoneSwitcher}. 834 */ 835 @NonNull 836 private PhoneSwitcherCallback mPhoneSwitcherCallback; 837 838 /** 839 * The network bandwidth. 840 */ 841 public static class NetworkBandwidth { 842 /** The downlink bandwidth in Kbps. */ 843 public final int downlinkBandwidthKbps; 844 845 /** The uplink Bandwidth in Kbps. */ 846 public final int uplinkBandwidthKbps; 847 848 /** 849 * Constructor. 850 * 851 * @param downlinkBandwidthKbps The downlink bandwidth in Kbps. 852 * @param uplinkBandwidthKbps The uplink Bandwidth in Kbps. 853 */ NetworkBandwidth(int downlinkBandwidthKbps, int uplinkBandwidthKbps)854 public NetworkBandwidth(int downlinkBandwidthKbps, int uplinkBandwidthKbps) { 855 this.downlinkBandwidthKbps = downlinkBandwidthKbps; 856 this.uplinkBandwidthKbps = uplinkBandwidthKbps; 857 } 858 859 @Override toString()860 public String toString() { 861 return String.format("NetworkBandwidth=[downlink=%d, uplink=%d]", 862 downlinkBandwidthKbps, uplinkBandwidthKbps); 863 } 864 } 865 866 /** 867 * Data network callback. Should only be used by {@link DataNetworkController}. 868 */ 869 public abstract static class DataNetworkCallback extends DataCallback { 870 /** 871 * Constructor 872 * 873 * @param executor The executor of the callback. 874 */ DataNetworkCallback(@onNull @allbackExecutor Executor executor)875 public DataNetworkCallback(@NonNull @CallbackExecutor Executor executor) { 876 super(executor); 877 } 878 879 /** 880 * Called when data setup failed. 881 * 882 * @param dataNetwork The data network. 883 * @param requestList The network requests attached to this data network. 884 * @param cause The fail cause of setup data network. 885 * @param retryDurationMillis The network suggested data retry duration in milliseconds as 886 * specified in 3GPP TS 24.302 section 8.2.9.1. The {@link DataProfile} associated to this 887 * data network will be throttled for the specified duration unless 888 * {@link DataServiceCallback#onApnUnthrottled} is called. {@link Long#MAX_VALUE} indicates 889 * data retry should not occur. {@link DataCallResponse#RETRY_DURATION_UNDEFINED} indicates 890 * network did not suggest any retry duration. 891 */ onSetupDataFailed(@onNull DataNetwork dataNetwork, @NonNull NetworkRequestList requestList, @DataFailureCause int cause, long retryDurationMillis)892 public abstract void onSetupDataFailed(@NonNull DataNetwork dataNetwork, 893 @NonNull NetworkRequestList requestList, @DataFailureCause int cause, 894 long retryDurationMillis); 895 896 /** 897 * Called when data network enters {@link ConnectedState}. 898 * 899 * @param dataNetwork The data network. 900 */ onConnected(@onNull DataNetwork dataNetwork)901 public abstract void onConnected(@NonNull DataNetwork dataNetwork); 902 903 /** 904 * Called when data network validation status changed. 905 * 906 * @param dataNetwork The data network. 907 * @param status one of {@link NetworkAgent#VALIDATION_STATUS_VALID} or 908 * {@link NetworkAgent#VALIDATION_STATUS_NOT_VALID}. 909 * @param redirectUri If internet connectivity is being redirected (e.g., on a captive 910 * portal), this is the destination the probes are being redirected to, otherwise 911 * {@code null}. 912 */ onValidationStatusChanged(@onNull DataNetwork dataNetwork, @ValidationStatus int status, @Nullable Uri redirectUri)913 public abstract void onValidationStatusChanged(@NonNull DataNetwork dataNetwork, 914 @ValidationStatus int status, @Nullable Uri redirectUri); 915 916 /** 917 * Called when data network suspended state changed. 918 * 919 * @param dataNetwork The data network. 920 * @param suspended {@code true} if data is suspended. 921 */ onSuspendedStateChanged(@onNull DataNetwork dataNetwork, boolean suspended)922 public abstract void onSuspendedStateChanged(@NonNull DataNetwork dataNetwork, 923 boolean suspended); 924 925 /** 926 * Called when network requests were failed to attach to the data network. 927 * 928 * @param dataNetwork The data network. 929 * @param requestList The requests failed to attach. 930 */ onAttachFailed(@onNull DataNetwork dataNetwork, @NonNull NetworkRequestList requestList)931 public abstract void onAttachFailed(@NonNull DataNetwork dataNetwork, 932 @NonNull NetworkRequestList requestList); 933 934 /** 935 * Called when data network enters {@link DisconnectedState}. Note this is only called 936 * when the data network was previously connected. For setup data network failed, 937 * {@link #onSetupDataFailed(DataNetwork, NetworkRequestList, int, long)} is called. 938 * 939 * @param dataNetwork The data network. 940 * @param cause The disconnect cause. 941 * @param tearDownReason The reason the network was torn down 942 */ onDisconnected(@onNull DataNetwork dataNetwork, @DataFailureCause int cause, @TearDownReason int tearDownReason)943 public abstract void onDisconnected(@NonNull DataNetwork dataNetwork, 944 @DataFailureCause int cause, @TearDownReason int tearDownReason); 945 946 /** 947 * Called when handover between IWLAN and cellular network succeeded. 948 * 949 * @param dataNetwork The data network. 950 */ onHandoverSucceeded(@onNull DataNetwork dataNetwork)951 public abstract void onHandoverSucceeded(@NonNull DataNetwork dataNetwork); 952 953 /** 954 * Called when data network handover between IWLAN and cellular network failed. 955 * 956 * @param dataNetwork The data network. 957 * @param cause The fail cause. 958 * @param retryDurationMillis Network suggested retry time in milliseconds. 959 * {@link Long#MAX_VALUE} indicates data retry should not occur. 960 * {@link DataCallResponse#RETRY_DURATION_UNDEFINED} indicates network did not suggest any 961 * retry duration. 962 * @param handoverFailureMode The handover failure mode that determine the behavior of 963 * how frameworks should handle the handover failure. 964 */ onHandoverFailed(@onNull DataNetwork dataNetwork, @DataFailureCause int cause, long retryDurationMillis, @HandoverFailureMode int handoverFailureMode)965 public abstract void onHandoverFailed(@NonNull DataNetwork dataNetwork, 966 @DataFailureCause int cause, long retryDurationMillis, 967 @HandoverFailureMode int handoverFailureMode); 968 969 /** 970 * Called when data network link status (i.e. RRC state) changed. 971 * 972 * @param dataNetwork The data network. 973 * @param linkStatus The link status (i.e. RRC state). 974 */ onLinkStatusChanged(@onNull DataNetwork dataNetwork, @LinkStatus int linkStatus)975 public abstract void onLinkStatusChanged(@NonNull DataNetwork dataNetwork, 976 @LinkStatus int linkStatus); 977 978 /** 979 * Called when PCO data changed. 980 * 981 * @param dataNetwork The data network. 982 */ onPcoDataChanged(@onNull DataNetwork dataNetwork)983 public abstract void onPcoDataChanged(@NonNull DataNetwork dataNetwork); 984 985 /** 986 * Called when network capabilities changed. 987 * 988 * @param dataNetwork The data network. 989 */ onNetworkCapabilitiesChanged(@onNull DataNetwork dataNetwork)990 public abstract void onNetworkCapabilitiesChanged(@NonNull DataNetwork dataNetwork); 991 992 /** 993 * Called when attempt to tear down a data network 994 * 995 * @param dataNetwork The data network. 996 */ onTrackNetworkUnwanted(@onNull DataNetwork dataNetwork)997 public abstract void onTrackNetworkUnwanted(@NonNull DataNetwork dataNetwork); 998 999 /** 1000 * Called when a network request is detached after no longer satisfied. 1001 * 1002 * @param networkRequest The detached network request. 1003 */ onRetryUnsatisfiedNetworkRequest( @onNull TelephonyNetworkRequest networkRequest)1004 public abstract void onRetryUnsatisfiedNetworkRequest( 1005 @NonNull TelephonyNetworkRequest networkRequest); 1006 1007 /** 1008 * Called when QosBearerSessions bearer changed, which indicates VoNr or VoLte calls. 1009 * 1010 * @param qosBearerSessions The current qosBearerSessions. 1011 */ onQosSessionsChanged( @onNull List<QosBearerSession> qosBearerSessions)1012 public abstract void onQosSessionsChanged( 1013 @NonNull List<QosBearerSession> qosBearerSessions); 1014 } 1015 1016 /** 1017 * Constructor 1018 * 1019 * @param phone The phone instance. 1020 * @param looper The looper to be used by the state machine. Currently the handler thread is the 1021 * phone process's main thread. 1022 * @param dataServiceManagers Data service managers. 1023 * @param dataProfile The data profile for establishing the data network. 1024 * @param networkRequestList The initial network requests attached to this data network. 1025 * @param transport The initial transport of the data network. 1026 * @param dataAllowedReason The reason that why setting up this data network is allowed. 1027 * @param callback The callback to receives data network state update. 1028 */ DataNetwork(@onNull Phone phone, FeatureFlags featureFlags, @NonNull Looper looper, @NonNull SparseArray<DataServiceManager> dataServiceManagers, @NonNull DataProfile dataProfile, @NonNull NetworkRequestList networkRequestList, @TransportType int transport, @NonNull DataAllowedReason dataAllowedReason, @NonNull DataNetworkCallback callback)1029 public DataNetwork(@NonNull Phone phone, FeatureFlags featureFlags, @NonNull Looper looper, 1030 @NonNull SparseArray<DataServiceManager> dataServiceManagers, 1031 @NonNull DataProfile dataProfile, 1032 @NonNull NetworkRequestList networkRequestList, 1033 @TransportType int transport, 1034 @NonNull DataAllowedReason dataAllowedReason, 1035 @NonNull DataNetworkCallback callback) { 1036 super("DataNetwork", looper); 1037 // State machine should be initialized at the top of constructor. log() can be only used 1038 // after state machine initialized (because getCurrentState() crashes if state machine has 1039 // not started.) 1040 initializeStateMachine(); 1041 1042 mPhone = phone; 1043 mFlags = featureFlags; 1044 mSubId = phone.getSubId(); 1045 mRil = mPhone.mCi; 1046 mLinkProperties = new LinkProperties(); 1047 mDataServiceManagers = dataServiceManagers; 1048 mAccessNetworksManager = phone.getAccessNetworksManager(); 1049 mVcnManager = mPhone.getContext().getSystemService(VcnManager.class); 1050 mDataNetworkController = phone.getDataNetworkController(); 1051 mPhoneSwitcher = PhoneSwitcher.getInstance(); 1052 mOnPreferredDataPhone = phone.getPhoneId() == mPhoneSwitcher.getPreferredDataPhoneId(); 1053 mDataNetworkControllerCallback = new DataNetworkController.DataNetworkControllerCallback( 1054 getHandler()::post) { 1055 @Override 1056 public void onSubscriptionPlanOverride() { 1057 sendMessage(EVENT_SUBSCRIPTION_PLAN_OVERRIDE); 1058 }}; 1059 mDataNetworkController.registerDataNetworkControllerCallback( 1060 mDataNetworkControllerCallback); 1061 mDataConfigManager = mDataNetworkController.getDataConfigManager(); 1062 mDataCallSessionStats = new DataCallSessionStats(mPhone); 1063 mDataNetworkValidationStats = new DataNetworkValidationStats(mPhone); 1064 mDataNetworkCallback = callback; 1065 mDataProfile = dataProfile; 1066 if (dataProfile.getTrafficDescriptor() != null) { 1067 // The initial traffic descriptor is from the data profile. After that traffic 1068 // descriptors will be updated by modem through setup data call response and data call 1069 // list changed event. 1070 mTrafficDescriptors.add(dataProfile.getTrafficDescriptor()); 1071 } 1072 mTransport = transport; 1073 mLastKnownDataNetworkType = getDataNetworkType(); 1074 mLastKnownRoamingState = mPhone.getServiceState().getDataRoamingFromRegistration(); 1075 mIsSatellite = mPhone.getServiceState().isUsingNonTerrestrialNetwork() 1076 && transport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN; 1077 mDataAllowedReason = dataAllowedReason; 1078 dataProfile.setLastSetupTimestamp(SystemClock.elapsedRealtime()); 1079 for (int transportType : mAccessNetworksManager.getAvailableTransports()) { 1080 mCid.put(transportType, INVALID_CID); 1081 } 1082 mTelephonyDisplayInfo = mPhone.getDisplayInfoController().getTelephonyDisplayInfo(); 1083 mTcpBufferSizes = mDataConfigManager.getTcpConfigString(mTelephonyDisplayInfo); 1084 1085 // network capabilities infer connectivity transport and MMTEL from the requested 1086 // capabilities. 1087 // TODO: Ideally we shouldn't infer network capabilities base on the requested capabilities, 1088 // but currently there are 2 hacks associated with getForcedCellularTransportCapabilities 1089 // and IMS service requesting IMS|MMTEL that need to support. When we stop supporting these 1090 // cases, we shouldn't consider the requests when determining the network capabilities. 1091 mAttachedNetworkRequestList.addAll(networkRequestList); 1092 // Update the capabilities in the constructor is to make sure the data network has initial 1093 // capability immediately after created. Doing this connecting state creates the window that 1094 // DataNetworkController might check if existing data network's capability can satisfy the 1095 // next network request within this window. 1096 updateNetworkCapabilities(); 1097 1098 // Remove the requests that can't use the initial capabilities 1099 ListIterator<TelephonyNetworkRequest> iter = mAttachedNetworkRequestList.listIterator(); 1100 while (iter.hasNext()) { 1101 TelephonyNetworkRequest request = iter.next(); 1102 if (request.canBeSatisfiedBy(mNetworkCapabilities)) { 1103 request.setAttachedNetwork(DataNetwork.this); 1104 request.setState(TelephonyNetworkRequest.REQUEST_STATE_SATISFIED); 1105 } else { 1106 iter.remove(); 1107 } 1108 } 1109 } 1110 1111 /** 1112 * Initialize and start the state machine. 1113 */ initializeStateMachine()1114 private void initializeStateMachine() { 1115 addState(mDefaultState); 1116 addState(mConnectingState, mDefaultState); 1117 addState(mConnectedState, mDefaultState); 1118 addState(mHandoverState, mDefaultState); 1119 addState(mDisconnectingState, mDefaultState); 1120 addState(mDisconnectedState, mDefaultState); 1121 setInitialState(mConnectingState); 1122 start(); 1123 } 1124 1125 /** 1126 * @return {@code true} if 464xlat should be skipped. 1127 */ shouldSkip464Xlat()1128 private boolean shouldSkip464Xlat() { 1129 if (mDataProfile.getApnSetting() != null) { 1130 switch (mDataProfile.getApnSetting().getSkip464Xlat()) { 1131 case Telephony.Carriers.SKIP_464XLAT_ENABLE: 1132 return true; 1133 case Telephony.Carriers.SKIP_464XLAT_DISABLE: 1134 return false; 1135 case Telephony.Carriers.SKIP_464XLAT_DEFAULT: 1136 default: 1137 break; 1138 } 1139 } 1140 1141 // As default, return true if ims and no internet 1142 final NetworkCapabilities nc = getNetworkCapabilities(); 1143 return nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS) 1144 && !nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1145 } 1146 1147 /** 1148 * Create the telephony network agent. 1149 * 1150 * @return The telephony network agent. 1151 */ 1152 @NonNull createNetworkAgent()1153 private TelephonyNetworkAgent createNetworkAgent() { 1154 final NetworkAgentConfig.Builder configBuilder = new NetworkAgentConfig.Builder(); 1155 configBuilder.setLegacyType(ConnectivityManager.TYPE_MOBILE); 1156 configBuilder.setLegacyTypeName("MOBILE"); 1157 int networkType = getDataNetworkType(); 1158 configBuilder.setLegacySubType(networkType); 1159 configBuilder.setLegacySubTypeName(TelephonyManager.getNetworkTypeName(networkType)); 1160 if (mDataProfile.getApnSetting() != null) { 1161 configBuilder.setLegacyExtraInfo(mDataProfile.getApnSetting().getApnName()); 1162 } 1163 1164 final CarrierSignalAgent carrierSignalAgent = mPhone.getCarrierSignalAgent(); 1165 if (carrierSignalAgent.hasRegisteredReceivers(TelephonyManager 1166 .ACTION_CARRIER_SIGNAL_REDIRECTED)) { 1167 // carrierSignal Receivers will place the carrier-specific provisioning notification 1168 configBuilder.setProvisioningNotificationEnabled(false); 1169 } 1170 1171 // Fill the IMSI 1172 final String subscriberId = mPhone.getSubscriberId(); 1173 if (!TextUtils.isEmpty(subscriberId)) { 1174 configBuilder.setSubscriberId(subscriberId); 1175 } 1176 1177 // set skip464xlat if it is not default otherwise 1178 if (shouldSkip464Xlat()) { 1179 configBuilder.setNat64DetectionEnabled(false); 1180 } 1181 1182 NetworkProvider provider; 1183 provider = PhoneFactory.getNetworkProvider(); 1184 1185 NetworkScore.Builder builder = new NetworkScore.Builder() 1186 .setKeepConnectedReason(isHandoverInProgress() 1187 ? NetworkScore.KEEP_CONNECTED_FOR_HANDOVER 1188 : NetworkScore.KEEP_CONNECTED_NONE); 1189 builder.setTransportPrimary(mOnPreferredDataPhone); 1190 mNetworkScore = builder.build(); 1191 logl("mNetworkScore: isPrimary=" + mNetworkScore.isTransportPrimary() 1192 + ", keepConnectedReason=" + mNetworkScore.getKeepConnectedReason()); 1193 1194 return new TelephonyNetworkAgent(mPhone, getHandler().getLooper(), this, 1195 mNetworkScore, configBuilder.build(), provider, 1196 new TelephonyNetworkAgentCallback(getHandler()::post) { 1197 @Override 1198 public void onValidationStatus(@ValidationStatus int status, 1199 @Nullable Uri redirectUri) { 1200 mDataNetworkCallback.invokeFromExecutor( 1201 () -> mDataNetworkCallback.onValidationStatusChanged( 1202 DataNetwork.this, status, redirectUri)); 1203 } 1204 }); 1205 } 1206 1207 /** 1208 * The default state. Any events that were not handled by the child states fallback to this 1209 * state. 1210 * 1211 * @see DataNetwork for the state machine diagram. 1212 */ 1213 private final class DefaultState extends State { 1214 @Override 1215 public void enter() { 1216 logv("Registering all events."); 1217 mDataConfigManagerCallback = new DataConfigManagerCallback(getHandler()::post) { 1218 @Override 1219 public void onCarrierConfigChanged() { 1220 sendMessage(EVENT_DATA_CONFIG_UPDATED); 1221 } 1222 }; 1223 mRil.registerForPcoData(getHandler(), EVENT_PCO_DATA_RECEIVED, null); 1224 1225 mDataConfigManager.registerCallback(mDataConfigManagerCallback); 1226 1227 mDataSettingsManagerCallback = new DataSettingsManagerCallback(getHandler()::post) { 1228 @Override 1229 public void onDataEnabledChanged(boolean enabled, 1230 @TelephonyManager.DataEnabledChangedReason int reason, 1231 @NonNull String callingPackage) { 1232 if (enabled) { 1233 // The NOT_RESTRICTED capability might be changed after data enabled. We 1234 // need to update the capabilities again. 1235 log("Data enabled. update network capabilities."); 1236 updateNetworkCapabilities(); 1237 } 1238 } 1239 1240 @Override 1241 public void onDataRoamingEnabledChanged(boolean enabled) { 1242 if (enabled) { 1243 // The NOT_RESTRICTED capability might be changed after data roaming 1244 // enabled. We need to update the capabilities again. 1245 log("Data roaming enabled. update network capabilities."); 1246 updateNetworkCapabilities(); 1247 } 1248 } 1249 }; 1250 1251 mDataNetworkController.getDataSettingsManager() 1252 .registerCallback(mDataSettingsManagerCallback); 1253 1254 mPhoneSwitcherCallback = new PhoneSwitcherCallback(Runnable::run) { 1255 @Override 1256 public void onPreferredDataPhoneIdChanged(int phoneId) { 1257 sendMessage(EVENT_PREFERRED_DATA_SUBSCRIPTION_CHANGED, phoneId, 0); 1258 } 1259 }; 1260 mPhoneSwitcher.registerCallback(mPhoneSwitcherCallback); 1261 1262 mPhone.getDisplayInfoController().registerForTelephonyDisplayInfoChanged( 1263 getHandler(), EVENT_DISPLAY_INFO_CHANGED, null); 1264 mPhone.getServiceStateTracker().registerForServiceStateChanged(getHandler(), 1265 EVENT_SERVICE_STATE_CHANGED, null); 1266 for (int transport : mAccessNetworksManager.getAvailableTransports()) { 1267 mDataServiceManagers.get(transport) 1268 .registerForDataCallListChanged(getHandler(), EVENT_DATA_STATE_CHANGED); 1269 } 1270 1271 mCarrierPrivilegesCallback = 1272 (Set<String> privilegedPackageNames, Set<Integer> privilegedUids) -> { 1273 log("onCarrierPrivilegesChanged, Uids=" + privilegedUids); 1274 Message message = obtainMessage(EVENT_CARRIER_PRIVILEGED_UIDS_CHANGED); 1275 AsyncResult.forMessage( 1276 message, 1277 privilegedUids.stream().mapToInt(i -> i).toArray(), 1278 null /* ex */); 1279 sendMessage(message); 1280 }; 1281 TelephonyManager tm = mPhone.getContext().getSystemService(TelephonyManager.class); 1282 if (tm != null) { 1283 tm.registerCarrierPrivilegesCallback( 1284 mPhone.getPhoneId(), getHandler()::post, mCarrierPrivilegesCallback); 1285 } 1286 1287 mPhone.getServiceStateTracker().registerForCssIndicatorChanged( 1288 getHandler(), EVENT_CSS_INDICATOR_CHANGED, null); 1289 if (mPhone.getCallTracker() != null) { 1290 mPhone.getCallTracker().registerForVoiceCallStarted( 1291 getHandler(), EVENT_VOICE_CALL_STARTED, null); 1292 mPhone.getCallTracker().registerForVoiceCallEnded( 1293 getHandler(), EVENT_VOICE_CALL_ENDED, null); 1294 } 1295 // Check null for devices not supporting FEATURE_TELEPHONY_IMS. 1296 if (mPhone.getImsPhone() != null && mPhone.getImsPhone().getCallTracker() != null) { 1297 mPhone.getImsPhone().getCallTracker().registerForVoiceCallStarted( 1298 getHandler(), EVENT_VOICE_CALL_STARTED, null); 1299 mPhone.getImsPhone().getCallTracker().registerForVoiceCallEnded( 1300 getHandler(), EVENT_VOICE_CALL_ENDED, null); 1301 } 1302 1303 if (mDataProfile.canSatisfy(NetworkCapabilities.NET_CAPABILITY_MMS)) { 1304 mAccessNetworksManagerCallback = new AccessNetworksManagerCallback( 1305 getHandler()::post) { 1306 @Override 1307 public void onPreferredTransportChanged( 1308 @NetCapability int networkCapability, boolean forceReconnect) { 1309 if (networkCapability == NetworkCapabilities.NET_CAPABILITY_MMS) { 1310 log("MMS preference changed."); 1311 updateNetworkCapabilities(); 1312 } 1313 } 1314 }; 1315 mAccessNetworksManager.registerCallback(mAccessNetworksManagerCallback); 1316 } 1317 1318 mRil.registerForNotAvailable(getHandler(), EVENT_RADIO_NOT_AVAILABLE, null); 1319 1320 // Only add symmetric code here, for example, registering and unregistering. 1321 // DefaultState.enter() is the starting point in the life cycle of the DataNetwork, 1322 // and DefaultState.exit() is the end. For non-symmetric initializing works, put them 1323 // in ConnectingState.enter(). 1324 } 1325 1326 @Override 1327 public void exit() { 1328 logv("Unregistering all events."); 1329 if (mAccessNetworksManagerCallback != null) { 1330 mAccessNetworksManager.unregisterCallback(mAccessNetworksManagerCallback); 1331 } 1332 1333 // Check null for devices not supporting FEATURE_TELEPHONY_IMS. 1334 if (mPhone.getImsPhone() != null && mPhone.getImsPhone().getCallTracker() != null) { 1335 mPhone.getImsPhone().getCallTracker().unregisterForVoiceCallStarted(getHandler()); 1336 mPhone.getImsPhone().getCallTracker().unregisterForVoiceCallEnded(getHandler()); 1337 } 1338 if (mPhone.getCallTracker() != null) { 1339 mPhone.getCallTracker().unregisterForVoiceCallStarted(getHandler()); 1340 mPhone.getCallTracker().unregisterForVoiceCallEnded(getHandler()); 1341 } 1342 1343 mPhone.getServiceStateTracker().unregisterForCssIndicatorChanged(getHandler()); 1344 TelephonyManager tm = mPhone.getContext().getSystemService(TelephonyManager.class); 1345 if (tm != null && mCarrierPrivilegesCallback != null) { 1346 tm.unregisterCarrierPrivilegesCallback(mCarrierPrivilegesCallback); 1347 } 1348 for (int transport : mAccessNetworksManager.getAvailableTransports()) { 1349 mDataServiceManagers.get(transport) 1350 .unregisterForDataCallListChanged(getHandler()); 1351 } 1352 mPhone.getServiceStateTracker().unregisterForServiceStateChanged(getHandler()); 1353 mPhone.getDisplayInfoController().unregisterForTelephonyDisplayInfoChanged( 1354 getHandler()); 1355 mPhoneSwitcher.unregisterCallback(mPhoneSwitcherCallback); 1356 mDataNetworkController.getDataSettingsManager() 1357 .unregisterCallback(mDataSettingsManagerCallback); 1358 mRil.unregisterForPcoData(getHandler()); 1359 mDataConfigManager.unregisterCallback(mDataConfigManagerCallback); 1360 mRil.unregisterForNotAvailable(getHandler()); 1361 } 1362 1363 @Override 1364 public boolean processMessage(Message msg) { 1365 switch (msg.what) { 1366 case EVENT_DATA_CONFIG_UPDATED: 1367 onCarrierConfigUpdated(); 1368 break; 1369 case EVENT_SERVICE_STATE_CHANGED: { 1370 int networkType = getDataNetworkType(); 1371 mDataCallSessionStats.onDrsOrRatChanged(networkType); 1372 if (networkType != TelephonyManager.NETWORK_TYPE_UNKNOWN) { 1373 mLastKnownDataNetworkType = networkType; 1374 } 1375 NetworkRegistrationInfo nri = 1376 mPhone.getServiceState() 1377 .getNetworkRegistrationInfo( 1378 NetworkRegistrationInfo.DOMAIN_PS, 1379 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 1380 if (nri != null && nri.isInService()) { 1381 mLastKnownRoamingState = nri.getNetworkRegistrationState() 1382 == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING; 1383 } 1384 updateSuspendState(); 1385 updateNetworkCapabilities(); 1386 break; 1387 } 1388 case EVENT_ATTACH_NETWORK_REQUEST: { 1389 onAttachNetworkRequests((NetworkRequestList) msg.obj); 1390 updateNetworkScore(); 1391 break; 1392 } 1393 case EVENT_DETACH_NETWORK_REQUEST: { 1394 onDetachNetworkRequest((TelephonyNetworkRequest) msg.obj, 1395 msg.arg1 != 0 /* shouldRetry */); 1396 updateNetworkScore(); 1397 break; 1398 } 1399 case EVENT_DETACH_ALL_NETWORK_REQUESTS: { 1400 for (TelephonyNetworkRequest networkRequest : mAttachedNetworkRequestList) { 1401 // Check if the network request still belongs to this network, because 1402 // during data switch, the network request can be attached to other network 1403 // on a different SIM. 1404 if (networkRequest.getAttachedNetwork() == DataNetwork.this) { 1405 networkRequest.setState( 1406 TelephonyNetworkRequest.REQUEST_STATE_UNSATISFIED); 1407 networkRequest.setAttachedNetwork(null); 1408 } 1409 } 1410 log("All network requests detached."); 1411 mAttachedNetworkRequestList.clear(); 1412 break; 1413 } 1414 case EVENT_DATA_STATE_CHANGED: { 1415 AsyncResult ar = (AsyncResult) msg.obj; 1416 int transport = (int) ar.userObj; 1417 onDataStateChanged(transport, (List<DataCallResponse>) ar.result); 1418 break; 1419 } 1420 case EVENT_CARRIER_PRIVILEGED_UIDS_CHANGED: { 1421 AsyncResult asyncResult = (AsyncResult) msg.obj; 1422 int[] administratorUids = (int[]) asyncResult.result; 1423 mAdministratorUids = Arrays.copyOf(administratorUids, administratorUids.length); 1424 updateNetworkCapabilities(); 1425 break; 1426 } 1427 case EVENT_PCO_DATA_RECEIVED: { 1428 AsyncResult ar = (AsyncResult) msg.obj; 1429 onPcoDataReceived((PcoData) ar.result); 1430 break; 1431 } 1432 case EVENT_NOTIFY_HANDOVER_CANCELLED_RESPONSE: 1433 removeMessages(EVENT_CANCEL_HANDOVER_NO_RESPONSE); 1434 log("Notified handover cancelled."); 1435 break; 1436 case EVENT_BANDWIDTH_ESTIMATE_FROM_MODEM_CHANGED: 1437 case EVENT_TEAR_DOWN_NETWORK: 1438 case EVENT_STUCK_IN_TRANSIENT_STATE: 1439 case EVENT_CANCEL_HANDOVER_NO_RESPONSE: 1440 case EVENT_DISPLAY_INFO_CHANGED: 1441 case EVENT_WAITING_FOR_TEARING_DOWN_CONDITION_MET: 1442 case EVENT_CSS_INDICATOR_CHANGED: 1443 case EVENT_VOICE_CALL_STARTED: 1444 case EVENT_VOICE_CALL_ENDED: 1445 // Ignore the events when not in the correct state. 1446 log("Ignored " + eventToString(msg.what)); 1447 break; 1448 case EVENT_NOTIFY_HANDOVER_STARTED_RESPONSE: 1449 case EVENT_NOTIFY_HANDOVER_STARTED: 1450 // We reach here if network is not in the right state. 1451 if (msg.obj != null) { 1452 // Cancel it because it's either HO in progress or will soon disconnect. 1453 // Either case we want to clean up obsolete retry attempts. 1454 DataHandoverRetryEntry retryEntry = (DataHandoverRetryEntry) msg.obj; 1455 retryEntry.setState(DataRetryEntry.RETRY_STATE_CANCELLED); 1456 } 1457 log("Ignore handover to " + AccessNetworkConstants 1458 .transportTypeToString(msg.arg1) + " request."); 1459 break; 1460 case EVENT_RADIO_NOT_AVAILABLE: 1461 // Ignore this event when it isn't a WWAN data network. 1462 if (mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WLAN) { 1463 loge(eventToString(msg.what) 1464 + ": ignored on IWLAN"); 1465 break; 1466 } 1467 mFailCause = DataFailCause.RADIO_NOT_AVAILABLE; 1468 loge(eventToString(msg.what) + ": transition to disconnected state"); 1469 transitionTo(mDisconnectedState); 1470 break; 1471 case EVENT_DATA_NETWORK_VALIDATION_REQUESTED: 1472 // If the data network is not connected, the request should be ignored. 1473 handleErrorDataNetworkValidationRequest((Consumer<Integer>) msg.obj); 1474 break; 1475 case EVENT_DATA_NETWORK_VALIDATION_RESPONSE: 1476 // handle the resultCode in response for the request. 1477 handleDataNetworkValidationRequestResultCode(msg.arg1 /* resultCode */); 1478 break; 1479 case EVENT_PREFERRED_DATA_SUBSCRIPTION_CHANGED: 1480 mOnPreferredDataPhone = mPhone.getPhoneId() == msg.arg1; 1481 logl("Preferred data phone id changed to " + msg.arg1 1482 + ", mOnPreferredDataPhone=" + mOnPreferredDataPhone); 1483 updateNetworkScore(); 1484 break; 1485 default: 1486 loge("Unhandled event " + eventToString(msg.what)); 1487 break; 1488 } 1489 return HANDLED; 1490 } 1491 } 1492 1493 /** 1494 * The connecting state. This is the initial state of a data network. 1495 * 1496 * @see DataNetwork for the state machine diagram. 1497 */ 1498 private final class ConnectingState extends State { 1499 /** Used for checking setup response IP mismatch. */ 1500 @NetworkRegistrationInfo.RegistrationState private int mRegStateWhenSetup; 1501 @Override 1502 public void enter() { 1503 sendMessageDelayed(EVENT_STUCK_IN_TRANSIENT_STATE, 1504 mDataConfigManager.getAnomalyNetworkConnectingTimeoutMs()); 1505 mNetworkAgent = createNetworkAgent(); 1506 mInitialNetworkAgentId = mNetworkAgent.getId(); 1507 mLogTag = "DN-" + mInitialNetworkAgentId + "-" 1508 + ((mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) ? "C" : "I"); 1509 1510 // Get carrier config package uid. Note that this uid will not change through the life 1511 // cycle of this data network. So there is no need to listen to the change event. 1512 mCarrierServicePackageUid = mPhone.getCarrierPrivilegesTracker() 1513 .getCarrierServicePackageUid(); 1514 1515 notifyPreciseDataConnectionState(); 1516 if (mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WLAN) { 1517 // Defer setupData until we get the PDU session ID response 1518 allocatePduSessionId(); 1519 return; 1520 } 1521 1522 setupData(); 1523 } 1524 1525 @Override 1526 public void exit() { 1527 removeMessages(EVENT_STUCK_IN_TRANSIENT_STATE); 1528 } 1529 1530 @Override 1531 public boolean processMessage(Message msg) { 1532 logv("event=" + eventToString(msg.what)); 1533 switch (msg.what) { 1534 case EVENT_ALLOCATE_PDU_SESSION_ID_RESPONSE: 1535 AsyncResult ar = (AsyncResult) msg.obj; 1536 if (ar.exception == null) { 1537 mPduSessionId = (int) ar.result; 1538 log("Set PDU session id to " + mPduSessionId); 1539 } else { 1540 loge("Failed to allocate PDU session id. e=" + ar.exception); 1541 } 1542 //Check whether all network requests were removed before setupData. 1543 if (!mAttachedNetworkRequestList.isEmpty()) { 1544 setupData(); 1545 } else { 1546 mRetryDelayMillis = DataCallResponse.RETRY_DURATION_UNDEFINED; 1547 transitionTo(mDisconnectedState); 1548 } 1549 break; 1550 case EVENT_SETUP_DATA_NETWORK_RESPONSE: 1551 int resultCode = msg.arg1; 1552 DataCallResponse dataCallResponse = 1553 msg.getData().getParcelable(DataServiceManager.DATA_CALL_RESPONSE); 1554 onSetupResponse(resultCode, dataCallResponse); 1555 break; 1556 case EVENT_NOTIFY_HANDOVER_STARTED: 1557 case EVENT_TEAR_DOWN_NETWORK: 1558 case EVENT_WAITING_FOR_TEARING_DOWN_CONDITION_MET: 1559 // Defer the request until connected or disconnected. 1560 log("Defer message " + eventToString(msg.what)); 1561 deferMessage(msg); 1562 break; 1563 case EVENT_STUCK_IN_TRANSIENT_STATE: 1564 reportAnomaly("Data network stuck in connecting state for " 1565 + TimeUnit.MILLISECONDS.toSeconds( 1566 mDataConfigManager.getAnomalyNetworkConnectingTimeoutMs()) 1567 + " seconds.", "58c56403-7ea7-4e56-a0c7-e467114d09b8"); 1568 // Setup data failed. Use the retry logic defined in 1569 // CarrierConfigManager.KEY_TELEPHONY_DATA_SETUP_RETRY_RULES_STRING_ARRAY. 1570 mRetryDelayMillis = DataCallResponse.RETRY_DURATION_UNDEFINED; 1571 mFailCause = DataFailCause.NO_RETRY_FAILURE; 1572 transitionTo(mDisconnectedState); 1573 break; 1574 case EVENT_DEACTIVATE_DATA_NETWORK_RESPONSE: 1575 int responseCode = msg.arg1; 1576 onDeactivateResponse(responseCode); 1577 break; 1578 default: 1579 return NOT_HANDLED; 1580 } 1581 return HANDLED; 1582 } 1583 1584 /** 1585 * Setup a data network. 1586 */ 1587 private void setupData() { 1588 int dataNetworkType = getDataNetworkType(); 1589 1590 NetworkRegistrationInfo nri = getNetworkRegistrationInfo(); 1591 mRegStateWhenSetup = nri != null 1592 ? nri.getNetworkRegistrationState() 1593 : NetworkRegistrationInfo.REGISTRATION_STATE_UNKNOWN; 1594 // We need to use the actual modem roaming state instead of the framework roaming state 1595 // here. This flag is only passed down to ril_service for picking the correct protocol 1596 // (for old modem backward compatibility). 1597 boolean isModemRoaming = mPhone.getServiceState().getDataRoamingFromRegistration(); 1598 1599 // Set this flag to true if the user turns on data roaming. Or if we override the 1600 // roaming state in framework, we should set this flag to true as well so the modem will 1601 // not reject the data call setup (because the modem thinks the device is roaming). 1602 boolean allowRoaming = mPhone.getDataRoamingEnabled() 1603 || (isModemRoaming && (!mPhone.getServiceState().getDataRoaming() 1604 /*|| isUnmeteredUseOnly()*/)); 1605 1606 TrafficDescriptor trafficDescriptor = mDataProfile.getTrafficDescriptor(); 1607 final boolean matchAllRuleAllowed = trafficDescriptor == null 1608 || !TextUtils.isEmpty(trafficDescriptor.getDataNetworkName()) 1609 // Both OsAppId and APN name are null. This helps for modem to handle when we 1610 // are on 5G or LTE with URSP support in falling back to default network. 1611 || (TextUtils.isEmpty(trafficDescriptor.getDataNetworkName()) 1612 && trafficDescriptor.getOsAppId() == null); 1613 1614 int accessNetwork = DataUtils.networkTypeToAccessNetworkType(dataNetworkType); 1615 1616 mDataServiceManagers.get(mTransport) 1617 .setupDataCall(accessNetwork, mDataProfile, isModemRoaming, allowRoaming, 1618 DataService.REQUEST_REASON_NORMAL, null, mPduSessionId, null, 1619 trafficDescriptor, matchAllRuleAllowed, 1620 obtainMessage(EVENT_SETUP_DATA_NETWORK_RESPONSE)); 1621 1622 int apnTypeBitmask = mDataProfile.getApnSetting() != null 1623 ? mDataProfile.getApnSetting().getApnTypeBitmask() : ApnSetting.TYPE_NONE; 1624 mDataCallSessionStats.onSetupDataCall(apnTypeBitmask, isSatellite()); 1625 1626 logl("setupData: accessNetwork=" 1627 + AccessNetworkType.toString(accessNetwork) + ", " + mDataProfile 1628 + ", isModemRoaming=" + isModemRoaming + ", allowRoaming=" + allowRoaming 1629 + ", PDU session id=" + mPduSessionId + ", matchAllRuleAllowed=" 1630 + matchAllRuleAllowed); 1631 TelephonyMetrics.getInstance().writeSetupDataCall(mPhone.getPhoneId(), 1632 ServiceState.networkTypeToRilRadioTechnology(dataNetworkType), 1633 mDataProfile.getProfileId(), mDataProfile.getApn(), 1634 mDataProfile.getProtocolType()); 1635 } 1636 1637 /** 1638 * Called when receiving setup data network response from the data service. 1639 * 1640 * @param resultCode The result code. 1641 * @param response The response. 1642 */ 1643 private void onSetupResponse(@DataServiceCallback.ResultCode int resultCode, 1644 @Nullable DataCallResponse response) { 1645 logl("onSetupResponse: resultCode=" + DataServiceCallback.resultCodeToString(resultCode) 1646 + ", response=" + response); 1647 mFailCause = getFailCauseFromDataCallResponse(resultCode, response); 1648 validateDataCallResponse(response, mRegStateWhenSetup); 1649 if (mFailCause == DataFailCause.NONE) { 1650 DataNetwork dataNetwork = mDataNetworkController.getDataNetworkByInterface( 1651 response.getInterfaceName()); 1652 if (dataNetwork != null) { 1653 logl("Interface " + response.getInterfaceName() + " has been already used by " 1654 + dataNetwork + ". Silently tear down now."); 1655 // If this is a pre-5G data setup, that means APN database has some problems. 1656 // For example, different APN settings have the same APN name. 1657 if (response.getTrafficDescriptors().isEmpty() && dataNetwork.isConnected()) { 1658 reportAnomaly("Duplicate network interface " + response.getInterfaceName() 1659 + " detected.", "62f66e7e-8d71-45de-a57b-dc5c78223fd5"); 1660 } 1661 1662 // Do not actually invoke onTearDown, otherwise the existing data network will 1663 // be torn down. 1664 mRetryDelayMillis = DataCallResponse.RETRY_DURATION_UNDEFINED; 1665 mFailCause = DataFailCause.NO_RETRY_FAILURE; 1666 transitionTo(mDisconnectedState); 1667 return; 1668 } 1669 1670 updateDataNetwork(response); 1671 1672 if (mVcnManager != null && mVcnManager.applyVcnNetworkPolicy(mNetworkCapabilities, 1673 mLinkProperties).isTeardownRequested()) { 1674 log("VCN service requested to tear down the network."); 1675 // Directly call onTearDown here. Calling tearDown will cause deadlock because 1676 // EVENT_TEAR_DOWN_NETWORK is deferred until state machine enters connected 1677 // state, which will never happen in this case. 1678 onTearDown(TEAR_DOWN_REASON_VCN_REQUESTED); 1679 return; 1680 } 1681 1682 transitionTo(mConnectedState); 1683 } else { 1684 // Setup data failed. 1685 mRetryDelayMillis = response != null ? response.getRetryDurationMillis() 1686 : DataCallResponse.RETRY_DURATION_UNDEFINED; 1687 transitionTo(mDisconnectedState); 1688 } 1689 1690 int apnTypeBitmask = ApnSetting.TYPE_NONE; 1691 int protocol = ApnSetting.PROTOCOL_UNKNOWN; 1692 if (mDataProfile.getApnSetting() != null) { 1693 apnTypeBitmask = mDataProfile.getApnSetting().getApnTypeBitmask(); 1694 protocol = mDataProfile.getApnSetting().getProtocol(); 1695 } 1696 mDataCallSessionStats.onSetupDataCallResponse(response, 1697 getDataNetworkType(), 1698 apnTypeBitmask, 1699 protocol, 1700 // Log the raw fail cause to avoid large amount of UNKNOWN showing on metrics. 1701 response != null ? response.getCause() : mFailCause); 1702 } 1703 } 1704 1705 /** 1706 * The connected state. This is the state when data network becomes usable. 1707 * 1708 * @see DataNetwork for the state machine diagram. 1709 */ 1710 private final class ConnectedState extends State { 1711 @Override 1712 public void enter() { 1713 // Note that reaching here could mean from connecting -> connected, or from 1714 // handover -> connected. 1715 if (!mEverConnected) { 1716 // Transited from ConnectingState 1717 log("network connected."); 1718 mEverConnected = true; 1719 mNetworkAgent.markConnected(); 1720 mDataNetworkCallback.invokeFromExecutor( 1721 () -> mDataNetworkCallback.onConnected(DataNetwork.this)); 1722 1723 mQosCallbackTracker = new QosCallbackTracker(mNetworkAgent, mPhone); 1724 mQosCallbackTracker.updateSessions(mQosBearerSessions); 1725 mKeepaliveTracker = new KeepaliveTracker(mPhone, 1726 getHandler().getLooper(), DataNetwork.this, mNetworkAgent); 1727 if (mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) { 1728 registerForWwanEvents(); 1729 } 1730 1731 // Create the VCN policy changed listener. When the policy changed, we might need 1732 // to tear down the VCN-managed network. 1733 if (mVcnManager != null) { 1734 mVcnPolicyChangeListener = () -> { 1735 log("VCN policy changed."); 1736 if (mVcnManager.applyVcnNetworkPolicy(mNetworkCapabilities, mLinkProperties) 1737 .isTeardownRequested()) { 1738 tearDown(TEAR_DOWN_REASON_VCN_REQUESTED); 1739 } else { 1740 updateNetworkCapabilities(); 1741 } 1742 }; 1743 mVcnManager.addVcnNetworkPolicyChangeListener( 1744 getHandler()::post, mVcnPolicyChangeListener); 1745 } 1746 } 1747 1748 // If we've ever received PCO data before connected, now it's the time to process it. 1749 mPcoData.getOrDefault(mCid.get(mTransport), Collections.emptyMap()) 1750 .forEach((pcoId, pcoData) -> onPcoDataChanged(pcoData)); 1751 1752 mDataNetworkCallback.invokeFromExecutor( 1753 () -> mDataNetworkCallback.onLinkStatusChanged(DataNetwork.this, mLinkStatus)); 1754 notifyPreciseDataConnectionState(); 1755 updateSuspendState(); 1756 } 1757 1758 @Override 1759 public boolean processMessage(Message msg) { 1760 logv("event=" + eventToString(msg.what)); 1761 switch (msg.what) { 1762 case EVENT_TEAR_DOWN_NETWORK: 1763 if (mInvokedDataDeactivation) { 1764 log("Ignore tear down request because network is being torn down."); 1765 break; 1766 } 1767 1768 int tearDownReason = msg.arg1; 1769 1770 removeMessages(EVENT_TEAR_DOWN_NETWORK); 1771 removeDeferredMessages(EVENT_TEAR_DOWN_NETWORK); 1772 transitionTo(mDisconnectingState); 1773 onTearDown(tearDownReason); 1774 break; 1775 case EVENT_BANDWIDTH_ESTIMATE_FROM_MODEM_CHANGED: 1776 AsyncResult ar = (AsyncResult) msg.obj; 1777 if (ar.exception != null) { 1778 log("EVENT_BANDWIDTH_ESTIMATE_FROM_MODEM_CHANGED: error ignoring, e=" 1779 + ar.exception); 1780 break; 1781 } 1782 onBandwidthUpdatedFromModem((List<LinkCapacityEstimate>) ar.result); 1783 break; 1784 case EVENT_DISPLAY_INFO_CHANGED: 1785 onDisplayInfoChanged(); 1786 break; 1787 case EVENT_NOTIFY_HANDOVER_STARTED: 1788 // Notify source transport that handover is about to start. Note this will not 1789 // initiate the handover process on target transport, but more for notifying 1790 // the source transport so that PDU session id can be preserved if network 1791 // notifies PDN lost during handover. The real handover process will kick off 1792 // after receiving EVENT_NOTIFY_HANDOVER_STARTED_RESPONSE. 1793 log("Notifying source transport " 1794 + AccessNetworkConstants.transportTypeToString(mTransport) 1795 + " that handover is about to start."); 1796 mDataServiceManagers.get(mTransport).startHandover(mCid.get(mTransport), 1797 obtainMessage(EVENT_NOTIFY_HANDOVER_STARTED_RESPONSE, 0, msg.arg2, 1798 msg.obj)); 1799 // We enter handover state here because this is the first action we do for 1800 // handover. 1801 transitionTo(mHandoverState); 1802 break; 1803 case EVENT_SUBSCRIPTION_PLAN_OVERRIDE: 1804 updateMeteredAndCongested(); 1805 break; 1806 case EVENT_DEACTIVATE_DATA_NETWORK_RESPONSE: 1807 int resultCode = msg.arg1; 1808 onDeactivateResponse(resultCode); 1809 break; 1810 case EVENT_WAITING_FOR_TEARING_DOWN_CONDITION_MET: 1811 transitionTo(mDisconnectingState); 1812 sendMessageDelayed(EVENT_TEAR_DOWN_NETWORK, msg.arg1, msg.arg2); 1813 break; 1814 case EVENT_VOICE_CALL_STARTED: 1815 case EVENT_VOICE_CALL_ENDED: 1816 case EVENT_CSS_INDICATOR_CHANGED: 1817 updateSuspendState(); 1818 updateNetworkCapabilities(); 1819 break; 1820 case EVENT_DATA_NETWORK_VALIDATION_REQUESTED: 1821 // Network validation request can be accepted if the data is in connected state 1822 handleDataNetworkValidationRequest((Consumer<Integer>) msg.obj); 1823 break; 1824 case EVENT_CANCEL_HANDOVER_NO_RESPONSE: 1825 reportAnomaly("Cancel handover no response within " 1826 + TimeUnit.MILLISECONDS.toSeconds( 1827 mDataConfigManager.getNetworkHandoverTimeoutMs()) 1828 + " seconds.", "ad320988-0601-4955-836a-e6b67289c294"); 1829 break; 1830 default: 1831 return NOT_HANDLED; 1832 } 1833 return HANDLED; 1834 } 1835 } 1836 1837 /** 1838 * The handover state. This is the state when data network handover between IWLAN and cellular. 1839 * 1840 * @see DataNetwork for the state machine diagram. 1841 */ 1842 private final class HandoverState extends State { 1843 @Override 1844 public void enter() { 1845 removeMessages(EVENT_CANCEL_HANDOVER_NO_RESPONSE); 1846 sendMessageDelayed(EVENT_STUCK_IN_TRANSIENT_STATE, 1847 mDataConfigManager.getNetworkHandoverTimeoutMs()); 1848 notifyPreciseDataConnectionState(); 1849 updateNetworkScore(true /* keepConnectedForHandover */); 1850 } 1851 1852 @Override 1853 public void exit() { 1854 removeMessages(EVENT_STUCK_IN_TRANSIENT_STATE); 1855 updateNetworkScore(false /* keepConnectedForHandover */); 1856 } 1857 1858 @Override 1859 public boolean processMessage(Message msg) { 1860 logv("event=" + eventToString(msg.what)); 1861 switch (msg.what) { 1862 case EVENT_DATA_STATE_CHANGED: 1863 // The data call list changed event should be conditionally deferred. 1864 // Otherwise the deferred message might be incorrectly treated as "disconnected" 1865 // signal. So we only defer the related data call list changed event, and drop 1866 // the unrelated. 1867 AsyncResult ar = (AsyncResult) msg.obj; 1868 int transport = (int) ar.userObj; 1869 List<DataCallResponse> responseList = (List<DataCallResponse>) ar.result; 1870 if (transport != mTransport) { 1871 log("Dropped unrelated " 1872 + AccessNetworkConstants.transportTypeToString(transport) 1873 + " data call list changed event. " + responseList); 1874 } else { 1875 log("Defer message " + eventToString(msg.what) + ":" + responseList); 1876 deferMessage(msg); 1877 } 1878 break; 1879 case EVENT_WAITING_FOR_TEARING_DOWN_CONDITION_MET: 1880 case EVENT_DISPLAY_INFO_CHANGED: 1881 case EVENT_TEAR_DOWN_NETWORK: 1882 case EVENT_CSS_INDICATOR_CHANGED: 1883 case EVENT_VOICE_CALL_ENDED: 1884 case EVENT_VOICE_CALL_STARTED: 1885 case EVENT_DATA_NETWORK_VALIDATION_REQUESTED: 1886 // Defer the request until handover succeeds or fails. 1887 log("Defer message " + eventToString(msg.what)); 1888 deferMessage(msg); 1889 break; 1890 case EVENT_RADIO_NOT_AVAILABLE: 1891 if (mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) { 1892 // Defer the request until handover to IWLAN succeeds or fails. 1893 log("Defer message " + eventToString(msg.what)); 1894 deferMessage(msg); 1895 } else { 1896 // If this is during handover to cellular, always tear down the network as 1897 // we will never get success or failed response from the modem. 1898 mFailCause = DataFailCause.RADIO_NOT_AVAILABLE; 1899 loge(eventToString(msg.what) + ": transition to disconnected state"); 1900 transitionTo(mDisconnectedState); 1901 } 1902 break; 1903 case EVENT_NOTIFY_HANDOVER_STARTED_RESPONSE: 1904 onStartHandover(msg.arg2, (DataHandoverRetryEntry) msg.obj); 1905 break; 1906 case EVENT_HANDOVER_RESPONSE: 1907 int resultCode = msg.arg1; 1908 DataCallResponse dataCallResponse = 1909 msg.getData().getParcelable(DataServiceManager.DATA_CALL_RESPONSE); 1910 onHandoverResponse(resultCode, dataCallResponse, 1911 (DataHandoverRetryEntry) msg.obj); 1912 break; 1913 case EVENT_STUCK_IN_TRANSIENT_STATE: 1914 // enable detection only for valid timeout range 1915 reportAnomaly("Data service did not respond the handover request within " 1916 + TimeUnit.MILLISECONDS.toSeconds( 1917 mDataConfigManager.getNetworkHandoverTimeoutMs()) + " seconds.", 1918 "1afe68cb-8b41-4964-a737-4f34372429ea"); 1919 // Handover failed. Use the retry logic defined in 1920 // CarrierConfigManager.KEY_TELEPHONY_DATA_HANDOVER_RETRY_RULES_STRING_ARRAY. 1921 long retry = DataCallResponse.RETRY_DURATION_UNDEFINED; 1922 int handoverFailureMode = 1923 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_SETUP_NORMAL; 1924 mFailCause = DataFailCause.ERROR_UNSPECIFIED; 1925 mDataNetworkCallback.invokeFromExecutor( 1926 () -> mDataNetworkCallback.onHandoverFailed(DataNetwork.this, 1927 mFailCause, retry, handoverFailureMode)); 1928 // No matter handover succeeded or not, transit back to connected state. 1929 transitionTo(mConnectedState); 1930 break; 1931 default: 1932 return NOT_HANDLED; 1933 } 1934 return HANDLED; 1935 } 1936 } 1937 1938 /** 1939 * The disconnecting state. This is the state when data network is about to be disconnected. 1940 * The network is still usable in this state, but the clients should be prepared to lose the 1941 * network in any moment. This state is particular useful for IMS graceful tear down, where 1942 * the network enters disconnecting state while waiting for IMS de-registration signal. 1943 * 1944 * @see DataNetwork for the state machine diagram. 1945 */ 1946 private final class DisconnectingState extends State { 1947 @Override 1948 public void enter() { 1949 sendMessageDelayed(EVENT_STUCK_IN_TRANSIENT_STATE, 1950 mDataConfigManager.getAnomalyNetworkDisconnectingTimeoutMs()); 1951 notifyPreciseDataConnectionState(); 1952 } 1953 1954 @Override 1955 public void exit() { 1956 removeMessages(EVENT_STUCK_IN_TRANSIENT_STATE); 1957 } 1958 1959 @Override 1960 public boolean processMessage(Message msg) { 1961 logv("event=" + eventToString(msg.what)); 1962 switch (msg.what) { 1963 case EVENT_TEAR_DOWN_NETWORK: 1964 if (mInvokedDataDeactivation) { 1965 log("Ignore tear down request because network is being torn down."); 1966 break; 1967 } 1968 removeMessages(EVENT_TEAR_DOWN_NETWORK); 1969 removeDeferredMessages(EVENT_TEAR_DOWN_NETWORK); 1970 onTearDown(msg.arg1); 1971 break; 1972 case EVENT_DEACTIVATE_DATA_NETWORK_RESPONSE: 1973 int resultCode = msg.arg1; 1974 onDeactivateResponse(resultCode); 1975 break; 1976 case EVENT_STUCK_IN_TRANSIENT_STATE: 1977 // After frameworks issues deactivate data call request, RIL should report 1978 // data disconnected through data call list changed event subsequently. 1979 1980 reportAnomaly("RIL did not send data call list changed event after " 1981 + "deactivate data call request within " 1982 + TimeUnit.MILLISECONDS.toSeconds( 1983 mDataConfigManager.getAnomalyNetworkDisconnectingTimeoutMs()) 1984 + " seconds.", "d0e4fa1c-c57b-4ba5-b4b6-8955487012cc"); 1985 mFailCause = DataFailCause.LOST_CONNECTION; 1986 transitionTo(mDisconnectedState); 1987 break; 1988 case EVENT_DISPLAY_INFO_CHANGED: 1989 onDisplayInfoChanged(); 1990 break; 1991 case EVENT_CSS_INDICATOR_CHANGED: 1992 case EVENT_VOICE_CALL_STARTED: 1993 case EVENT_VOICE_CALL_ENDED: 1994 updateSuspendState(); 1995 updateNetworkCapabilities(); 1996 break; 1997 default: 1998 return NOT_HANDLED; 1999 } 2000 return HANDLED; 2001 } 2002 } 2003 2004 /** 2005 * The disconnected state. This is the final state of a data network. 2006 * 2007 * @see DataNetwork for the state machine diagram. 2008 */ 2009 private final class DisconnectedState extends State { 2010 @Override 2011 public void enter() { 2012 logl("Data network disconnected. mEverConnected=" + mEverConnected); 2013 // Preserve the list for onSetupDataFailed callback, because we need to pass that list 2014 // back to DataNetworkController, but after EVENT_DETACH_ALL_NETWORK_REQUESTS gets 2015 // processed, the network request list would become empty. 2016 NetworkRequestList requestList = new NetworkRequestList(mAttachedNetworkRequestList); 2017 2018 // The detach all network requests must be the last message to handle. 2019 sendMessage(EVENT_DETACH_ALL_NETWORK_REQUESTS); 2020 // Gracefully handle all the un-processed events then quit the state machine. 2021 // quit() throws a QUIT event to the end of message queue. All the events before quit() 2022 // will be processed. Events after quit() will not be processed. 2023 quit(); 2024 2025 //************************************************************// 2026 // DO NOT POST ANY EVENTS AFTER HERE. // 2027 // THE STATE MACHINE WONT PROCESS EVENTS AFTER QUIT. // 2028 // ONLY CLEANUP SHOULD BE PERFORMED AFTER THIS. // 2029 //************************************************************// 2030 2031 if (mEverConnected) { 2032 mLinkStatus = DataCallResponse.LINK_STATUS_INACTIVE; 2033 mNetworkValidationStatus = 2034 PreciseDataConnectionState.NETWORK_VALIDATION_UNSUPPORTED; 2035 mDataNetworkCallback.invokeFromExecutor(() -> mDataNetworkCallback 2036 .onLinkStatusChanged(DataNetwork.this, mLinkStatus)); 2037 mDataNetworkCallback.invokeFromExecutor(() -> mDataNetworkCallback 2038 .onDisconnected(DataNetwork.this, mFailCause, mTearDownReason)); 2039 if (mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) { 2040 unregisterForWwanEvents(); 2041 } 2042 // Since NetworkValidation is able to request only in the Connected state, 2043 // if ever connected, log for onDataNetworkDisconnected. 2044 mDataNetworkValidationStats.onDataNetworkDisconnected(getDataNetworkType()); 2045 } else { 2046 mDataNetworkCallback.invokeFromExecutor(() -> mDataNetworkCallback 2047 .onSetupDataFailed(DataNetwork.this, 2048 requestList, mFailCause, mRetryDelayMillis)); 2049 } 2050 notifyPreciseDataConnectionState(); 2051 mNetworkAgent.unregister(); 2052 mDataNetworkController.unregisterDataNetworkControllerCallback( 2053 mDataNetworkControllerCallback); 2054 mDataCallSessionStats.onDataCallDisconnected(mFailCause); 2055 2056 if (mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WLAN 2057 && mPduSessionId != DataCallResponse.PDU_SESSION_ID_NOT_SET) { 2058 mRil.releasePduSessionId(null, mPduSessionId); 2059 } 2060 2061 if (mVcnManager != null && mVcnPolicyChangeListener != null) { 2062 mVcnManager.removeVcnNetworkPolicyChangeListener(mVcnPolicyChangeListener); 2063 } 2064 } 2065 2066 @Override 2067 public boolean processMessage(Message msg) { 2068 logv("event=" + eventToString(msg.what)); 2069 return NOT_HANDLED; 2070 } 2071 } 2072 2073 /** 2074 * Register for events that can only happen on cellular networks. 2075 */ 2076 private void registerForWwanEvents() { 2077 registerForBandwidthUpdate(); 2078 mKeepaliveTracker.registerForKeepaliveStatus(); 2079 } 2080 2081 /** 2082 * Unregister for events that can only happen on cellular networks. 2083 */ 2084 private void unregisterForWwanEvents() { 2085 unregisterForBandwidthUpdate(); 2086 mKeepaliveTracker.unregisterForKeepaliveStatus(); 2087 } 2088 2089 @Override 2090 protected void unhandledMessage(Message msg) { 2091 IState state = getCurrentState(); 2092 loge("Unhandled message " + msg.what + " in state " 2093 + (state == null ? "null" : state.getName())); 2094 } 2095 2096 /** 2097 * Attempt to attach the network request list to this data network. Whether the network can 2098 * satisfy the request or not will be checked when EVENT_ATTACH_NETWORK_REQUEST is processed. 2099 * If the request can't be attached, {@link DataNetworkCallback#onAttachFailed( 2100 * DataNetwork, NetworkRequestList)}. 2101 * 2102 * @param requestList Network request list to attach. 2103 * @return {@code false} if the network is already disconnected. {@code true} means the request 2104 * has been scheduled to attach to the network. If attach succeeds, the network request's state 2105 * will be set to {@link TelephonyNetworkRequest#REQUEST_STATE_SATISFIED}. If failed, the 2106 * callback {@link DataNetworkCallback#onAttachFailed(DataNetwork, NetworkRequestList)} will 2107 * be called. 2108 */ 2109 public boolean attachNetworkRequests(@NonNull NetworkRequestList requestList) { 2110 // If the network is already ended, we still attach the network request to the data network, 2111 // so it can be retried later by data network controller. 2112 if (getCurrentState() == null || isDisconnected()) { 2113 // The state machine has already stopped. This is due to data network is disconnected. 2114 return false; 2115 } 2116 sendMessage(obtainMessage(EVENT_ATTACH_NETWORK_REQUEST, requestList)); 2117 return true; 2118 } 2119 2120 /** 2121 * Called when attaching network request list to this data network. 2122 * 2123 * @param requestList Network request list to attach. 2124 */ 2125 public void onAttachNetworkRequests(@NonNull NetworkRequestList requestList) { 2126 NetworkRequestList failedList = new NetworkRequestList(); 2127 for (TelephonyNetworkRequest networkRequest : requestList) { 2128 if (!mDataNetworkController.isNetworkRequestExisting(networkRequest)) { 2129 failedList.add(networkRequest); 2130 log("Attached failed. Network request was already removed. " + networkRequest); 2131 } else if (!networkRequest.canBeSatisfiedBy(getNetworkCapabilities())) { 2132 failedList.add(networkRequest); 2133 log("Attached failed. Cannot satisfy the network request " 2134 + networkRequest); 2135 } else { 2136 mAttachedNetworkRequestList.add(networkRequest); 2137 networkRequest.setAttachedNetwork(DataNetwork.this); 2138 networkRequest.setState( 2139 TelephonyNetworkRequest.REQUEST_STATE_SATISFIED); 2140 log("Successfully attached network request " + networkRequest); 2141 } 2142 } 2143 if (!failedList.isEmpty()) { 2144 mDataNetworkCallback.invokeFromExecutor(() -> mDataNetworkCallback 2145 .onAttachFailed(DataNetwork.this, failedList)); 2146 } 2147 } 2148 2149 /** 2150 * Called when detaching the network request from this data network. 2151 * 2152 * @param networkRequest Network request to detach. 2153 * @param shouldRetry {@code true} if the detached network request should be retried. 2154 */ 2155 private void onDetachNetworkRequest(@NonNull TelephonyNetworkRequest networkRequest, 2156 boolean shouldRetry) { 2157 mAttachedNetworkRequestList.remove(networkRequest); 2158 // Check if the network request still belongs to this network, because 2159 // during data switch, the network request can be attached to other network 2160 // on a different SIM. 2161 if (networkRequest.getAttachedNetwork() == DataNetwork.this) { 2162 networkRequest.setState(TelephonyNetworkRequest.REQUEST_STATE_UNSATISFIED); 2163 networkRequest.setAttachedNetwork(null); 2164 2165 if (shouldRetry) { 2166 // Inform DataNetworkController that a network request was detached and should be 2167 // scheduled to retry. 2168 mDataNetworkCallback.invokeFromExecutor(() -> 2169 mDataNetworkCallback.onRetryUnsatisfiedNetworkRequest(networkRequest)); 2170 } 2171 } 2172 2173 if (mAttachedNetworkRequestList.isEmpty()) { 2174 log("All network requests are detached."); 2175 2176 // If there is no network request attached, and we are not preferred data phone, then 2177 // this detach is likely due to temp DDS switch. We should tear down the network when 2178 // all requests are detached so the other network on preferred data sub can be 2179 // established properly. 2180 int preferredDataPhoneId = PhoneSwitcher.getInstance().getPreferredDataPhoneId(); 2181 if (preferredDataPhoneId != SubscriptionManager.INVALID_PHONE_INDEX 2182 && preferredDataPhoneId != mPhone.getPhoneId()) { 2183 tearDown(TEAR_DOWN_REASON_PREFERRED_DATA_SWITCHED); 2184 } 2185 } 2186 } 2187 2188 /** 2189 * Detach the network request from this data network. Note that this will not tear down the 2190 * network. 2191 * 2192 * @param networkRequest Network request to detach. 2193 * @param shouldRetry {@code true} if the detached network request should be retried. 2194 */ 2195 public void detachNetworkRequest(@NonNull TelephonyNetworkRequest networkRequest, 2196 boolean shouldRetry) { 2197 if (getCurrentState() == null || isDisconnected()) { 2198 return; 2199 } 2200 sendMessage(obtainMessage(EVENT_DETACH_NETWORK_REQUEST, shouldRetry ? 1 : 0, 0, 2201 networkRequest)); 2202 } 2203 2204 /** 2205 * Register for bandwidth update. 2206 */ 2207 private void registerForBandwidthUpdate() { 2208 int bandwidthEstimateSource = mDataConfigManager.getBandwidthEstimateSource(); 2209 if (bandwidthEstimateSource == BANDWIDTH_SOURCE_MODEM) { 2210 mPhone.mCi.registerForLceInfo( 2211 getHandler(), EVENT_BANDWIDTH_ESTIMATE_FROM_MODEM_CHANGED, null); 2212 } else if (bandwidthEstimateSource == BANDWIDTH_SOURCE_BANDWIDTH_ESTIMATOR) { 2213 if (mLinkBandwidthEstimatorCallback == null) { 2214 mLinkBandwidthEstimatorCallback = 2215 new LinkBandwidthEstimatorCallback(getHandler()::post) { 2216 @Override 2217 public void onBandwidthChanged(int uplinkBandwidthKbps, 2218 int downlinkBandwidthKbps) { 2219 if (isConnected()) { 2220 onBandwidthUpdated(uplinkBandwidthKbps, downlinkBandwidthKbps); 2221 } 2222 } 2223 }; 2224 mPhone.getLinkBandwidthEstimator().registerCallback( 2225 mLinkBandwidthEstimatorCallback); 2226 } 2227 } else { 2228 loge("Invalid bandwidth source configuration: " + bandwidthEstimateSource); 2229 } 2230 } 2231 2232 /** 2233 * Unregister bandwidth update. 2234 */ 2235 private void unregisterForBandwidthUpdate() { 2236 int bandwidthEstimateSource = mDataConfigManager.getBandwidthEstimateSource(); 2237 if (bandwidthEstimateSource == BANDWIDTH_SOURCE_MODEM) { 2238 mPhone.mCi.unregisterForLceInfo(getHandler()); 2239 } else if (bandwidthEstimateSource == BANDWIDTH_SOURCE_BANDWIDTH_ESTIMATOR) { 2240 if (mLinkBandwidthEstimatorCallback != null) { 2241 mPhone.getLinkBandwidthEstimator() 2242 .unregisterCallback(mLinkBandwidthEstimatorCallback); 2243 mLinkBandwidthEstimatorCallback = null; 2244 } 2245 } else { 2246 loge("Invalid bandwidth source configuration: " + bandwidthEstimateSource); 2247 } 2248 } 2249 2250 /** 2251 * Remove network requests that can't be satisfied anymore. 2252 * 2253 * @param shouldRetry {@code true} if the detached network requests should be retried. 2254 */ 2255 private void removeUnsatisfiedNetworkRequests(boolean shouldRetry) { 2256 for (TelephonyNetworkRequest networkRequest : mAttachedNetworkRequestList) { 2257 if (!networkRequest.canBeSatisfiedBy(mNetworkCapabilities)) { 2258 log("removeUnsatisfiedNetworkRequests: " + networkRequest 2259 + " can't be satisfied anymore. Will be detached."); 2260 detachNetworkRequest(networkRequest, shouldRetry); 2261 } 2262 } 2263 } 2264 2265 /** 2266 * Check if the new link properties are compatible with the old link properties. For example, 2267 * if IP changes, that's considered incompatible. 2268 * 2269 * @param oldLinkProperties Old link properties. 2270 * @param newLinkProperties New Link properties. 2271 * 2272 * @return {@code true} if the new link properties is compatible with the old link properties. 2273 */ 2274 private boolean isLinkPropertiesCompatible(@NonNull LinkProperties oldLinkProperties, 2275 @NonNull LinkProperties newLinkProperties) { 2276 if (Objects.equals(oldLinkProperties, newLinkProperties)) return true; 2277 2278 if (!LinkPropertiesUtils.isIdenticalAddresses(oldLinkProperties, newLinkProperties)) { 2279 // If the same address type was removed and added we need to cleanup. 2280 LinkPropertiesUtils.CompareOrUpdateResult<Integer, LinkAddress> result = 2281 new LinkPropertiesUtils.CompareOrUpdateResult<>( 2282 oldLinkProperties.getLinkAddresses(), 2283 newLinkProperties.getLinkAddresses(), 2284 linkAddress -> Objects.hash(linkAddress.getAddress(), 2285 linkAddress.getPrefixLength(), linkAddress.getScope())); 2286 log("isLinkPropertiesCompatible: old=" + oldLinkProperties 2287 + " new=" + newLinkProperties + " result=" + result); 2288 for (LinkAddress added : result.added) { 2289 for (LinkAddress removed : result.removed) { 2290 if (NetUtils.addressTypeMatches(removed.getAddress(), added.getAddress())) { 2291 return false; 2292 } 2293 } 2294 } 2295 } 2296 2297 return true; 2298 } 2299 2300 /** 2301 * Check if there are immutable capabilities changed. The connectivity service is not able 2302 * to handle immutable capabilities changed, but in very rare scenarios, immutable capabilities 2303 * need to be changed dynamically, such as in setup data call response, modem responded with the 2304 * same cid. In that case, we need to merge the new capabilities into the existing data network. 2305 * 2306 * @param oldCapabilities The old network capabilities. 2307 * @param newCapabilities The new network capabilities. 2308 * @return {@code true} if there are immutable network capabilities changed. 2309 */ 2310 private static boolean areImmutableCapabilitiesChanged( 2311 @NonNull NetworkCapabilities oldCapabilities, 2312 @NonNull NetworkCapabilities newCapabilities) { 2313 if (ArrayUtils.isEmpty(oldCapabilities.getCapabilities())) return false; 2314 2315 // Remove mutable capabilities from both old and new capabilities, the remaining 2316 // capabilities would be immutable capabilities. 2317 List<Integer> oldImmutableCapabilities = Arrays.stream(oldCapabilities.getCapabilities()) 2318 .boxed().collect(Collectors.toList()); 2319 oldImmutableCapabilities.removeAll(MUTABLE_CAPABILITIES); 2320 List<Integer> newImmutableCapabilities = Arrays.stream(newCapabilities.getCapabilities()) 2321 .boxed().collect(Collectors.toList()); 2322 newImmutableCapabilities.removeAll(MUTABLE_CAPABILITIES); 2323 return oldImmutableCapabilities.size() != newImmutableCapabilities.size() 2324 || !oldImmutableCapabilities.containsAll(newImmutableCapabilities); 2325 } 2326 2327 /** 2328 * In some rare cases we need to re-create the network agent, for example, underlying network 2329 * IP changed, or when we unfortunately need to remove/add a immutable network capability. 2330 */ 2331 private void recreateNetworkAgent() { 2332 if (isConnecting() || isDisconnected() || isDisconnecting()) { 2333 loge("Incorrect state for re-creating the network agent."); 2334 return; 2335 } 2336 2337 // Abandon the network agent because we are going to create a new one. 2338 mNetworkAgent.abandon(); 2339 // Create a new network agent and register with connectivity service. Note that the agent 2340 // will always be registered with NOT_SUSPENDED capability. 2341 mNetworkAgent = createNetworkAgent(); 2342 mNetworkAgent.markConnected(); 2343 notifyPreciseDataConnectionState(); 2344 // Because network agent is always created with NOT_SUSPENDED, we need to update 2345 // the suspended if it's was in suspended state. 2346 if (mSuspended) { 2347 log("recreateNetworkAgent: The network is in suspended state. Update the network" 2348 + " capability again. nc=" + mNetworkCapabilities); 2349 mNetworkAgent.sendNetworkCapabilities(mNetworkCapabilities); 2350 } 2351 } 2352 2353 /** 2354 * @return {@code true} if this is a satellite data network. 2355 */ 2356 public boolean isSatellite() { 2357 return mIsSatellite; 2358 } 2359 2360 /** 2361 * Update the network capabilities. 2362 */ 2363 private void updateNetworkCapabilities() { 2364 final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder(); 2365 2366 if (mIsSatellite && mDataConfigManager.getForcedCellularTransportCapabilities().stream() 2367 .noneMatch(this::hasNetworkCapabilityInNetworkRequests)) { 2368 builder.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE); 2369 } else { 2370 builder.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR); 2371 } 2372 2373 boolean roaming = mPhone.getServiceState().getDataRoaming(); 2374 2375 builder.setNetworkSpecifier(new TelephonyNetworkSpecifier.Builder() 2376 .setSubscriptionId(mSubId).build()); 2377 builder.setSubscriptionIds(Collections.singleton(mSubId)); 2378 2379 ApnSetting apnSetting = mDataProfile.getApnSetting(); 2380 2381 if (apnSetting != null) { 2382 apnSetting.getApnTypes().stream() 2383 .map(DataUtils::apnTypeToNetworkCapability) 2384 .filter(cap -> cap >= 0) 2385 .forEach(builder::addCapability); 2386 if (apnSetting.getApnTypes().contains(ApnSetting.TYPE_ENTERPRISE)) { 2387 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2388 } 2389 } 2390 2391 // If MMTEL capability is requested, we should not remove it because it's an immutable 2392 // capability defined by connectivity service. When the device enters from VoPS to non-VoPS, 2393 // we should perform grace tear down from data network controller if needed. 2394 if (hasNetworkCapabilityInNetworkRequests(NetworkCapabilities.NET_CAPABILITY_MMTEL)) { 2395 // Request has MMTEL, add it again so the network won't be unwanted by connectivity. 2396 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL); 2397 } else if (mDataProfile.canSatisfy(NetworkCapabilities.NET_CAPABILITY_IMS)) { 2398 // Request has IMS capability only. 2399 // Always add MMTEL capability on IMS network unless network explicitly indicates VoPS 2400 // not supported. 2401 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL); 2402 if (mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) { 2403 NetworkRegistrationInfo nri = getNetworkRegistrationInfo(); 2404 if (nri != null) { 2405 DataSpecificRegistrationInfo dsri = nri.getDataSpecificInfo(); 2406 // Check if the network is non-VoPS. 2407 if (dsri != null && dsri.getVopsSupportInfo() != null 2408 && !dsri.getVopsSupportInfo().isVopsSupported()) { 2409 builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL); 2410 } 2411 log("updateNetworkCapabilities: dsri=" + dsri); 2412 } 2413 } 2414 } 2415 2416 // Extract network capabilities from the traffic descriptor. 2417 for (TrafficDescriptor trafficDescriptor : mTrafficDescriptors) { 2418 try { 2419 if (trafficDescriptor.getOsAppId() == null) continue; 2420 OsAppId osAppId = new OsAppId(trafficDescriptor.getOsAppId()); 2421 if (!osAppId.getOsId().equals(OsAppId.ANDROID_OS_ID)) { 2422 loge("Received non-Android OS id " + osAppId.getOsId()); 2423 continue; 2424 } 2425 int networkCapability = DataUtils.getNetworkCapabilityFromString( 2426 osAppId.getAppId()); 2427 switch (networkCapability) { 2428 case NetworkCapabilities.NET_CAPABILITY_ENTERPRISE: 2429 builder.addCapability(networkCapability); 2430 // Always add internet if TD contains enterprise. 2431 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2432 builder.addEnterpriseId(osAppId.getDifferentiator()); 2433 break; 2434 case NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY: 2435 case NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH: 2436 case NetworkCapabilities.NET_CAPABILITY_CBS: 2437 builder.addCapability(networkCapability); 2438 break; 2439 default: 2440 loge("Invalid app id " + osAppId.getAppId()); 2441 } 2442 } catch (Exception e) { 2443 loge("Exception: " + e + ". Failed to create osAppId from " 2444 + new BigInteger(1, trafficDescriptor.getOsAppId()).toString(16)); 2445 } 2446 } 2447 2448 if (!mCongested) { 2449 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED); 2450 } 2451 2452 if (mTempNotMeteredSupported && mTempNotMetered) { 2453 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED); 2454 } 2455 2456 // Always start with NOT_VCN_MANAGED, then remove if VcnManager indicates this is part of a 2457 // VCN. 2458 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED); 2459 final VcnNetworkPolicyResult vcnPolicy = getVcnPolicy(builder.build()); 2460 if (vcnPolicy != null && !vcnPolicy.getNetworkCapabilities() 2461 .hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)) { 2462 builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED); 2463 } 2464 2465 if (!roaming) { 2466 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING); 2467 } 2468 2469 if (!mSuspended) { 2470 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED); 2471 } 2472 2473 if (mCarrierServicePackageUid != Process.INVALID_UID 2474 && ArrayUtils.contains(mAdministratorUids, mCarrierServicePackageUid)) { 2475 builder.setOwnerUid(mCarrierServicePackageUid); 2476 builder.setAllowedUids(Collections.singleton(mCarrierServicePackageUid)); 2477 } 2478 builder.setAdministratorUids(mAdministratorUids); 2479 2480 Set<Integer> meteredCapabilities = mDataConfigManager 2481 .getMeteredNetworkCapabilities(roaming).stream() 2482 .filter(cap -> mAccessNetworksManager.getPreferredTransportByNetworkCapability(cap) 2483 == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 2484 .collect(Collectors.toSet()); 2485 boolean unmeteredNetwork = meteredCapabilities.stream().noneMatch( 2486 Arrays.stream(builder.build().getCapabilities()).boxed() 2487 .collect(Collectors.toSet())::contains); 2488 2489 if (unmeteredNetwork) { 2490 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED); 2491 } 2492 2493 // Always start with not-restricted, and then remove if needed. 2494 // By default, NET_CAPABILITY_NOT_RESTRICTED and NET_CAPABILITY_NOT_CONSTRAINED are included 2495 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2496 2497 // When data is disabled, or data roaming is disabled and the device is roaming, we need 2498 // to remove certain capabilities depending on scenarios. 2499 if (!mDataNetworkController.getDataSettingsManager().isDataEnabled() 2500 || (mPhone.getServiceState().getDataRoaming() 2501 && !mDataNetworkController.getDataSettingsManager().isDataRoamingEnabled())) { 2502 // If data is allowed because the request is a restricted network request, we need 2503 // to mark the network as restricted when data is disabled or data roaming is disabled 2504 // and the device is roaming. If we don't do that, non-privileged apps will be able 2505 // to use this network when data is disabled. 2506 if (mDataAllowedReason == DataAllowedReason.RESTRICTED_REQUEST) { 2507 builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2508 } else if (mDataAllowedReason == DataAllowedReason.UNMETERED_USAGE 2509 || mDataAllowedReason == DataAllowedReason.MMS_REQUEST 2510 || mDataAllowedReason == DataAllowedReason.EMERGENCY_SUPL) { 2511 // If data is allowed due to unmetered usage, or MMS always-allowed, we need to 2512 // remove unrelated-but-metered capabilities. 2513 for (int capability : meteredCapabilities) { 2514 // 1. If it's unmetered usage, remove all metered capabilities. 2515 // 2. If it's MMS always-allowed, then remove all metered capabilities but MMS. 2516 // 3/ If it's for emergency SUPL, then remove all metered capabilities but SUPL. 2517 if ((capability == NetworkCapabilities.NET_CAPABILITY_MMS 2518 && mDataAllowedReason == DataAllowedReason.MMS_REQUEST) 2519 || (capability == NetworkCapabilities.NET_CAPABILITY_SUPL 2520 && mDataAllowedReason == DataAllowedReason.EMERGENCY_SUPL)) { 2521 // Not removing the capability for special uses. 2522 continue; 2523 } 2524 builder.removeCapability(capability); 2525 } 2526 } 2527 } 2528 2529 if (mDataNetworkController.isEsimBootStrapProvisioningActivated()) { 2530 builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2531 } 2532 2533 // Check if the feature force MMS on IWLAN is enabled. When the feature is enabled, MMS 2534 // will be attempted on IWLAN if possible, even if existing cellular networks already 2535 // supports IWLAN. 2536 if (builder.build().hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)) { 2537 // If QNS sets MMS preferred on IWLAN, and it is possible to setup an MMS network on 2538 // IWLAN, then we need to remove the MMS capability on the cellular network. This will 2539 // allow the new MMS network to be brought up on IWLAN when MMS network request arrives. 2540 if (mAccessNetworksManager.getPreferredTransportByNetworkCapability( 2541 NetworkCapabilities.NET_CAPABILITY_MMS) 2542 == AccessNetworkConstants.TRANSPORT_TYPE_WLAN && mTransport 2543 == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) { 2544 2545 DataProfile dataProfile = mDataNetworkController.getDataProfileManager() 2546 .getDataProfileForNetworkRequest(new TelephonyNetworkRequest( 2547 new NetworkRequest.Builder().addCapability( 2548 NetworkCapabilities.NET_CAPABILITY_MMS).build(), mPhone, mFlags), 2549 TelephonyManager.NETWORK_TYPE_IWLAN, false, false, false); 2550 // If we find another data data profile that can support MMS on IWLAN, then remove 2551 // the MMS capability from this cellular network. This will allow IWLAN to be 2552 // brought up for MMS later. 2553 if (dataProfile != null && !dataProfile.getApn().equals(mDataProfile.getApn())) { 2554 log("Found a different apn name " + mDataProfile.getApn() 2555 + " that can serve MMS on IWLAN."); 2556 builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 2557 } 2558 } 2559 } 2560 2561 // If one of the capabilities are for special use, for example, IMS, CBS, then this 2562 // network should be restricted, regardless data is enabled or not. 2563 if (NetworkCapabilitiesUtils.inferRestrictedCapability(builder.build()) 2564 || (vcnPolicy != null && !vcnPolicy.getNetworkCapabilities() 2565 .hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED))) { 2566 builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2567 } 2568 2569 // Set the bandwidth information. 2570 builder.setLinkDownstreamBandwidthKbps(mNetworkBandwidth.downlinkBandwidthKbps); 2571 builder.setLinkUpstreamBandwidthKbps(mNetworkBandwidth.uplinkBandwidthKbps); 2572 2573 // Configure the network as restricted/constrained for unrestricted satellite network. 2574 if (mIsSatellite && builder.build().hasCapability( 2575 NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)) { 2576 2577 int dataPolicy; 2578 if (mFlags.dataServiceCheck()) { 2579 final SatelliteController satelliteController = SatelliteController.getInstance(); 2580 dataPolicy = satelliteController.getSatelliteDataServicePolicyForPlmn(mSubId, 2581 mPhone.getServiceState().getOperatorNumeric()); 2582 } else { 2583 dataPolicy = mDataConfigManager.getSatelliteDataSupportMode(); 2584 } 2585 switch (dataPolicy) { 2586 case CarrierConfigManager.SATELLITE_DATA_SUPPORT_ONLY_RESTRICTED 2587 -> builder.removeCapability( 2588 NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2589 case CarrierConfigManager.SATELLITE_DATA_SUPPORT_BANDWIDTH_CONSTRAINED -> { 2590 try { 2591 builder.removeCapability(DataUtils 2592 .NET_CAPABILITY_NOT_BANDWIDTH_CONSTRAINED); 2593 } catch (Exception ignored) { } 2594 } 2595 // default case CarrierConfigManager.SATELLITE_DATA_SUPPORT_ALL 2596 } 2597 } 2598 2599 NetworkCapabilities nc = builder.build(); 2600 if (mNetworkCapabilities == null || mNetworkAgent == null) { 2601 // This is the first time when network capabilities is created. The agent is not created 2602 // at this time. Just return here. The network capabilities will be used when network 2603 // agent is created. 2604 mNetworkCapabilities = nc; 2605 logl("Initial capabilities " + mNetworkCapabilities); 2606 return; 2607 } 2608 2609 if (!nc.equals(mNetworkCapabilities)) { 2610 // Check if we are changing the immutable capabilities. Note that we should be very 2611 // careful and limit the use cases of changing immutable capabilities. Connectivity 2612 // service would not close sockets for clients if a network request becomes 2613 // unsatisfiable. 2614 if (mEverConnected && areImmutableCapabilitiesChanged(mNetworkCapabilities, nc) 2615 && (isConnected() || isHandoverInProgress())) { 2616 // Before connectivity service supports making all capabilities mutable, it is 2617 // suggested to de-register and re-register the network agent if it is needed to 2618 // add/remove immutable capabilities. 2619 logl("updateNetworkCapabilities: Immutable capabilities changed. Re-create the " 2620 + "network agent. Attempted to change from " + mNetworkCapabilities + " to " 2621 + nc); 2622 mNetworkCapabilities = nc; 2623 recreateNetworkAgent(); 2624 } else { 2625 // Now we need to inform connectivity service and data network controller 2626 // about the capabilities changed. 2627 mNetworkCapabilities = nc; 2628 log("Capabilities changed to " + mNetworkCapabilities); 2629 mNetworkAgent.sendNetworkCapabilities(mNetworkCapabilities); 2630 } 2631 2632 // Only retry the request when the network is in connected or handover state. This is to 2633 // prevent request is detached during connecting state, and then become a setup/detach 2634 // infinite loop. 2635 boolean shouldRetry = isConnected() || isHandoverInProgress(); 2636 removeUnsatisfiedNetworkRequests(shouldRetry); 2637 mDataNetworkCallback.invokeFromExecutor(() -> mDataNetworkCallback 2638 .onNetworkCapabilitiesChanged(DataNetwork.this)); 2639 } else { 2640 log("updateNetworkCapabilities: Capabilities not changed."); 2641 } 2642 } 2643 2644 /** 2645 * @return The network capabilities of this data network. 2646 */ 2647 @NonNull 2648 public NetworkCapabilities getNetworkCapabilities() { 2649 return mNetworkCapabilities; 2650 } 2651 2652 /** 2653 * @return The link properties of this data network. 2654 */ 2655 @NonNull 2656 public LinkProperties getLinkProperties() { 2657 return mLinkProperties; 2658 } 2659 2660 /** 2661 * @return The data profile of this data network. 2662 */ 2663 @NonNull 2664 public DataProfile getDataProfile() { 2665 return mDataProfile; 2666 } 2667 2668 /** 2669 * Update data suspended state. 2670 */ 2671 private void updateSuspendState() { 2672 if (isConnecting() || isDisconnected()) { 2673 // Return if not in the right state. 2674 return; 2675 } 2676 2677 boolean newSuspendedState = false; 2678 // Get the uncombined service state directly. 2679 NetworkRegistrationInfo nri = getNetworkRegistrationInfo(); 2680 if (nri == null) return; 2681 2682 // Never set suspended for emergency apn. Emergency data connection 2683 // can work while device is not in service. 2684 if (mNetworkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_EIMS)) { 2685 // If we are not in service, change to suspended. 2686 } else if (nri.getRegistrationState() 2687 != NetworkRegistrationInfo.REGISTRATION_STATE_HOME 2688 && nri.getRegistrationState() 2689 != NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING) { 2690 newSuspendedState = true; 2691 // Check voice/data concurrency. 2692 } else if (!mPhone.getServiceStateTracker().isConcurrentVoiceAndDataAllowed() 2693 && mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN 2694 && mPhone.getCallTracker() != null) { 2695 newSuspendedState = mPhone.getCallTracker().getState() != PhoneConstants.State.IDLE; 2696 } 2697 2698 // Only notify when there is a change. 2699 if (mSuspended != newSuspendedState) { 2700 mSuspended = newSuspendedState; 2701 logl("Network becomes " + (mSuspended ? "suspended" : "unsuspended")); 2702 // To update NOT_SUSPENDED capability. 2703 updateNetworkCapabilities(); 2704 notifyPreciseDataConnectionState(); 2705 mDataNetworkCallback.invokeFromExecutor(() -> 2706 mDataNetworkCallback.onSuspendedStateChanged(DataNetwork.this, mSuspended)); 2707 } 2708 } 2709 2710 /** 2711 * Allocate PDU session ID from the modem. This is only needed when the data network is 2712 * initiated on IWLAN. 2713 */ 2714 private void allocatePduSessionId() { 2715 mRil.allocatePduSessionId(obtainMessage(EVENT_ALLOCATE_PDU_SESSION_ID_RESPONSE)); 2716 } 2717 2718 /** 2719 * Get fail cause from {@link DataCallResponse} and the result code. 2720 * 2721 * @param resultCode The result code returned from 2722 * {@link DataServiceCallback#onSetupDataCallComplete(int, DataCallResponse)}. 2723 * @param response The data call response returned from 2724 * {@link DataServiceCallback#onSetupDataCallComplete(int, DataCallResponse)}. 2725 * 2726 * @return The fail cause. {@link DataFailCause#NONE} if succeeds. 2727 */ 2728 @DataFailureCause 2729 private int getFailCauseFromDataCallResponse( 2730 @DataServiceCallback.ResultCode int resultCode, @Nullable DataCallResponse response) { 2731 int failCause = DataFailCause.NONE; 2732 switch (resultCode) { 2733 case DataServiceCallback.RESULT_ERROR_ILLEGAL_STATE: 2734 failCause = DataFailCause.RADIO_NOT_AVAILABLE; 2735 break; 2736 case DataServiceCallback.RESULT_ERROR_BUSY: 2737 case DataServiceCallback.RESULT_ERROR_TEMPORARILY_UNAVAILABLE: 2738 failCause = DataFailCause.SERVICE_TEMPORARILY_UNAVAILABLE; 2739 break; 2740 case DataServiceCallback.RESULT_ERROR_INVALID_ARG: 2741 failCause = DataFailCause.UNACCEPTABLE_NETWORK_PARAMETER; 2742 break; 2743 case DataServiceCallback.RESULT_ERROR_UNSUPPORTED: 2744 failCause = DataFailCause.REQUEST_NOT_SUPPORTED; 2745 break; 2746 case DataServiceCallback.RESULT_SUCCESS: 2747 if (response != null) { 2748 failCause = DataFailCause.getFailCause(response.getCause()); 2749 } 2750 break; 2751 } 2752 return failCause; 2753 } 2754 2755 /** 2756 * Update data network based on the latest {@link DataCallResponse}. 2757 * 2758 * @param response The data call response from data service. 2759 */ 2760 private void updateDataNetwork(@Nullable DataCallResponse response) { 2761 if (response == null) return; 2762 mCid.put(mTransport, response.getId()); 2763 LinkProperties linkProperties = new LinkProperties(); 2764 2765 // Set interface name 2766 linkProperties.setInterfaceName(response.getInterfaceName()); 2767 2768 // Set PDU session id 2769 if (mPduSessionId != response.getPduSessionId()) { 2770 mPduSessionId = response.getPduSessionId(); 2771 log("PDU session id updated to " + mPduSessionId); 2772 } 2773 2774 // Set the link status 2775 if (mLinkStatus != response.getLinkStatus()) { 2776 mLinkStatus = response.getLinkStatus(); 2777 log("Link status updated to " + DataUtils.linkStatusToString(mLinkStatus)); 2778 if (isConnected()) { 2779 // If the data network is in a transition state, the link status will be notified 2780 // upon entering connected or disconnected state. If the data network is already 2781 // connected, send the updated link status from the updated data call response. 2782 mDataNetworkCallback.invokeFromExecutor(() -> mDataNetworkCallback 2783 .onLinkStatusChanged(DataNetwork.this, mLinkStatus)); 2784 } 2785 } 2786 2787 // Set link addresses 2788 if (!response.getAddresses().isEmpty()) { 2789 for (LinkAddress la : response.getAddresses()) { 2790 if (!la.getAddress().isAnyLocalAddress()) { 2791 logv("addr/pl=" + la.getAddress() + "/" + la.getPrefixLength()); 2792 linkProperties.addLinkAddress(la); 2793 } 2794 } 2795 } else { 2796 loge("no address for ifname=" + response.getInterfaceName()); 2797 } 2798 2799 // Set DNS servers 2800 if (!response.getDnsAddresses().isEmpty()) { 2801 for (InetAddress dns : response.getDnsAddresses()) { 2802 if (!dns.isAnyLocalAddress()) { 2803 linkProperties.addDnsServer(dns); 2804 } 2805 } 2806 } else { 2807 loge("Empty dns response"); 2808 } 2809 2810 // Set PCSCF 2811 if (!response.getPcscfAddresses().isEmpty()) { 2812 for (InetAddress pcscf : response.getPcscfAddresses()) { 2813 linkProperties.addPcscfServer(pcscf); 2814 } 2815 } 2816 2817 // For backwards compatibility, use getMtu() if getMtuV4() is not available. 2818 int mtuV4 = response.getMtuV4() > 0 ? response.getMtuV4() : response.getMtu(); 2819 2820 if (mtuV4 <= 0) { 2821 // Use back up value from data profile. 2822 if (mDataProfile.getApnSetting() != null) { 2823 mtuV4 = mDataProfile.getApnSetting().getMtuV4(); 2824 } 2825 if (mtuV4 <= 0) { 2826 mtuV4 = mDataConfigManager.getDefaultMtu(); 2827 } 2828 } 2829 2830 // For backwards compatibility, use getMtu() if getMtuV6() is not available. 2831 int mtuV6 = response.getMtuV6() > 0 ? response.getMtuV6() : response.getMtu(); 2832 if (mtuV6 <= 0) { 2833 // Use back up value from data profile. 2834 if (mDataProfile.getApnSetting() != null) { 2835 mtuV6 = mDataProfile.getApnSetting().getMtuV6(); 2836 } 2837 if (mtuV6 <= 0) { 2838 mtuV6 = mDataConfigManager.getDefaultMtu(); 2839 } 2840 } 2841 2842 // Set MTU for each route. 2843 for (InetAddress gateway : response.getGatewayAddresses()) { 2844 int mtu = gateway instanceof java.net.Inet6Address ? mtuV6 : mtuV4; 2845 linkProperties.addRoute(new RouteInfo(null, gateway, null, 2846 RouteInfo.RTN_UNICAST, mtu)); 2847 } 2848 2849 // LinkProperties.setMtu should be deprecated. The mtu for each route has been already 2850 // provided in addRoute() above. For backwards compatibility, we still need to provide 2851 // a value for the legacy MTU. Use the higher value of v4 and v6 value here. 2852 linkProperties.setMtu(Math.max(mtuV4, mtuV6)); 2853 2854 if (mDataProfile.getApnSetting() != null 2855 && !TextUtils.isEmpty(mDataProfile.getApnSetting().getProxyAddressAsString())) { 2856 int port = mDataProfile.getApnSetting().getProxyPort(); 2857 if (port == -1) { 2858 port = 8080; 2859 } 2860 ProxyInfo proxy = ProxyInfo.buildDirectProxy( 2861 mDataProfile.getApnSetting().getProxyAddressAsString(), port); 2862 linkProperties.setHttpProxy(proxy); 2863 } 2864 2865 linkProperties.setTcpBufferSizes(mTcpBufferSizes); 2866 2867 mNetworkSliceInfo = response.getSliceInfo(); 2868 2869 mTrafficDescriptors.clear(); 2870 mTrafficDescriptors.addAll(response.getTrafficDescriptors()); 2871 2872 mDefaultQos = response.getDefaultQos(); 2873 2874 2875 Set<QosBearerSession> newSessions = new HashSet<>(response.getQosBearerSessions()); 2876 if (newSessions.size() != mQosBearerSessions.size() 2877 || !newSessions.containsAll(mQosBearerSessions)) { 2878 mDataNetworkCallback.onQosSessionsChanged(response.getQosBearerSessions()); 2879 } 2880 mQosBearerSessions.clear(); 2881 mQosBearerSessions.addAll(response.getQosBearerSessions()); 2882 if (mQosCallbackTracker != null) { 2883 mQosCallbackTracker.updateSessions(mQosBearerSessions); 2884 } 2885 2886 if (!linkProperties.equals(mLinkProperties)) { 2887 // If the new link properties is not compatible (e.g. IP changes, interface changes), 2888 // then we should de-register the network agent and re-create a new one. 2889 if ((isConnected() || isHandoverInProgress()) 2890 && !isLinkPropertiesCompatible(mLinkProperties, linkProperties)) { 2891 logl("updateDataNetwork: Incompatible link properties detected. Re-create the " 2892 + "network agent. Changed from " + mLinkProperties + " to " 2893 + linkProperties); 2894 2895 mLinkProperties = linkProperties; 2896 recreateNetworkAgent(); 2897 } else { 2898 mLinkProperties = linkProperties; 2899 log("sendLinkProperties " + mLinkProperties); 2900 mNetworkAgent.sendLinkProperties(mLinkProperties); 2901 } 2902 } 2903 2904 updateNetworkCapabilities(); 2905 updateValidationStatus(response.getNetworkValidationStatus()); 2906 } 2907 2908 /** 2909 * If the {@link DataCallResponse} contains invalid info, triggers an anomaly report. 2910 * 2911 * @param response The response to be validated 2912 * @param setupRegState Registration state if the response is for initial data call setup. 2913 */ 2914 private void validateDataCallResponse(@Nullable DataCallResponse response, 2915 @NetworkRegistrationInfo.RegistrationState int setupRegState) { 2916 if (response == null 2917 || response.getLinkStatus() == DataCallResponse.LINK_STATUS_INACTIVE) return; 2918 int failCause = response.getCause(); 2919 if (failCause == DataFailCause.NONE) { 2920 if (TextUtils.isEmpty(response.getInterfaceName()) 2921 || response.getAddresses().isEmpty() 2922 // if out of range 2923 || response.getLinkStatus() < DataCallResponse.LINK_STATUS_UNKNOWN 2924 || response.getLinkStatus() > DataCallResponse.LINK_STATUS_ACTIVE 2925 || response.getProtocolType() < ApnSetting.PROTOCOL_UNKNOWN 2926 || response.getProtocolType() > ApnSetting.PROTOCOL_UNSTRUCTURED 2927 || response.getHandoverFailureMode() 2928 < DataCallResponse.HANDOVER_FAILURE_MODE_UNKNOWN 2929 || response.getHandoverFailureMode() 2930 > DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_SETUP_NORMAL) { 2931 loge("Invalid DataCallResponse:" + response); 2932 reportAnomaly("Invalid DataCallResponse detected", 2933 "1f273e9d-b09c-46eb-ad1c-421d01f61164"); 2934 } 2935 // Check IP for initial setup response 2936 NetworkRegistrationInfo nri = getNetworkRegistrationInfo(); 2937 if (setupRegState != -1 // Is setup response 2938 && mDataProfile.getApnSetting() != null && nri != null && nri.isInService()) { 2939 boolean wasRoaming = setupRegState 2940 == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING; 2941 boolean isRoaming = nri.getNetworkRegistrationState() 2942 == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING; 2943 if (wasRoaming == isRoaming) { // Ignore check if in race condition. 2944 int protocol = isRoaming ? mDataProfile.getApnSetting().getRoamingProtocol() 2945 : mDataProfile.getApnSetting().getProtocol(); 2946 String underlyingDataService = mTransport 2947 == AccessNetworkConstants.TRANSPORT_TYPE_WWAN 2948 ? "RIL" : "IWLAN data service"; 2949 if (protocol == ApnSetting.PROTOCOL_IP) { 2950 if (response.getAddresses().stream().noneMatch( 2951 la -> la.getAddress() instanceof java.net.Inet4Address)) { 2952 loge("Invalid DataCallResponse. Requested IPv4 but didn't get an " 2953 + "IPv4 address." + response); 2954 reportAnomaly(underlyingDataService + " reported mismatched IP " 2955 + "type. Requested IPv4 but didn't get an IPv4 " 2956 + "address.", "7744f920-fb64-4db0-ba47-de0eae485a82"); 2957 } 2958 } else if (protocol == ApnSetting.PROTOCOL_IPV6) { 2959 if (response.getAddresses().stream().noneMatch( 2960 la -> la.getAddress() instanceof java.net.Inet6Address)) { 2961 loge("Invalid DataCallResponse. Requested IPv6 but didn't get an " 2962 + "IPv6 address." + response); 2963 reportAnomaly(underlyingDataService + " reported mismatched IP " 2964 + "type. Requested IPv6 but didn't get an IPv6 " 2965 + "address.", "7744f920-fb64-4db0-ba47-de0eae485a82"); 2966 } 2967 } 2968 } 2969 } 2970 } else if (!DataFailCause.isFailCauseExisting(failCause)) { // Setup data failed. 2971 loge("Invalid DataFailCause in " + response); 2972 reportAnomaly("Invalid DataFailCause: (0x" + Integer.toHexString(failCause) 2973 + ")", 2974 "6b264f28-9f58-4cbd-9e0e-d7624ba30879"); 2975 } 2976 } 2977 2978 /** 2979 * Called when receiving deactivate data network response from the data service. 2980 * 2981 * @param resultCode The result code. 2982 */ 2983 private void onDeactivateResponse(@DataServiceCallback.ResultCode int resultCode) { 2984 logl("onDeactivateResponse: resultCode=" 2985 + DataServiceCallback.resultCodeToString(resultCode)); 2986 if (resultCode == DataServiceCallback.RESULT_ERROR_ILLEGAL_STATE) { 2987 log("Remove network since deactivate request returned an error."); 2988 mFailCause = DataFailCause.RADIO_NOT_AVAILABLE; 2989 transitionTo(mDisconnectedState); 2990 } else if (mPhone.getHalVersion(HAL_SERVICE_DATA).less(RIL.RADIO_HAL_VERSION_2_0)) { 2991 log("Remove network on deactivate data response on old HAL " 2992 + mPhone.getHalVersion(HAL_SERVICE_DATA)); 2993 mFailCause = DataFailCause.LOST_CONNECTION; 2994 transitionTo(mDisconnectedState); 2995 } 2996 } 2997 2998 /** 2999 * Tear down the data network immediately. 3000 * 3001 * @param reason The reason of tearing down the network. 3002 */ 3003 public void tearDown(@TearDownReason int reason) { 3004 if (getCurrentState() == null || isDisconnected()) { 3005 return; 3006 } 3007 mTearDownReason = reason; 3008 sendMessage(obtainMessage(EVENT_TEAR_DOWN_NETWORK, reason)); 3009 } 3010 3011 private void onTearDown(@TearDownReason int reason) { 3012 logl("onTearDown: reason=" + tearDownReasonToString(reason)); 3013 3014 // track frequent NetworkAgent.onNetworkUnwanted() call of IMS and INTERNET 3015 if (reason == TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED 3016 && isConnected() 3017 && (mNetworkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS) 3018 || mNetworkCapabilities.hasCapability( 3019 NetworkCapabilities.NET_CAPABILITY_INTERNET))) { 3020 mDataNetworkCallback.onTrackNetworkUnwanted(this); 3021 } 3022 3023 mDataServiceManagers.get(mTransport).deactivateDataCall(mCid.get(mTransport), 3024 reason == TEAR_DOWN_REASON_AIRPLANE_MODE_ON ? DataService.REQUEST_REASON_SHUTDOWN 3025 : DataService.REQUEST_REASON_NORMAL, 3026 obtainMessage(EVENT_DEACTIVATE_DATA_NETWORK_RESPONSE)); 3027 mDataCallSessionStats.setDeactivateDataCallReason(reason); 3028 mInvokedDataDeactivation = true; 3029 } 3030 3031 /** 3032 * @return {@code true} if we shall delay tear down this network because an active voice call is 3033 * relying on it and 3034 * {@link CarrierConfigManager#KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL} is enabled. 3035 */ 3036 public boolean shouldDelayImsTearDownDueToInCall() { 3037 return mDataConfigManager.isImsDelayTearDownUntilVoiceCallEndEnabled() 3038 && mNetworkCapabilities != null 3039 && mNetworkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS) 3040 && mPhone.getImsPhone() != null 3041 && mPhone.getImsPhone().getCallTracker().getState() 3042 != PhoneConstants.State.IDLE; 3043 } 3044 3045 /** 3046 * Tear down the data network when condition is met or timed out. Data network will enter 3047 * {@link DisconnectingState} immediately and waiting for condition met. When condition is met, 3048 * {@link DataNetworkController} should invoke {@link Consumer#accept(Object)} so the actual 3049 * tear down work can be performed. 3050 * 3051 * This is primarily used for IMS graceful tear down. {@link DataNetworkController} inform 3052 * {@link DataNetwork} to enter {@link DisconnectingState}. IMS service can observe this 3053 * through {@link PreciseDataConnectionState#getState()} and then perform IMS de-registration 3054 * work. After IMS de-registered, {@link DataNetworkController} informs {@link DataNetwork} 3055 * that it's okay to tear down the network. 3056 * 3057 * @param reason The tear down reason. 3058 * 3059 * @param timeoutMillis Timeout in milliseconds. Within the time window, clients will have to 3060 * call {@link Consumer#accept(Object)}, otherwise, data network will be torn down when 3061 * timed out. 3062 * 3063 * @return The runnable for client to execute when condition is met. When executed, tear down 3064 * will be performed. {@code null} if the data network is already disconnected or being 3065 * disconnected. 3066 */ 3067 @Nullable 3068 public Runnable tearDownWhenConditionMet(@TearDownReason int reason, long timeoutMillis) { 3069 if (getCurrentState() == null || isDisconnected() || isDisconnecting()) { 3070 loge("tearDownWhenConditionMet: Not in the right state. State=" + getCurrentState()); 3071 return null; 3072 } 3073 logl("tearDownWhenConditionMet: reason=" + tearDownReasonToString(reason) + ", timeout=" 3074 + timeoutMillis + "ms."); 3075 sendMessage(EVENT_WAITING_FOR_TEARING_DOWN_CONDITION_MET, reason, (int) timeoutMillis); 3076 return () -> this.tearDown(reason); 3077 } 3078 3079 /** 3080 * Called when receiving {@link DataServiceCallback#onDataCallListChanged(List)} from the data 3081 * service. 3082 * 3083 * @param transport The transport where this event from. 3084 * @param responseList The data call response list. 3085 */ 3086 private void onDataStateChanged(@TransportType int transport, 3087 @NonNull List<DataCallResponse> responseList) { 3088 // Ignore the update if it's not from the data service on the right transport. 3089 // Also if never received data call response from setup call response, which updates the 3090 // cid, ignore the update here. 3091 logv("onDataStateChanged: " + responseList); 3092 if (transport != mTransport || mCid.get(mTransport) == INVALID_CID || isDisconnected()) { 3093 return; 3094 } 3095 3096 DataCallResponse response = responseList.stream() 3097 .filter(r -> mCid.get(mTransport) == r.getId()) 3098 .findFirst() 3099 .orElse(null); 3100 if (response != null) { 3101 if (!response.equals(mDataCallResponse)) { 3102 log("onDataStateChanged: " + response); 3103 validateDataCallResponse(response, -1 /*setupRegState setup only*/); 3104 mDataCallResponse = response; 3105 if (response.getLinkStatus() != DataCallResponse.LINK_STATUS_INACTIVE) { 3106 updateDataNetwork(response); 3107 notifyPreciseDataConnectionState(); 3108 } else { 3109 log("onDataStateChanged: PDN inactive reported by " 3110 + AccessNetworkConstants.transportTypeToString(mTransport) 3111 + " data service."); 3112 mFailCause = mEverConnected ? response.getCause() 3113 : DataFailCause.NO_RETRY_FAILURE; 3114 mRetryDelayMillis = DataCallResponse.RETRY_DURATION_UNDEFINED; 3115 transitionTo(mDisconnectedState); 3116 } 3117 } 3118 } else { 3119 // The data call response is missing from the list. This means the PDN is gone. This 3120 // is the PDN lost reported by the modem. We don't send another DEACTIVATE_DATA request 3121 // for that 3122 log("onDataStateChanged: PDN disconnected reported by " 3123 + AccessNetworkConstants.transportTypeToString(mTransport) + " data service."); 3124 mFailCause = mEverConnected ? DataFailCause.LOST_CONNECTION 3125 : DataFailCause.NO_RETRY_FAILURE; 3126 mRetryDelayMillis = DataCallResponse.RETRY_DURATION_UNDEFINED; 3127 transitionTo(mDisconnectedState); 3128 } 3129 } 3130 3131 /** 3132 * Called when carrier config updated. 3133 */ 3134 private void onCarrierConfigUpdated() { 3135 log("onCarrierConfigUpdated"); 3136 3137 updateBandwidthFromDataConfig(); 3138 updateTcpBufferSizes(); 3139 updateMeteredAndCongested(); 3140 } 3141 3142 /** 3143 * Called when receiving bandwidth update from the modem. 3144 * 3145 * @param linkCapacityEstimates The link capacity estimate list from the modem. 3146 */ 3147 private void onBandwidthUpdatedFromModem( 3148 @NonNull List<LinkCapacityEstimate> linkCapacityEstimates) { 3149 Objects.requireNonNull(linkCapacityEstimates); 3150 if (linkCapacityEstimates.isEmpty()) return; 3151 3152 int uplinkBandwidthKbps = 0, downlinkBandwidthKbps = 0; 3153 for (LinkCapacityEstimate linkCapacityEstimate : linkCapacityEstimates) { 3154 if (linkCapacityEstimate.getType() == LinkCapacityEstimate.LCE_TYPE_COMBINED) { 3155 uplinkBandwidthKbps = linkCapacityEstimate.getUplinkCapacityKbps(); 3156 downlinkBandwidthKbps = linkCapacityEstimate.getDownlinkCapacityKbps(); 3157 break; 3158 } else if (linkCapacityEstimate.getType() == LinkCapacityEstimate.LCE_TYPE_PRIMARY 3159 || linkCapacityEstimate.getType() == LinkCapacityEstimate.LCE_TYPE_SECONDARY) { 3160 uplinkBandwidthKbps += linkCapacityEstimate.getUplinkCapacityKbps(); 3161 downlinkBandwidthKbps += linkCapacityEstimate.getDownlinkCapacityKbps(); 3162 } else { 3163 loge("Invalid LinkCapacityEstimate type " + linkCapacityEstimate.getType()); 3164 } 3165 } 3166 onBandwidthUpdated(uplinkBandwidthKbps, downlinkBandwidthKbps); 3167 } 3168 3169 /** 3170 * Called when bandwidth estimation updated from either modem or the bandwidth estimator. 3171 * 3172 * @param uplinkBandwidthKbps Uplink bandwidth estimate in Kbps. 3173 * @param downlinkBandwidthKbps Downlink bandwidth estimate in Kbps. 3174 */ 3175 private void onBandwidthUpdated(int uplinkBandwidthKbps, int downlinkBandwidthKbps) { 3176 log("onBandwidthUpdated: downlinkBandwidthKbps=" + downlinkBandwidthKbps 3177 + ", uplinkBandwidthKbps=" + uplinkBandwidthKbps); 3178 NetworkBandwidth bandwidthFromConfig = mDataConfigManager.getBandwidthForNetworkType( 3179 mTelephonyDisplayInfo); 3180 3181 if (downlinkBandwidthKbps == LinkCapacityEstimate.INVALID) { 3182 // Fallback to carrier config. 3183 downlinkBandwidthKbps = bandwidthFromConfig.downlinkBandwidthKbps; 3184 } 3185 3186 if (uplinkBandwidthKbps == LinkCapacityEstimate.INVALID) { 3187 // Fallback to carrier config. 3188 uplinkBandwidthKbps = bandwidthFromConfig.uplinkBandwidthKbps; 3189 } 3190 3191 // Make sure uplink is not greater than downlink. 3192 uplinkBandwidthKbps = Math.min(uplinkBandwidthKbps, downlinkBandwidthKbps); 3193 mNetworkBandwidth = new NetworkBandwidth(downlinkBandwidthKbps, uplinkBandwidthKbps); 3194 3195 updateNetworkCapabilities(); 3196 } 3197 3198 /** 3199 * Called when {@link TelephonyDisplayInfo} changed. This can happen when network types or 3200 * override network types (5G NSA, 5G MMWAVE) change. 3201 */ 3202 private void onDisplayInfoChanged() { 3203 mTelephonyDisplayInfo = mPhone.getDisplayInfoController().getTelephonyDisplayInfo(); 3204 updateBandwidthFromDataConfig(); 3205 updateTcpBufferSizes(); 3206 updateMeteredAndCongested(); 3207 } 3208 3209 /** 3210 * Update the bandwidth from carrier config. Note this is no-op if the bandwidth source is not 3211 * carrier config. 3212 */ 3213 private void updateBandwidthFromDataConfig() { 3214 if (mDataConfigManager.getBandwidthEstimateSource() != BANDWIDTH_SOURCE_CARRIER_CONFIG) { 3215 return; 3216 } 3217 log("updateBandwidthFromDataConfig"); 3218 mNetworkBandwidth = mDataConfigManager.getBandwidthForNetworkType(mTelephonyDisplayInfo); 3219 updateNetworkCapabilities(); 3220 } 3221 3222 /** 3223 * Update the TCP buffer sizes from resource overlays. 3224 */ 3225 private void updateTcpBufferSizes() { 3226 log("updateTcpBufferSizes"); 3227 mTcpBufferSizes = mDataConfigManager.getTcpConfigString(mTelephonyDisplayInfo); 3228 LinkProperties linkProperties = new LinkProperties(mLinkProperties); 3229 linkProperties.setTcpBufferSizes(mTcpBufferSizes); 3230 if (!linkProperties.equals(mLinkProperties)) { 3231 mLinkProperties = linkProperties; 3232 log("sendLinkProperties " + mLinkProperties); 3233 mNetworkAgent.sendLinkProperties(mLinkProperties); 3234 } 3235 } 3236 3237 /** 3238 * Update the metered and congested values from carrier configs and subscription overrides 3239 */ 3240 private void updateMeteredAndCongested() { 3241 int networkType = mTelephonyDisplayInfo.getNetworkType(); 3242 switch (mTelephonyDisplayInfo.getOverrideNetworkType()) { 3243 case TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NR_ADVANCED: 3244 case TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NR_NSA: 3245 networkType = TelephonyManager.NETWORK_TYPE_NR; 3246 break; 3247 case TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_LTE_ADVANCED_PRO: 3248 case TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_LTE_CA: 3249 networkType = TelephonyManager.NETWORK_TYPE_LTE_CA; 3250 break; 3251 } 3252 log("updateMeteredAndCongested: networkType=" 3253 + TelephonyManager.getNetworkTypeName(networkType)); 3254 boolean changed = false; 3255 if (mDataConfigManager.isTempNotMeteredSupportedByCarrier() != mTempNotMeteredSupported) { 3256 mTempNotMeteredSupported = !mTempNotMeteredSupported; 3257 changed = true; 3258 log("updateMeteredAndCongested: mTempNotMeteredSupported changed to " 3259 + mTempNotMeteredSupported); 3260 } 3261 boolean isTempNotMetered = mDataConfigManager.isNetworkTypeUnmetered( 3262 mTelephonyDisplayInfo, mPhone.getServiceState()) 3263 && (mDataNetworkController.getUnmeteredOverrideNetworkTypes().contains(networkType) 3264 || isNetworkTypeUnmetered(networkType)); 3265 if (isTempNotMetered != mTempNotMetered) { 3266 mTempNotMetered = isTempNotMetered; 3267 changed = true; 3268 log("updateMeteredAndCongested: mTempNotMetered changed to " + mTempNotMetered); 3269 } 3270 if (mDataNetworkController.getCongestedOverrideNetworkTypes().contains(networkType) 3271 != mCongested) { 3272 mCongested = !mCongested; 3273 changed = true; 3274 log("updateMeteredAndCongested: mCongested changed to " + mCongested); 3275 } 3276 if (changed) { 3277 updateNetworkCapabilities(); 3278 } 3279 if (mTempNotMetered && isInternetSupported()) { 3280 // NR NSA and NR have the same network type: NR 3281 mDataCallSessionStats.onUnmeteredUpdate(networkType); 3282 } 3283 } 3284 3285 /** 3286 * Get whether the network type is unmetered from SubscriptionPlans, from either an unmetered 3287 * general plan or specific plan for the given network type. 3288 * 3289 * @param networkType The network type to check meteredness for 3290 * @return Whether the given network type is unmetered based on SubscriptionPlans 3291 */ 3292 private boolean isNetworkTypeUnmetered(@NetworkType int networkType) { 3293 List<SubscriptionPlan> plans = mDataNetworkController.getSubscriptionPlans(); 3294 if (plans.isEmpty()) return false; 3295 boolean isGeneralUnmetered = true; 3296 Set<Integer> allNetworkTypes = Arrays.stream(TelephonyManager.getAllNetworkTypes()) 3297 .boxed().collect(Collectors.toSet()); 3298 for (SubscriptionPlan plan : plans) { 3299 // Check if plan is general (applies to all network types) or specific 3300 if (Arrays.stream(plan.getNetworkTypes()).boxed().collect(Collectors.toSet()) 3301 .containsAll(allNetworkTypes)) { 3302 if (plan.getDataLimitBytes() != SubscriptionPlan.BYTES_UNLIMITED) { 3303 // Metered takes precedence over unmetered for safety 3304 isGeneralUnmetered = false; 3305 } 3306 } else { 3307 // Check if plan applies to given network type 3308 if (networkType != TelephonyManager.NETWORK_TYPE_UNKNOWN) { 3309 for (int planNetworkType : plan.getNetworkTypes()) { 3310 if (planNetworkType == networkType) { 3311 return plan.getDataLimitBytes() == SubscriptionPlan.BYTES_UNLIMITED; 3312 } 3313 } 3314 } 3315 } 3316 } 3317 return isGeneralUnmetered; 3318 } 3319 3320 /** 3321 * @return The unique context id assigned by the data service in 3322 * {@link DataCallResponse#getId()}. 3323 */ 3324 public int getId() { 3325 return mCid.get(mTransport); 3326 } 3327 3328 /** 3329 * @return The current network type reported by the network service. 3330 */ 3331 @NetworkType 3332 private int getDataNetworkType() { 3333 return getDataNetworkType(mTransport); 3334 } 3335 3336 /** 3337 * Get the data network type on the specified transport. 3338 * 3339 * @param transport The transport. 3340 * @return The data network type. 3341 */ 3342 @NetworkType 3343 private int getDataNetworkType(@TransportType int transport) { 3344 // WLAN transport can't have network type other than IWLAN. Ideally service state tracker 3345 // should report the correct RAT, but sometimes race condition could happen that service 3346 // state is reset to out of service and RAT not updated to IWLAN yet. 3347 if (transport == AccessNetworkConstants.TRANSPORT_TYPE_WLAN) { 3348 return TelephonyManager.NETWORK_TYPE_IWLAN; 3349 } 3350 3351 ServiceState ss = mPhone.getServiceState(); 3352 NetworkRegistrationInfo nrs = ss.getNetworkRegistrationInfo( 3353 NetworkRegistrationInfo.DOMAIN_PS, transport); 3354 if (nrs != null) { 3355 return nrs.getAccessNetworkTechnology(); 3356 } 3357 return TelephonyManager.NETWORK_TYPE_UNKNOWN; 3358 } 3359 3360 /** 3361 * @return The physical link status (i.e. RRC state). 3362 */ 3363 @LinkStatus 3364 public int getLinkStatus() { 3365 return mLinkStatus; 3366 } 3367 3368 /** 3369 * Update the network score and report to connectivity service if necessary. 3370 */ 3371 private void updateNetworkScore() { 3372 updateNetworkScore(isHandoverInProgress()); 3373 } 3374 3375 /** 3376 * Update the network score and report to connectivity service if necessary. 3377 * 3378 * @param keepConnectedForHandover indicate handover is in progress or not. 3379 */ 3380 private void updateNetworkScore(boolean keepConnectedForHandover) { 3381 int connectedReason = keepConnectedForHandover 3382 ? NetworkScore.KEEP_CONNECTED_FOR_HANDOVER : NetworkScore.KEEP_CONNECTED_NONE; 3383 if (mNetworkScore.getKeepConnectedReason() != connectedReason 3384 || mNetworkScore.isTransportPrimary() != mOnPreferredDataPhone) { 3385 NetworkScore.Builder builder = new NetworkScore.Builder() 3386 .setKeepConnectedReason(connectedReason); 3387 builder.setTransportPrimary(mOnPreferredDataPhone); 3388 mNetworkScore = builder.build(); 3389 mNetworkAgent.sendNetworkScore(mNetworkScore); 3390 logl("updateNetworkScore: isPrimary=" + mNetworkScore.isTransportPrimary() 3391 + ", keepConnectedForHandover=" + keepConnectedForHandover); 3392 } 3393 } 3394 3395 /** 3396 * @return Network registration info on the current transport. 3397 */ 3398 @Nullable 3399 private NetworkRegistrationInfo getNetworkRegistrationInfo() { 3400 NetworkRegistrationInfo nri = mPhone.getServiceStateTracker().getServiceState() 3401 .getNetworkRegistrationInfo(NetworkRegistrationInfo.DOMAIN_PS, mTransport); 3402 if (nri == null) { 3403 loge("Can't get network registration info for " 3404 + AccessNetworkConstants.transportTypeToString(mTransport)); 3405 return null; 3406 } 3407 return nri; 3408 } 3409 3410 /** 3411 * Get the APN type network capability. If there are more than one capabilities that are 3412 * APN types, then return the highest priority one which also has associated network request. 3413 * For example, if the network supports both MMS and internet, but only internet request 3414 * attached at this time, then the capability would be internet. Later on if MMS network request 3415 * attached to this network, then the APN type capability would be MMS. 3416 * 3417 * @return The APN type network capability from this network. 3418 * 3419 * @see #getPriority() 3420 */ 3421 @NetCapability 3422 public int getApnTypeNetworkCapability() { 3423 if (!mAttachedNetworkRequestList.isEmpty()) { 3424 // The highest priority network request is always at the top of list. 3425 return mAttachedNetworkRequestList.get(0).getHighestPriorityApnTypeNetworkCapability(); 3426 } else { 3427 return Arrays.stream(getNetworkCapabilities().getCapabilities()).boxed() 3428 .filter(cap -> DataUtils.networkCapabilityToApnType(cap) 3429 != ApnSetting.TYPE_NONE) 3430 .max(Comparator.comparingInt(mDataConfigManager::getNetworkCapabilityPriority)) 3431 .orElse(-1); 3432 } 3433 } 3434 3435 /** 3436 * Get the priority of the network. The priority is derived from the highest priority capability 3437 * which also has such associated network request. For example, if the network supports both 3438 * MMS and internet, but only has internet request attached, then this network has internet's 3439 * priority. Later on when the MMS request attached to this network, the network's priority will 3440 * be updated to MMS's priority. 3441 * 3442 * @return The priority of the network. 3443 * 3444 * @see #getApnTypeNetworkCapability() 3445 */ 3446 public int getPriority() { 3447 if (!mAttachedNetworkRequestList.isEmpty()) { 3448 // The highest priority network request is always at the top of list. 3449 return mAttachedNetworkRequestList.get(0).getPriority(); 3450 } else { 3451 // If all network requests are already detached, then just pick the highest priority 3452 // capability's priority. 3453 return Arrays.stream(getNetworkCapabilities().getCapabilities()).boxed() 3454 .map(mDataConfigManager::getNetworkCapabilityPriority) 3455 .max(Integer::compare) 3456 .orElse(0); 3457 } 3458 } 3459 3460 /** 3461 * @return The attached network request list. 3462 */ 3463 @NonNull 3464 public NetworkRequestList getAttachedNetworkRequestList() { 3465 return mAttachedNetworkRequestList; 3466 } 3467 3468 /** 3469 * @return {@code true} if in connecting state. 3470 */ 3471 public boolean isConnecting() { 3472 return getCurrentState() == mConnectingState; 3473 } 3474 3475 /** 3476 * @return {@code true} if in connected state. 3477 */ 3478 public boolean isConnected() { 3479 return getCurrentState() == mConnectedState; 3480 } 3481 3482 /** 3483 * @return {@code true} if in disconnecting state. 3484 */ 3485 public boolean isDisconnecting() { 3486 return getCurrentState() == mDisconnectingState; 3487 } 3488 3489 /** 3490 * @return {@code true} if in disconnected state. 3491 */ 3492 public boolean isDisconnected() { 3493 return getCurrentState() == mDisconnectedState; 3494 } 3495 3496 /** 3497 * @return {@code true} if in handover state. 3498 */ 3499 public boolean isHandoverInProgress() { 3500 return getCurrentState() == mHandoverState; 3501 } 3502 3503 /** 3504 * @return {@code true} if the data network is suspended. 3505 */ 3506 public boolean isSuspended() { 3507 return getState() == TelephonyManager.DATA_SUSPENDED; 3508 } 3509 3510 /** 3511 * @return The current transport of the data network. 3512 */ 3513 @TransportType 3514 public int getTransport() { 3515 return mTransport; 3516 } 3517 3518 @DataState 3519 private int getState() { 3520 IState state = getCurrentState(); 3521 if (state == null || isDisconnected()) { 3522 return TelephonyManager.DATA_DISCONNECTED; 3523 } else if (isConnecting()) { 3524 return TelephonyManager.DATA_CONNECTING; 3525 } else if (isConnected()) { 3526 // The data connection can only be suspended when it's in active state. 3527 if (mSuspended) { 3528 return TelephonyManager.DATA_SUSPENDED; 3529 } 3530 return TelephonyManager.DATA_CONNECTED; 3531 } else if (isDisconnecting()) { 3532 return TelephonyManager.DATA_DISCONNECTING; 3533 } else if (isHandoverInProgress()) { 3534 return TelephonyManager.DATA_HANDOVER_IN_PROGRESS; 3535 } 3536 3537 return TelephonyManager.DATA_UNKNOWN; 3538 } 3539 3540 /** 3541 * @return {@code true} if this data network supports internet. 3542 */ 3543 public boolean isInternetSupported() { 3544 return mNetworkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3545 } 3546 3547 /** 3548 * @return {@code true} if this network was setup for SUPL during emergency call. {@code false} 3549 * otherwise. 3550 */ 3551 public boolean isEmergencySupl() { 3552 return mDataAllowedReason == DataAllowedReason.EMERGENCY_SUPL; 3553 } 3554 3555 /** 3556 * Get precise data connection state 3557 * 3558 * @return The {@link PreciseDataConnectionState} 3559 */ 3560 private PreciseDataConnectionState getPreciseDataConnectionState() { 3561 return new PreciseDataConnectionState.Builder() 3562 .setTransportType(mTransport) 3563 .setId(mCid.get(mTransport)) 3564 .setNetworkAgentId(mNetworkAgent.getId()) 3565 .setState(getState()) 3566 .setApnSetting(mDataProfile.getApnSetting()) 3567 .setLinkProperties(mLinkProperties) 3568 .setNetworkType(getDataNetworkType()) 3569 .setFailCause(mFailCause) 3570 .setDefaultQos(mDefaultQos) 3571 .setNetworkValidationStatus(mNetworkValidationStatus) 3572 .build(); 3573 } 3574 3575 /** 3576 * Send the precise data connection state to the listener of 3577 * {@link android.telephony.TelephonyCallback.PreciseDataConnectionStateListener}. 3578 * <p> 3579 * Note that notify only when {@link DataState} or {@link 3580 * PreciseDataConnectionState.NetworkValidationStatus} or {@link TelephonyNetworkAgent#getId} 3581 * changes. 3582 */ 3583 private void notifyPreciseDataConnectionState() { 3584 PreciseDataConnectionState pdcs = getPreciseDataConnectionState(); 3585 if (mPreciseDataConnectionState == null 3586 || mPreciseDataConnectionState.getState() != pdcs.getState() 3587 || mPreciseDataConnectionState.getNetworkValidationStatus() 3588 != pdcs.getNetworkValidationStatus() 3589 || mPreciseDataConnectionState.getNetId() != pdcs.getNetId()) { 3590 mPreciseDataConnectionState = pdcs; 3591 logv("notifyPreciseDataConnectionState=" + pdcs); 3592 mPhone.notifyDataConnection(pdcs); 3593 } 3594 } 3595 3596 /** 3597 * Request the data network to handover to the target transport. 3598 * <p> 3599 * This is the starting point of initiating IWLAN/cellular handover. It will first call 3600 * {@link DataServiceManager#startHandover(int, Message)} to notify source transport that 3601 * handover is about to start, and then call {@link DataServiceManager#setupDataCall(int, 3602 * DataProfile, boolean, boolean, int, LinkProperties, int, NetworkSliceInfo, TrafficDescriptor, 3603 * boolean, Message)} on target transport to initiate the handover process. 3604 * 3605 * @param targetTransport The target transport. 3606 * @param retryEntry Data handover retry entry. This would be {@code null} for first time 3607 * handover attempt. 3608 * @return {@code true} if the request has been accepted. 3609 */ 3610 public boolean startHandover(@TransportType int targetTransport, 3611 @Nullable DataHandoverRetryEntry retryEntry) { 3612 if (getCurrentState() == null || isDisconnected() || isDisconnecting()) { 3613 // Fail the request if not in the appropriate state. 3614 if (retryEntry != null) retryEntry.setState(DataRetryEntry.RETRY_STATE_CANCELLED); 3615 return false; 3616 } 3617 3618 // Before we really initiate the handover process on target transport, we need to notify 3619 // source transport that handover is about to start. Handover will be eventually initiated 3620 // in onStartHandover(). 3621 sendMessage(obtainMessage(EVENT_NOTIFY_HANDOVER_STARTED, 0, targetTransport, retryEntry)); 3622 return true; 3623 } 3624 3625 /** 3626 * Called when starting IWLAN/cellular handover process on the target transport. 3627 * 3628 * @param targetTransport The target transport. 3629 * @param retryEntry Data handover retry entry. This would be {@code null} for first time 3630 * handover attempt. 3631 */ 3632 private void onStartHandover(@TransportType int targetTransport, 3633 @Nullable DataHandoverRetryEntry retryEntry) { 3634 if (mTransport == targetTransport) { 3635 log("onStartHandover: The network is already on " 3636 + AccessNetworkConstants.transportTypeToString(mTransport) 3637 + ", handover is not needed."); 3638 if (retryEntry != null) retryEntry.setState(DataRetryEntry.RETRY_STATE_CANCELLED); 3639 return; 3640 } 3641 3642 // We need to use the actual modem roaming state instead of the framework roaming state 3643 // here. This flag is only passed down to ril_service for picking the correct protocol (for 3644 // old modem backward compatibility). 3645 boolean isModemRoaming = mPhone.getServiceState().getDataRoamingFromRegistration(); 3646 3647 // Set this flag to true if the user turns on data roaming. Or if we override the roaming 3648 // state in framework, we should set this flag to true as well so the modem will not reject 3649 // the data call setup (because the modem actually thinks the device is roaming). 3650 boolean allowRoaming = mPhone.getDataRoamingEnabled() 3651 || (isModemRoaming && (!mPhone.getServiceState().getDataRoaming())); 3652 3653 mHandoverDataProfile = mDataProfile; 3654 int targetNetworkType = getDataNetworkType(targetTransport); 3655 if (targetNetworkType != TelephonyManager.NETWORK_TYPE_UNKNOWN 3656 && !mAttachedNetworkRequestList.isEmpty()) { 3657 TelephonyNetworkRequest networkRequest = mAttachedNetworkRequestList.get(0); 3658 DataProfile dataProfile = mDataNetworkController.getDataProfileManager() 3659 .getDataProfileForNetworkRequest(networkRequest, targetNetworkType, 3660 mPhone.getServiceState().isUsingNonTerrestrialNetwork(), 3661 mDataNetworkController.isEsimBootStrapProvisioningActivated(), false); 3662 // Some carriers have different profiles between cellular and IWLAN. We need to 3663 // dynamically switch profile, but only when those profiles have same APN name. 3664 if (dataProfile != null && dataProfile.getApnSetting() != null 3665 && mDataProfile.getApnSetting() != null 3666 && TextUtils.equals(dataProfile.getApnSetting().getApnName(), 3667 mDataProfile.getApnSetting().getApnName()) 3668 && !dataProfile.equals(mDataProfile)) { 3669 mHandoverDataProfile = dataProfile; 3670 log("Used different data profile for handover. " + mDataProfile); 3671 } 3672 } 3673 3674 logl("Start handover from " + AccessNetworkConstants.transportTypeToString(mTransport) 3675 + " to " + AccessNetworkConstants.transportTypeToString(targetTransport)); 3676 // Send the handover request to the target transport data service. 3677 mDataServiceManagers.get(targetTransport).setupDataCall( 3678 DataUtils.networkTypeToAccessNetworkType(getDataNetworkType(targetTransport)), 3679 mHandoverDataProfile, isModemRoaming, allowRoaming, 3680 DataService.REQUEST_REASON_HANDOVER, mLinkProperties, mPduSessionId, 3681 mNetworkSliceInfo, mHandoverDataProfile.getTrafficDescriptor(), true, 3682 obtainMessage(EVENT_HANDOVER_RESPONSE, retryEntry)); 3683 3684 mDataNetworkValidationStats.onHandoverAttempted(); 3685 } 3686 3687 /** 3688 * Called when receiving handover response from the data service. 3689 * 3690 * @param resultCode The result code. 3691 * @param response The response. 3692 * @param retryEntry Data handover retry entry. This would be {@code null} for first time 3693 * handover attempt. 3694 */ 3695 private void onHandoverResponse(@DataServiceCallback.ResultCode int resultCode, 3696 @Nullable DataCallResponse response, @Nullable DataHandoverRetryEntry retryEntry) { 3697 logl("onHandoverResponse: resultCode=" + DataServiceCallback.resultCodeToString(resultCode) 3698 + ", response=" + response); 3699 mFailCause = getFailCauseFromDataCallResponse(resultCode, response); 3700 validateDataCallResponse(response, -1 /*setupRegState setup only*/); 3701 if (mFailCause == DataFailCause.NONE) { 3702 // Handover succeeded. 3703 3704 // Clean up on the source transport. 3705 mDataServiceManagers.get(mTransport).deactivateDataCall(mCid.get(mTransport), 3706 DataService.REQUEST_REASON_HANDOVER, null); 3707 // Switch the transport to the target. 3708 mTransport = DataUtils.getTargetTransport(mTransport); 3709 // Update the logging tag 3710 mLogTag = "DN-" + mInitialNetworkAgentId + "-" 3711 + ((mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) ? "C" : "I"); 3712 // Switch the data profile. This is no-op in most of the case since almost all carriers 3713 // use same data profile between IWLAN and cellular. 3714 mDataProfile = mHandoverDataProfile; 3715 updateDataNetwork(response); 3716 if (mTransport != AccessNetworkConstants.TRANSPORT_TYPE_WWAN) { 3717 unregisterForWwanEvents(); 3718 } else { 3719 // Handover from WLAN to WWAN 3720 registerForWwanEvents(); 3721 } 3722 if (retryEntry != null) retryEntry.setState(DataRetryEntry.RETRY_STATE_SUCCEEDED); 3723 mDataNetworkCallback.invokeFromExecutor( 3724 () -> mDataNetworkCallback.onHandoverSucceeded(DataNetwork.this)); 3725 } else { 3726 // Handover failed. 3727 3728 // Notify source transport that handover failed on target transport so that PDU session 3729 // id can be released if it is preserved for handover. 3730 mDataServiceManagers.get(mTransport).cancelHandover(mCid.get(mTransport), 3731 obtainMessage(EVENT_NOTIFY_HANDOVER_CANCELLED_RESPONSE)); 3732 sendMessageDelayed(EVENT_CANCEL_HANDOVER_NO_RESPONSE, 3733 mDataConfigManager.getNetworkHandoverTimeoutMs()); 3734 3735 long retry = response != null ? response.getRetryDurationMillis() 3736 : DataCallResponse.RETRY_DURATION_UNDEFINED; 3737 // If the handover mode is unspecified, default to HANDOVER_FAILURE_MODE_UNKNOWN, 3738 // which will retry handover if retry rules are defined. 3739 int handoverFailureMode = response != null ? response.getHandoverFailureMode() 3740 : DataCallResponse.HANDOVER_FAILURE_MODE_UNKNOWN; 3741 if (retryEntry != null) retryEntry.setState(DataRetryEntry.RETRY_STATE_FAILED); 3742 mDataNetworkCallback.invokeFromExecutor( 3743 () -> mDataNetworkCallback.onHandoverFailed(DataNetwork.this, 3744 mFailCause, retry, handoverFailureMode)); 3745 trackHandoverFailure(response != null ? response.getCause() : mFailCause); 3746 } 3747 3748 // No matter handover succeeded or not, transit back to connected state. 3749 transitionTo(mConnectedState); 3750 } 3751 3752 /** 3753 * Called when handover failed. Record the source and target RAT{@link NetworkType} and the 3754 * failure cause {@link android.telephony.DataFailCause}. 3755 * 3756 * @param cause The fail cause. 3757 */ 3758 private void trackHandoverFailure(int cause) { 3759 int sourceRat = getDataNetworkType(); 3760 int targetTransport = DataUtils.getTargetTransport(mTransport); 3761 int targetRat = getDataNetworkType(targetTransport); 3762 3763 mDataCallSessionStats.onHandoverFailure(cause, sourceRat, targetRat); 3764 } 3765 3766 /** 3767 * Called when receiving PCO (Protocol Configuration Options) data from the cellular network. 3768 * 3769 * @param pcoData The PCO data. 3770 */ 3771 private void onPcoDataChanged(@NonNull PcoData pcoData) { 3772 log("onPcoDataChanged: " + pcoData); 3773 mDataNetworkCallback.invokeFromExecutor( 3774 () -> mDataNetworkCallback.onPcoDataChanged(DataNetwork.this)); 3775 if (mDataProfile.getApnSetting() != null) { 3776 for (int apnType : mDataProfile.getApnSetting().getApnTypes()) { 3777 Intent intent = new Intent(TelephonyManager.ACTION_CARRIER_SIGNAL_PCO_VALUE); 3778 intent.putExtra(TelephonyManager.EXTRA_APN_TYPE, apnType); 3779 intent.putExtra(TelephonyManager.EXTRA_APN_PROTOCOL, 3780 ApnSetting.getProtocolIntFromString(pcoData.bearerProto)); 3781 intent.putExtra(TelephonyManager.EXTRA_PCO_ID, pcoData.pcoId); 3782 intent.putExtra(TelephonyManager.EXTRA_PCO_VALUE, pcoData.contents); 3783 mPhone.getCarrierSignalAgent().notifyCarrierSignalReceivers(intent); 3784 } 3785 } 3786 } 3787 3788 /** 3789 * Called when receiving PCO (Protocol Configuration Options) data from the cellular network. 3790 * 3791 * @param pcoData PCO data. 3792 */ 3793 private void onPcoDataReceived(@NonNull PcoData pcoData) { 3794 // Save all the PCO data received, even though it might be unrelated to this data network. 3795 // The network might be still in connecting state. Save all now and use it when entering 3796 // connected state. 3797 log("onPcoDataReceived: " + pcoData); 3798 PcoData oldData = mPcoData.computeIfAbsent(pcoData.cid, m -> new ArrayMap<>()) 3799 .put(pcoData.pcoId, pcoData); 3800 if (getId() == INVALID_CID || pcoData.cid != getId()) return; 3801 if (!Objects.equals(oldData, pcoData)) { 3802 onPcoDataChanged(pcoData); 3803 } 3804 } 3805 3806 /** 3807 * @return The last known data network type of the data network. 3808 */ 3809 @NetworkType 3810 public int getLastKnownDataNetworkType() { 3811 return mLastKnownDataNetworkType; 3812 } 3813 3814 /** 3815 * @return The last known roaming state of this data network. 3816 */ 3817 public boolean getLastKnownRoamingState() { 3818 return mLastKnownRoamingState; 3819 } 3820 3821 /** 3822 * @return The PCO data received from the network. 3823 */ 3824 @NonNull 3825 public Map<Integer, PcoData> getPcoData() { 3826 if (mTransport == AccessNetworkConstants.TRANSPORT_TYPE_WLAN 3827 || mCid.get(mTransport) == INVALID_CID) { 3828 return Collections.emptyMap(); 3829 } 3830 return mPcoData.getOrDefault(mCid.get(mTransport), Collections.emptyMap()); 3831 } 3832 3833 /** 3834 * Check if the this data network is VCN-managed. 3835 * 3836 * @param networkCapabilities The network capabilities of this data network. 3837 * @return The VCN's policy for this DataNetwork. 3838 */ 3839 private VcnNetworkPolicyResult getVcnPolicy(NetworkCapabilities networkCapabilities) { 3840 if (mVcnManager == null) { 3841 return null; 3842 } 3843 3844 return mVcnManager.applyVcnNetworkPolicy(networkCapabilities, getLinkProperties()); 3845 } 3846 3847 /** 3848 * Check if any of the attached request has the specified network capability. 3849 * 3850 * @param netCapability The network capability to check. 3851 * @return {@code true} if at least one network request has specified network capability. 3852 */ 3853 public boolean hasNetworkCapabilityInNetworkRequests(@NetCapability int netCapability) { 3854 return mAttachedNetworkRequestList.stream().anyMatch( 3855 request -> request.hasCapability(netCapability)); 3856 } 3857 3858 /** 3859 * The network validation requests moves to process on the state machine handler. A request is 3860 * processed according to state of the data network. 3861 */ 3862 public void requestNetworkValidation(@NonNull Consumer<Integer> resultCodeCallback) { 3863 // request a network validation by DataNetwork state 3864 sendMessage(EVENT_DATA_NETWORK_VALIDATION_REQUESTED, resultCodeCallback); 3865 } 3866 3867 /** 3868 * Request network validation to data service provider. 3869 */ 3870 private void handleDataNetworkValidationRequest(@NonNull Consumer<Integer> resultCodeCallback) { 3871 if (mNetworkValidationResultCodeCallback != null) { 3872 loge("requestNetworkValidation: previous networkValidationRequest is in progress."); 3873 FunctionalUtils.ignoreRemoteException(resultCodeCallback::accept) 3874 .accept(DataServiceCallback.RESULT_ERROR_BUSY); 3875 return; 3876 } 3877 3878 mNetworkValidationResultCodeCallback = resultCodeCallback; 3879 3880 // Request validation directly from the data service. 3881 mDataServiceManagers.get(mTransport).requestNetworkValidation( 3882 mCid.get(mTransport), obtainMessage(EVENT_DATA_NETWORK_VALIDATION_RESPONSE)); 3883 3884 int apnTypeBitmask = mDataProfile.getApnSetting() != null 3885 ? mDataProfile.getApnSetting().getApnTypeBitmask() : ApnSetting.TYPE_NONE; 3886 mDataNetworkValidationStats.onRequestNetworkValidation(apnTypeBitmask); 3887 3888 log("handleDataNetworkValidationRequest, network validation requested"); 3889 } 3890 3891 private void handleErrorDataNetworkValidationRequest( 3892 @NonNull Consumer<Integer> resultCodeCallback) { 3893 loge("handleErrorDataNetworkValidationRequest: DataNetwork is not in Connected state"); 3894 FunctionalUtils.ignoreRemoteException(resultCodeCallback::accept) 3895 .accept(DataServiceCallback.RESULT_ERROR_ILLEGAL_STATE); 3896 } 3897 3898 /** 3899 * handle the resultCode in response for the request. 3900 * 3901 * @param resultCode {@link DataServiceCallback.ResultCode} 3902 */ 3903 private void handleDataNetworkValidationRequestResultCode( 3904 @DataServiceCallback.ResultCode int resultCode) { 3905 if (mNetworkValidationResultCodeCallback != null) { 3906 log("handleDataNetworkValidationRequestResultCode, resultCode:" 3907 + DataServiceCallback.resultCodeToString(resultCode)); 3908 FunctionalUtils.ignoreRemoteException(mNetworkValidationResultCodeCallback::accept) 3909 .accept(resultCode); 3910 mNetworkValidationResultCodeCallback = null; 3911 } 3912 } 3913 3914 /** 3915 * Update the validation status from {@link DataCallResponse}, convert to network validation 3916 * status {@link PreciseDataConnectionState.NetworkValidationStatus}. 3917 * 3918 * @param networkValidationStatus {@link PreciseDataConnectionState.NetworkValidationStatus} 3919 */ 3920 private void updateValidationStatus( 3921 @PreciseDataConnectionState.NetworkValidationStatus int networkValidationStatus) { 3922 // if network validation status is changed, notify preciseDataConnectionState. 3923 if (mNetworkValidationStatus != networkValidationStatus) { 3924 log("updateValidationStatus:" 3925 + PreciseDataConnectionState.networkValidationStatusToString( 3926 networkValidationStatus)); 3927 mNetworkValidationStatus = networkValidationStatus; 3928 } 3929 3930 mDataNetworkValidationStats.onUpdateNetworkValidationState( 3931 mNetworkValidationStatus, getDataNetworkType()); 3932 } 3933 3934 /** 3935 * Convert the data tear down reason to string. 3936 * 3937 * @param reason Data deactivation reason. 3938 * @return The deactivation reason in string format. 3939 */ 3940 @NonNull 3941 public static String tearDownReasonToString(@TearDownReason int reason) { 3942 return switch (reason) { 3943 case TEAR_DOWN_REASON_NONE -> "NONE"; 3944 case TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED -> "CONNECTIVITY_SERVICE_UNWANTED"; 3945 case TEAR_DOWN_REASON_SIM_REMOVAL -> "SIM_REMOVAL"; 3946 case TEAR_DOWN_REASON_AIRPLANE_MODE_ON -> "AIRPLANE_MODE_ON"; 3947 case TEAR_DOWN_REASON_DATA_DISABLED -> "DATA_DISABLED"; 3948 case TEAR_DOWN_REASON_NO_LIVE_REQUEST -> "TEAR_DOWN_REASON_NO_LIVE_REQUEST"; 3949 case TEAR_DOWN_REASON_RAT_NOT_ALLOWED -> "TEAR_DOWN_REASON_RAT_NOT_ALLOWED"; 3950 case TEAR_DOWN_REASON_ROAMING_DISABLED -> "TEAR_DOWN_REASON_ROAMING_DISABLED"; 3951 case TEAR_DOWN_REASON_CONCURRENT_VOICE_DATA_NOT_ALLOWED -> 3952 "TEAR_DOWN_REASON_CONCURRENT_VOICE_DATA_NOT_ALLOWED"; 3953 case TEAR_DOWN_REASON_SERVICE_OPTION_NOT_SUPPORTED -> 3954 "TEAR_DOWN_REASON_SERVICE_OPTION_NOT_SUPPORTED"; 3955 case TEAR_DOWN_REASON_DATA_SERVICE_NOT_READY -> 3956 "TEAR_DOWN_REASON_DATA_SERVICE_NOT_READY"; 3957 case TEAR_DOWN_REASON_POWER_OFF_BY_CARRIER -> "TEAR_DOWN_REASON_POWER_OFF_BY_CARRIER"; 3958 case TEAR_DOWN_REASON_DATA_STALL -> "TEAR_DOWN_REASON_DATA_STALL"; 3959 case TEAR_DOWN_REASON_HANDOVER_FAILED -> "TEAR_DOWN_REASON_HANDOVER_FAILED"; 3960 case TEAR_DOWN_REASON_HANDOVER_NOT_ALLOWED -> "TEAR_DOWN_REASON_HANDOVER_NOT_ALLOWED"; 3961 case TEAR_DOWN_REASON_VCN_REQUESTED -> "TEAR_DOWN_REASON_VCN_REQUESTED"; 3962 case TEAR_DOWN_REASON_VOPS_NOT_SUPPORTED -> "TEAR_DOWN_REASON_VOPS_NOT_SUPPORTED"; 3963 case TEAR_DOWN_REASON_DEFAULT_DATA_UNSELECTED -> 3964 "TEAR_DOWN_REASON_DEFAULT_DATA_UNSELECTED"; 3965 case TEAR_DOWN_REASON_NOT_IN_SERVICE -> "TEAR_DOWN_REASON_NOT_IN_SERVICE"; 3966 case TEAR_DOWN_REASON_DATA_CONFIG_NOT_READY -> "TEAR_DOWN_REASON_DATA_CONFIG_NOT_READY"; 3967 case TEAR_DOWN_REASON_PENDING_TEAR_DOWN_ALL -> "TEAR_DOWN_REASON_PENDING_TEAR_DOWN_ALL"; 3968 case TEAR_DOWN_REASON_NO_SUITABLE_DATA_PROFILE -> 3969 "TEAR_DOWN_REASON_NO_SUITABLE_DATA_PROFILE"; 3970 case TEAR_DOWN_REASON_CDMA_EMERGENCY_CALLBACK_MODE -> 3971 "TEAR_DOWN_REASON_CDMA_EMERGENCY_CALLBACK_MODE"; 3972 case TEAR_DOWN_REASON_RETRY_SCHEDULED -> "TEAR_DOWN_REASON_RETRY_SCHEDULED"; 3973 case TEAR_DOWN_REASON_DATA_THROTTLED -> "TEAR_DOWN_REASON_DATA_THROTTLED"; 3974 case TEAR_DOWN_REASON_DATA_PROFILE_INVALID -> "TEAR_DOWN_REASON_DATA_PROFILE_INVALID"; 3975 case TEAR_DOWN_REASON_DATA_PROFILE_NOT_PREFERRED -> 3976 "TEAR_DOWN_REASON_DATA_PROFILE_NOT_PREFERRED"; 3977 case TEAR_DOWN_REASON_NOT_ALLOWED_BY_POLICY -> "TEAR_DOWN_REASON_NOT_ALLOWED_BY_POLICY"; 3978 case TEAR_DOWN_REASON_ILLEGAL_STATE -> "TEAR_DOWN_REASON_ILLEGAL_STATE"; 3979 case TEAR_DOWN_REASON_ONLY_ALLOWED_SINGLE_NETWORK -> 3980 "TEAR_DOWN_REASON_ONLY_ALLOWED_SINGLE_NETWORK"; 3981 case TEAR_DOWN_REASON_PREFERRED_DATA_SWITCHED -> 3982 "TEAR_DOWN_REASON_PREFERRED_DATA_SWITCHED"; 3983 case TEAR_DOWN_REASON_DATA_LIMIT_REACHED -> "TEAR_DOWN_REASON_DATA_LIMIT_REACHED"; 3984 case TEAR_DOWN_REASON_DATA_NETWORK_TRANSPORT_NOT_ALLOWED -> 3985 "TEAR_DOWN_REASON_DATA_NETWORK_TRANSPORT_NOT_ALLOWED"; 3986 default -> "UNKNOWN(" + reason + ")"; 3987 }; 3988 } 3989 3990 /** 3991 * Convert event to string 3992 * 3993 * @param event The event 3994 * @return The event in string format. 3995 */ 3996 @NonNull 3997 private static String eventToString(int event) { 3998 return switch (event) { 3999 case EVENT_DATA_CONFIG_UPDATED -> "EVENT_DATA_CONFIG_UPDATED"; 4000 case EVENT_ATTACH_NETWORK_REQUEST -> "EVENT_ATTACH_NETWORK_REQUEST"; 4001 case EVENT_DETACH_NETWORK_REQUEST -> "EVENT_DETACH_NETWORK_REQUEST"; 4002 case EVENT_RADIO_NOT_AVAILABLE -> "EVENT_RADIO_NOT_AVAILABLE"; 4003 case EVENT_ALLOCATE_PDU_SESSION_ID_RESPONSE -> "EVENT_ALLOCATE_PDU_SESSION_ID_RESPONSE"; 4004 case EVENT_SETUP_DATA_NETWORK_RESPONSE -> "EVENT_SETUP_DATA_NETWORK_RESPONSE"; 4005 case EVENT_TEAR_DOWN_NETWORK -> "EVENT_TEAR_DOWN_NETWORK"; 4006 case EVENT_DATA_STATE_CHANGED -> "EVENT_DATA_STATE_CHANGED"; 4007 case EVENT_SERVICE_STATE_CHANGED -> "EVENT_DATA_NETWORK_TYPE_REG_STATE_CHANGED"; 4008 case EVENT_DETACH_ALL_NETWORK_REQUESTS -> "EVENT_DETACH_ALL_NETWORK_REQUESTS"; 4009 case EVENT_BANDWIDTH_ESTIMATE_FROM_MODEM_CHANGED -> 4010 "EVENT_BANDWIDTH_ESTIMATE_FROM_MODEM_CHANGED"; 4011 case EVENT_CANCEL_HANDOVER_NO_RESPONSE -> "EVENT_CANCEL_HANDOVER_NO_RESPONSE"; 4012 case EVENT_DISPLAY_INFO_CHANGED -> "EVENT_DISPLAY_INFO_CHANGED"; 4013 case EVENT_HANDOVER_RESPONSE -> "EVENT_HANDOVER_RESPONSE"; 4014 case EVENT_SUBSCRIPTION_PLAN_OVERRIDE -> "EVENT_SUBSCRIPTION_PLAN_OVERRIDE"; 4015 case EVENT_PCO_DATA_RECEIVED -> "EVENT_PCO_DATA_RECEIVED"; 4016 case EVENT_CARRIER_PRIVILEGED_UIDS_CHANGED -> "EVENT_CARRIER_PRIVILEGED_UIDS_CHANGED"; 4017 case EVENT_DEACTIVATE_DATA_NETWORK_RESPONSE -> "EVENT_DEACTIVATE_DATA_NETWORK_RESPONSE"; 4018 case EVENT_STUCK_IN_TRANSIENT_STATE -> "EVENT_STUCK_IN_TRANSIENT_STATE"; 4019 case EVENT_WAITING_FOR_TEARING_DOWN_CONDITION_MET -> 4020 "EVENT_WAITING_FOR_TEARING_DOWN_CONDITION_MET"; 4021 case EVENT_VOICE_CALL_STARTED -> "EVENT_VOICE_CALL_STARTED"; 4022 case EVENT_VOICE_CALL_ENDED -> "EVENT_VOICE_CALL_ENDED"; 4023 case EVENT_CSS_INDICATOR_CHANGED -> "EVENT_CSS_INDICATOR_CHANGED"; 4024 case EVENT_NOTIFY_HANDOVER_STARTED -> "EVENT_NOTIFY_HANDOVER_STARTED"; 4025 case EVENT_NOTIFY_HANDOVER_STARTED_RESPONSE -> "EVENT_NOTIFY_HANDOVER_STARTED_RESPONSE"; 4026 case EVENT_NOTIFY_HANDOVER_CANCELLED_RESPONSE -> 4027 "EVENT_NOTIFY_HANDOVER_CANCELLED_RESPONSE"; 4028 case EVENT_DATA_NETWORK_VALIDATION_REQUESTED -> 4029 "EVENT_DATA_NETWORK_VALIDATION_REQUESTED"; 4030 case EVENT_DATA_NETWORK_VALIDATION_RESPONSE -> "EVENT_DATA_NETWORK_VALIDATION_RESPONSE"; 4031 default -> "Unknown(" + event + ")"; 4032 }; 4033 } 4034 4035 @Override 4036 public String toString() { 4037 return "[DataNetwork: " + mLogTag + ", " + (mDataProfile.getApnSetting() != null 4038 ? mDataProfile.getApnSetting().getApnName() : null) + ", state=" 4039 + (getCurrentState() != null ? getCurrentState().getName() : null) + "]"; 4040 } 4041 4042 /** 4043 * @return The short name of the data network (e.g. DN-C-1) 4044 */ 4045 @NonNull 4046 public String name() { 4047 return mLogTag; 4048 } 4049 4050 /** 4051 * Trigger the anomaly report with the specified UUID. 4052 * 4053 * @param anomalyMsg Description of the event 4054 * @param uuid UUID associated with that event 4055 */ 4056 private void reportAnomaly(@NonNull String anomalyMsg, @NonNull String uuid) { 4057 logl(anomalyMsg); 4058 AnomalyReporter.reportAnomaly(UUID.fromString(uuid), anomalyMsg, mPhone.getCarrierId()); 4059 } 4060 4061 /** 4062 * Log debug messages. 4063 * @param s debug messages 4064 */ 4065 @Override 4066 protected void log(@NonNull String s) { 4067 Rlog.d(mLogTag, (getCurrentState() != null 4068 ? (getCurrentState().getName() + ": ") : "") + s); 4069 } 4070 4071 /** 4072 * Log error messages. 4073 * @param s error messages 4074 */ 4075 @Override 4076 protected void loge(@NonNull String s) { 4077 Rlog.e(mLogTag, (getCurrentState() != null 4078 ? (getCurrentState().getName() + ": ") : "") + s); 4079 } 4080 4081 /** 4082 * Log verbose messages. 4083 * @param s error messages 4084 */ 4085 @Override 4086 protected void logv(@NonNull String s) { 4087 if (VDBG) { 4088 Rlog.v(mLogTag, (getCurrentState() != null 4089 ? (getCurrentState().getName() + ": ") : "") + s); 4090 } 4091 } 4092 4093 /** 4094 * Log debug messages and also log into the local log. 4095 * @param s debug messages 4096 */ 4097 private void logl(@NonNull String s) { 4098 log(s); 4099 mLocalLog.log((getCurrentState() != null ? (getCurrentState().getName() + ": ") : "") + s); 4100 } 4101 4102 /** 4103 * Dump the state of DataNetwork 4104 * 4105 * @param fd File descriptor 4106 * @param printWriter Print writer 4107 * @param args Arguments 4108 */ 4109 public void dump(FileDescriptor fd, PrintWriter printWriter, String[] args) { 4110 IndentingPrintWriter pw = new IndentingPrintWriter(printWriter, " "); 4111 super.dump(fd, pw, args); 4112 pw.println("Tag: " + name()); 4113 pw.increaseIndent(); 4114 pw.println("mSubId=" + mSubId); 4115 pw.println("mOnPreferredDataPhone=" + mOnPreferredDataPhone); 4116 pw.println("mTransport=" + AccessNetworkConstants.transportTypeToString(mTransport)); 4117 pw.println("mLastKnownDataNetworkType=" + TelephonyManager 4118 .getNetworkTypeName(mLastKnownDataNetworkType)); 4119 pw.println("WWAN cid=" + mCid.get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN)); 4120 pw.println("WLAN cid=" + mCid.get(AccessNetworkConstants.TRANSPORT_TYPE_WLAN)); 4121 pw.println("mNetworkScore=" + mNetworkScore); 4122 pw.println("keepConnectedReason=" + mNetworkScore.getKeepConnectedReason()); 4123 pw.println("mDataAllowedReason=" + mDataAllowedReason); 4124 pw.println("mPduSessionId=" + mPduSessionId); 4125 pw.println("mDataProfile=" + mDataProfile); 4126 pw.println("mNetworkCapabilities=" + mNetworkCapabilities); 4127 pw.println("mLinkProperties=" + mLinkProperties); 4128 pw.println("mNetworkSliceInfo=" + mNetworkSliceInfo); 4129 pw.println("mNetworkBandwidth=" + mNetworkBandwidth); 4130 pw.println("mTcpBufferSizes=" + mTcpBufferSizes); 4131 pw.println("mTelephonyDisplayInfo=" + mTelephonyDisplayInfo); 4132 pw.println("mTempNotMeteredSupported=" + mTempNotMeteredSupported); 4133 pw.println("mTempNotMetered=" + mTempNotMetered); 4134 pw.println("mCongested=" + mCongested); 4135 pw.println("mSuspended=" + mSuspended); 4136 pw.println("mDataCallResponse=" + mDataCallResponse); 4137 pw.println("mFailCause=" + DataFailCause.toString(mFailCause)); 4138 pw.println("mAdministratorUids=" + Arrays.toString(mAdministratorUids)); 4139 pw.println("mCarrierServicePackageUid=" + mCarrierServicePackageUid); 4140 pw.println("mEverConnected=" + mEverConnected); 4141 pw.println("mInvokedDataDeactivation=" + mInvokedDataDeactivation); 4142 4143 pw.println("Attached network requests:"); 4144 pw.increaseIndent(); 4145 for (TelephonyNetworkRequest request : mAttachedNetworkRequestList) { 4146 pw.println(request); 4147 } 4148 pw.decreaseIndent(); 4149 pw.println("mQosBearerSessions=" + mQosBearerSessions); 4150 4151 mNetworkAgent.dump(fd, pw, args); 4152 pw.println("Local logs:"); 4153 pw.increaseIndent(); 4154 mLocalLog.dump(fd, pw, args); 4155 pw.decreaseIndent(); 4156 pw.decreaseIndent(); 4157 pw.println("---------------"); 4158 } 4159 } 4160