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 static com.android.internal.telephony.data.DataNetworkController.DataNetworkControllerCallback; 22 import static com.android.internal.telephony.data.DataNetworkController.NetworkRequestList; 23 24 import static com.google.common.truth.Truth.assertThat; 25 import static com.google.common.truth.Truth.assertWithMessage; 26 27 import static org.junit.Assert.assertEquals; 28 import static org.junit.Assert.assertFalse; 29 import static org.junit.Assert.assertSame; 30 import static org.junit.Assert.assertThrows; 31 import static org.junit.Assert.assertTrue; 32 import static org.junit.Assert.fail; 33 import static org.mockito.ArgumentMatchers.any; 34 import static org.mockito.ArgumentMatchers.anyBoolean; 35 import static org.mockito.ArgumentMatchers.anyInt; 36 import static org.mockito.ArgumentMatchers.anyString; 37 import static org.mockito.ArgumentMatchers.eq; 38 import static org.mockito.Mockito.clearInvocations; 39 import static org.mockito.Mockito.doAnswer; 40 import static org.mockito.Mockito.doReturn; 41 import static org.mockito.Mockito.never; 42 import static org.mockito.Mockito.times; 43 import static org.mockito.Mockito.verify; 44 import static org.mockito.Mockito.when; 45 46 import android.annotation.NonNull; 47 import android.content.pm.PackageManager; 48 import android.net.ConnectivityManager; 49 import android.net.InetAddresses; 50 import android.net.LinkAddress; 51 import android.net.LinkProperties; 52 import android.net.NetworkCapabilities; 53 import android.net.NetworkPolicyManager; 54 import android.net.NetworkRequest; 55 import android.net.Uri; 56 import android.net.vcn.VcnManager.VcnNetworkPolicyChangeListener; 57 import android.net.vcn.VcnNetworkPolicyResult; 58 import android.os.AsyncResult; 59 import android.os.Handler; 60 import android.os.Looper; 61 import android.os.Message; 62 import android.os.PersistableBundle; 63 import android.os.RegistrantList; 64 import android.provider.Telephony; 65 import android.telephony.AccessNetworkConstants; 66 import android.telephony.AccessNetworkConstants.AccessNetworkType; 67 import android.telephony.AccessNetworkConstants.TransportType; 68 import android.telephony.Annotation; 69 import android.telephony.Annotation.DataFailureCause; 70 import android.telephony.Annotation.NetCapability; 71 import android.telephony.Annotation.NetworkType; 72 import android.telephony.CarrierConfigManager; 73 import android.telephony.DataFailCause; 74 import android.telephony.DataSpecificRegistrationInfo; 75 import android.telephony.LteVopsSupportInfo; 76 import android.telephony.NetworkRegistrationInfo; 77 import android.telephony.NetworkRegistrationInfo.RegistrationState; 78 import android.telephony.PreciseDataConnectionState; 79 import android.telephony.ServiceState; 80 import android.telephony.SubscriptionInfo; 81 import android.telephony.SubscriptionManager; 82 import android.telephony.SubscriptionPlan; 83 import android.telephony.TelephonyDisplayInfo; 84 import android.telephony.TelephonyManager; 85 import android.telephony.data.ApnSetting; 86 import android.telephony.data.DataCallResponse; 87 import android.telephony.data.DataCallResponse.LinkStatus; 88 import android.telephony.data.DataProfile; 89 import android.telephony.data.DataService; 90 import android.telephony.data.DataServiceCallback; 91 import android.telephony.data.ThrottleStatus; 92 import android.telephony.data.TrafficDescriptor; 93 import android.telephony.data.TrafficDescriptor.OsAppId; 94 import android.telephony.ims.ImsManager; 95 import android.telephony.ims.ImsMmTelManager; 96 import android.telephony.ims.ImsRcsManager; 97 import android.telephony.ims.ImsReasonInfo; 98 import android.telephony.ims.ImsRegistrationAttributes; 99 import android.telephony.ims.ImsStateCallback; 100 import android.telephony.ims.RegistrationManager.RegistrationCallback; 101 import android.telephony.ims.feature.ImsFeature; 102 import android.telephony.ims.stub.ImsRegistrationImplBase; 103 import android.testing.AndroidTestingRunner; 104 import android.testing.TestableLooper; 105 import android.util.ArraySet; 106 import android.util.SparseArray; 107 108 import com.android.internal.telephony.ISub; 109 import com.android.internal.telephony.MultiSimSettingController; 110 import com.android.internal.telephony.Phone; 111 import com.android.internal.telephony.PhoneConstants; 112 import com.android.internal.telephony.PhoneFactory; 113 import com.android.internal.telephony.RIL; 114 import com.android.internal.telephony.TelephonyTest; 115 import com.android.internal.telephony.data.AccessNetworksManager.AccessNetworksManagerCallback; 116 import com.android.internal.telephony.data.DataEvaluation.DataDisallowedReason; 117 import com.android.internal.telephony.data.DataNetworkController.HandoverRule; 118 import com.android.internal.telephony.data.DataRetryManager.DataRetryManagerCallback; 119 import com.android.internal.telephony.data.LinkBandwidthEstimator.LinkBandwidthEstimatorCallback; 120 import com.android.internal.telephony.flags.FeatureFlags; 121 import com.android.internal.telephony.ims.ImsResolver; 122 import com.android.internal.telephony.subscription.SubscriptionInfoInternal; 123 124 import org.junit.After; 125 import org.junit.Before; 126 import org.junit.Test; 127 import org.junit.runner.RunWith; 128 import org.mockito.ArgumentCaptor; 129 import org.mockito.Mockito; 130 131 import java.lang.reflect.Field; 132 import java.time.Period; 133 import java.time.ZonedDateTime; 134 import java.util.ArrayList; 135 import java.util.Arrays; 136 import java.util.Collections; 137 import java.util.HashMap; 138 import java.util.List; 139 import java.util.Map; 140 import java.util.Set; 141 import java.util.concurrent.Executor; 142 143 import javax.annotation.Nullable; 144 145 @RunWith(AndroidTestingRunner.class) 146 @TestableLooper.RunWithLooper 147 public class DataNetworkControllerTest extends TelephonyTest { 148 private static final String IPV4_ADDRESS = "10.0.2.15"; 149 private static final String IPV6_ADDRESS = "2607:fb90:a620:651d:eabe:f8da:c107:44be"; 150 151 private static final String FAKE_MMTEL_PACKAGE = "fake.mmtel.package"; 152 private static final String FAKE_RCS_PACKAGE = "fake.rcs.package"; 153 154 // Events 155 private static final int EVENT_SIM_STATE_CHANGED = 9; 156 private static final int EVENT_REEVALUATE_EXISTING_DATA_NETWORKS = 16; 157 private static final int EVENT_SERVICE_STATE_CHANGED = 17; 158 private static final int EVENT_VOICE_CALL_ENDED = 18; 159 private static final int EVENT_SUBSCRIPTION_OVERRIDE = 23; 160 161 // Mocked classes 162 protected ISub mMockedIsub; 163 private DataNetworkControllerCallback mMockedDataNetworkControllerCallback; 164 private DataRetryManagerCallback mMockedDataRetryManagerCallback; 165 private ImsResolver mMockedImsResolver; 166 private DataStallRecoveryManager mMockedDataStallRecoveryManager; 167 private ImsManager mMockedImsManager; 168 private ImsMmTelManager mMockedImsMmTelManager; 169 private ImsRcsManager mMockedImsRcsManager; 170 private ImsStateCallback mMmtelStateCallback; 171 private ImsStateCallback mRcsStateCallback; 172 private RegistrationCallback mMmtelRegCallback; 173 private RegistrationCallback mRcsRegCallback; 174 private SubscriptionInfo mMockSubInfo; 175 private PackageManager mMockPackageManager; 176 177 private int mNetworkRequestId = 0; 178 179 private final SparseArray<DataServiceManager> mMockedDataServiceManagers = new SparseArray<>(); 180 private final SparseArray<RegistrantList> mDataCallListChangedRegistrants = new SparseArray<>(); 181 private DataNetworkController mDataNetworkControllerUT; 182 private PersistableBundle mCarrierConfig; 183 private CarrierConfigManager.CarrierConfigChangeListener mCarrierConfigChangeListener; 184 185 private AccessNetworksManagerCallback mAccessNetworksManagerCallback; 186 private LinkBandwidthEstimatorCallback mLinkBandwidthEstimatorCallback; 187 188 private boolean mIsNonTerrestrialNetwork = false; 189 private ArrayList<Integer> mCarrierSupportedServices = new ArrayList<>(); 190 191 private final DataProfile mGeneralPurposeDataProfile = new DataProfile.Builder() 192 .setApnSetting(new ApnSetting.Builder() 193 .setId(2163) 194 .setOperatorNumeric("12345") 195 .setEntryName("internet_supl_mms_apn") 196 .setApnName("internet_supl_mms_apn") 197 .setUser("user") 198 .setPassword("passwd") 199 .setApnTypeBitmask(ApnSetting.TYPE_DEFAULT | ApnSetting.TYPE_SUPL 200 | ApnSetting.TYPE_MMS) 201 .setProtocol(ApnSetting.PROTOCOL_IPV6) 202 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 203 .setCarrierEnabled(true) 204 .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 205 | TelephonyManager.NETWORK_TYPE_BITMASK_NR 206 | TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN 207 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT)) 208 .setLingeringNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 209 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT 210 | TelephonyManager.NETWORK_TYPE_BITMASK_UMTS 211 | TelephonyManager.NETWORK_TYPE_BITMASK_NR)) 212 .setProfileId(1234) 213 .setMaxConns(321) 214 .setWaitTime(456) 215 .setMaxConnsTime(789) 216 .setInfrastructureBitmask(ApnSetting.INFRASTRUCTURE_SATELLITE 217 | ApnSetting.INFRASTRUCTURE_CELLULAR) 218 .build()) 219 .setPreferred(false) 220 .build(); 221 222 // The same data profile but with different auto generated ID, should be considered the same as 223 // mGeneralPurposeDataProfile 224 private final DataProfile mDuplicatedGeneralPurposeDataProfile = new DataProfile.Builder() 225 .setApnSetting(new ApnSetting.Builder() 226 .setId(3612) 227 .setOperatorNumeric("12345") 228 .setEntryName("internet_supl_mms_apn") 229 .setApnName("internet_supl_mms_apn") 230 .setUser("user") 231 .setPassword("passwd") 232 .setApnTypeBitmask(ApnSetting.TYPE_DEFAULT | ApnSetting.TYPE_SUPL 233 | ApnSetting.TYPE_MMS) 234 .setProtocol(ApnSetting.PROTOCOL_IPV6) 235 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 236 .setCarrierEnabled(true) 237 .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 238 | TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN 239 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT)) 240 .setLingeringNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 241 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT 242 | TelephonyManager.NETWORK_TYPE_BITMASK_UMTS 243 | TelephonyManager.NETWORK_TYPE_BITMASK_NR)) 244 .setProfileId(1234) 245 .setMaxConns(321) 246 .setWaitTime(456) 247 .setMaxConnsTime(789) 248 .build()) 249 .setPreferred(false) 250 .build(); 251 252 // Created to test preferred data profiles that apply to different network types 253 private final DataProfile mGeneralPurposeDataProfileAlternative = new DataProfile.Builder() 254 .setApnSetting(new ApnSetting.Builder() 255 .setId(2161) 256 .setOperatorNumeric("12345") 257 .setEntryName("internet_supl_mms_apn") 258 .setApnName("internet_supl_mms_apn") 259 .setUser("user") 260 .setPassword("passwd") 261 .setApnTypeBitmask(ApnSetting.TYPE_DEFAULT | ApnSetting.TYPE_SUPL 262 | ApnSetting.TYPE_MMS) 263 .setProtocol(ApnSetting.PROTOCOL_IPV6) 264 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 265 .setCarrierEnabled(true) 266 .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 267 | TelephonyManager.NETWORK_TYPE_BITMASK_NR 268 | TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN 269 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT)) 270 .setLingeringNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 271 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT 272 | TelephonyManager.NETWORK_TYPE_BITMASK_UMTS 273 | TelephonyManager.NETWORK_TYPE_BITMASK_NR)) 274 .setProfileId(4321) 275 .setMaxConns(321) 276 .setWaitTime(456) 277 .setMaxConnsTime(789) 278 .build()) 279 .setPreferred(false) 280 .build(); 281 282 private final DataProfile mImsCellularDataProfile = new DataProfile.Builder() 283 .setApnSetting(new ApnSetting.Builder() 284 .setId(2164) 285 .setOperatorNumeric("12345") 286 .setEntryName("ims_apn") 287 .setApnName("ims_apn") 288 .setUser("user") 289 .setPassword("passwd") 290 .setApnTypeBitmask(ApnSetting.TYPE_IMS) 291 .setProtocol(ApnSetting.PROTOCOL_IPV6) 292 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 293 .setCarrierEnabled(true) 294 .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 295 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT)) 296 .setLingeringNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 297 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT 298 | TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN 299 | TelephonyManager.NETWORK_TYPE_BITMASK_UMTS 300 | TelephonyManager.NETWORK_TYPE_BITMASK_NR)) 301 .setProfileId(1235) 302 .setMaxConns(321) 303 .setWaitTime(456) 304 .setMaxConnsTime(789) 305 .build()) 306 .setPreferred(false) 307 .build(); 308 309 private final DataProfile mImsIwlanDataProfile = new DataProfile.Builder() 310 .setApnSetting(new ApnSetting.Builder() 311 .setId(2164) 312 .setOperatorNumeric("12345") 313 .setEntryName("ims_apn") 314 .setApnName("ims_apn") 315 .setUser("user") 316 .setPassword("passwd") 317 .setApnTypeBitmask(ApnSetting.TYPE_IMS) 318 .setProtocol(ApnSetting.PROTOCOL_IPV6) 319 .setRoamingProtocol(ApnSetting.PROTOCOL_IPV6) 320 .setCarrierEnabled(true) 321 .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN)) 322 .setProfileId(1235) 323 .setMaxConns(321) 324 .setWaitTime(456) 325 .setMaxConnsTime(789) 326 .build()) 327 .setPreferred(false) 328 .build(); 329 330 private final DataProfile mEmergencyDataProfile = new DataProfile.Builder() 331 .setApnSetting(new ApnSetting.Builder() 332 .setEntryName("DEFAULT EIMS") 333 .setId(2165) 334 .setProtocol(ApnSetting.PROTOCOL_IPV4V6) 335 .setRoamingProtocol(ApnSetting.PROTOCOL_IPV4V6) 336 .setApnName("sos") 337 .setApnTypeBitmask(ApnSetting.TYPE_EMERGENCY) 338 .setCarrierEnabled(true) 339 .setApnSetId(Telephony.Carriers.MATCH_ALL_APN_SET_ID) 340 .build()) 341 .build(); 342 343 private final DataProfile mFotaDataProfile = new DataProfile.Builder() 344 .setApnSetting(new ApnSetting.Builder() 345 .setId(2166) 346 .setOperatorNumeric("12345") 347 .setEntryName("fota_apn") 348 .setApnName("fota_apn") 349 .setUser("user") 350 .setPassword("passwd") 351 .setApnTypeBitmask(ApnSetting.TYPE_FOTA) 352 .setProtocol(ApnSetting.PROTOCOL_IPV6) 353 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 354 .setCarrierEnabled(true) 355 .setNetworkTypeBitmask((int) TelephonyManager.NETWORK_TYPE_BITMASK_LTE 356 | (int) TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT) 357 .setProfileId(1236) 358 .setMaxConns(321) 359 .setWaitTime(456) 360 .setMaxConnsTime(789) 361 .build()) 362 .setPreferred(false) 363 .build(); 364 365 private final DataProfile mTetheringDataProfile = new DataProfile.Builder() 366 .setApnSetting(new ApnSetting.Builder() 367 .setId(2167) 368 .setOperatorNumeric("12345") 369 .setEntryName("dun_apn") 370 .setApnName("dun_apn") 371 .setUser("user") 372 .setPassword("passwd") 373 .setApnTypeBitmask(ApnSetting.TYPE_DUN | ApnSetting.TYPE_DEFAULT) 374 .setProtocol(ApnSetting.PROTOCOL_IPV6) 375 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 376 .setCarrierEnabled(true) 377 .setNetworkTypeBitmask((int) TelephonyManager.NETWORK_TYPE_BITMASK_LTE 378 | (int) TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT) 379 .setProfileId(1236) 380 .setMaxConns(321) 381 .setWaitTime(456) 382 .setMaxConnsTime(789) 383 .build()) 384 .setPreferred(false) 385 .build(); 386 387 private final DataProfile mEnterpriseDataProfile = new DataProfile.Builder() 388 .setTrafficDescriptor(new TrafficDescriptor(null, 389 new TrafficDescriptor.OsAppId(TrafficDescriptor.OsAppId.ANDROID_OS_ID, 390 "ENTERPRISE", 1).getBytes())) 391 .build(); 392 393 private final DataProfile mLowLatencyDataProfile = new DataProfile.Builder() 394 .setTrafficDescriptor(new TrafficDescriptor(null, 395 new TrafficDescriptor.OsAppId(TrafficDescriptor.OsAppId.ANDROID_OS_ID, 396 "PRIORITIZE_LATENCY", 1).getBytes())) 397 .build(); 398 399 private final DataProfile mNtnDataProfile = new DataProfile.Builder() 400 .setApnSetting(new ApnSetting.Builder() 401 .setEntryName("ntn") 402 .setApnName("ntn") 403 .setApnTypeBitmask(ApnSetting.TYPE_RCS) 404 .setCarrierEnabled(true) 405 .setInfrastructureBitmask(ApnSetting.INFRASTRUCTURE_SATELLITE) 406 .build()) 407 .setPreferred(false) 408 .build(); 409 410 private final DataProfile mEsimBootstrapDataProfile = new DataProfile.Builder() 411 .setApnSetting(new ApnSetting.Builder() 412 .setEntryName("ESIM BOOTSTRAP") 413 .setApnName("ESIM BOOTSTRAP") 414 .setApnTypeBitmask(ApnSetting.TYPE_DEFAULT) 415 .setNetworkTypeBitmask((int) TelephonyManager.NETWORK_TYPE_BITMASK_LTE 416 | (int) TelephonyManager.NETWORK_TYPE_BITMASK_NR) 417 .setCarrierEnabled(true) 418 .setEsimBootstrapProvisioning(true) 419 .build()) 420 .setPreferred(false) 421 .build(); 422 423 private final DataProfile mEsimBootstrapImsProfile = new DataProfile.Builder() 424 .setApnSetting(new ApnSetting.Builder() 425 .setEntryName("IMS BOOTSTRAP") 426 .setApnName("IMS BOOTSTRAP") 427 .setApnTypeBitmask(ApnSetting.TYPE_IMS) 428 .setNetworkTypeBitmask((int) TelephonyManager.NETWORK_TYPE_BITMASK_LTE 429 | (int) TelephonyManager.NETWORK_TYPE_BITMASK_NR) 430 .setCarrierEnabled(true) 431 .setEsimBootstrapProvisioning(true) 432 .build()) 433 .setPreferred(false) 434 .build(); 435 436 private final DataProfile mEsimBootstrapRcsInfraStructureProfile = 437 new DataProfile.Builder() 438 .setApnSetting(new ApnSetting.Builder() 439 .setEntryName("INFRASTRUCTURE BOOTSTRAP") 440 .setApnName("INFRASTRUCTURE BOOTSTRAP") 441 .setApnTypeBitmask(ApnSetting.TYPE_RCS) 442 .setNetworkTypeBitmask((int) TelephonyManager.NETWORK_TYPE_BITMASK_LTE 443 | (int) TelephonyManager.NETWORK_TYPE_BITMASK_NR) 444 .setCarrierEnabled(true) 445 .setInfrastructureBitmask(2) 446 .setEsimBootstrapProvisioning(true) 447 .build()) 448 .setPreferred(false) 449 .build(); 450 451 /** Data call response map. The first key is the transport type, the second key is the cid. */ 452 private final Map<Integer, Map<Integer, DataCallResponse>> mDataCallResponses = new HashMap<>(); 453 createDataCallResponse(int cid, @LinkStatus int linkStatus)454 private @NonNull DataCallResponse createDataCallResponse(int cid, @LinkStatus int linkStatus) { 455 return createDataCallResponse(cid, linkStatus, Collections.emptyList()); 456 } 457 createDataCallResponse(int cid, @LinkStatus int linkStatus, @NonNull List<TrafficDescriptor> tdList)458 private @NonNull DataCallResponse createDataCallResponse(int cid, @LinkStatus int linkStatus, 459 @NonNull List<TrafficDescriptor> tdList) { 460 return new DataCallResponse.Builder() 461 .setCause(0) 462 .setRetryDurationMillis(-1L) 463 .setId(cid) 464 .setLinkStatus(linkStatus) 465 .setProtocolType(ApnSetting.PROTOCOL_IPV4V6) 466 .setInterfaceName("ifname" + cid) 467 .setAddresses(Arrays.asList( 468 new LinkAddress(InetAddresses.parseNumericAddress(IPV4_ADDRESS), 32), 469 new LinkAddress(IPV6_ADDRESS + "/64"))) 470 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress("10.0.2.3"), 471 InetAddresses.parseNumericAddress("fd00:976a::9"))) 472 .setGatewayAddresses(Arrays.asList( 473 InetAddresses.parseNumericAddress("10.0.2.15"), 474 InetAddresses.parseNumericAddress("fe80::2"))) 475 .setPcscfAddresses(Arrays.asList( 476 InetAddresses.parseNumericAddress("fd00:976a:c305:1d::8"), 477 InetAddresses.parseNumericAddress("fd00:976a:c202:1d::7"), 478 InetAddresses.parseNumericAddress("fd00:976a:c305:1d::5"))) 479 .setMtu(1500) 480 .setMtuV4(1500) 481 .setMtuV6(1500) 482 .setPduSessionId(1) 483 .setQosBearerSessions(new ArrayList<>()) 484 .setTrafficDescriptors(tdList) 485 .build(); 486 } 487 setFailedSetupDataResponse(DataServiceManager dsm, @DataFailureCause int cause, long retryMillis, boolean forHandover)488 private void setFailedSetupDataResponse(DataServiceManager dsm, @DataFailureCause int cause, 489 long retryMillis, boolean forHandover) { 490 setFailedSetupDataResponse(dsm, cause, retryMillis, forHandover, 0); 491 } 492 setFailedSetupDataResponse(DataServiceManager dsm, @DataFailureCause int cause, long retryMillis, boolean forHandover, long delay)493 private void setFailedSetupDataResponse(DataServiceManager dsm, @DataFailureCause int cause, 494 long retryMillis, boolean forHandover, long delay) { 495 doAnswer(invocation -> { 496 final Message msg = (Message) invocation.getArguments()[10]; 497 498 DataCallResponse response = new DataCallResponse.Builder() 499 .setCause(cause) 500 .setRetryDurationMillis(retryMillis) 501 .setHandoverFailureMode( 502 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_HANDOVER) 503 .build(); 504 msg.getData().putParcelable("data_call_response", response); 505 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 506 msg.getTarget().sendMessageDelayed(msg, delay); 507 return null; 508 }).when(dsm).setupDataCall(anyInt(), any(DataProfile.class), anyBoolean(), 509 anyBoolean(), forHandover ? eq(DataService.REQUEST_REASON_HANDOVER) 510 : eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), 511 anyBoolean(), any(Message.class)); 512 } 513 setSuccessfulSetupDataResponse(DataServiceManager dsm, DataCallResponse response)514 private void setSuccessfulSetupDataResponse(DataServiceManager dsm, DataCallResponse response) { 515 doAnswer(invocation -> { 516 final Message msg = (Message) invocation.getArguments()[10]; 517 518 int transport = AccessNetworkConstants.TRANSPORT_TYPE_INVALID; 519 if (dsm == mMockedWwanDataServiceManager) { 520 transport = AccessNetworkConstants.TRANSPORT_TYPE_WWAN; 521 } else if (dsm == mMockedWlanDataServiceManager) { 522 transport = AccessNetworkConstants.TRANSPORT_TYPE_WLAN; 523 } 524 mDataCallResponses.computeIfAbsent(transport, v -> new HashMap<>()); 525 mDataCallResponses.get(transport).put(response.getId(), response); 526 msg.getData().putParcelable("data_call_response", response); 527 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 528 msg.sendToTarget(); 529 530 mDataCallListChangedRegistrants.get(transport).notifyRegistrants( 531 new AsyncResult(transport, new ArrayList<>(mDataCallResponses.get( 532 transport).values()), null)); 533 return null; 534 }).when(dsm).setupDataCall(anyInt(), any(DataProfile.class), anyBoolean(), 535 anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 536 any(Message.class)); 537 } 538 setSuccessfulSetupDataResponse(DataServiceManager dsm, int cid)539 private void setSuccessfulSetupDataResponse(DataServiceManager dsm, int cid) { 540 setSuccessfulSetupDataResponse(dsm, cid, 0L); 541 } 542 setSuccessfulSetupDataResponse(DataServiceManager dsm, int cid, long delay)543 private void setSuccessfulSetupDataResponse(DataServiceManager dsm, int cid, long delay) { 544 doAnswer(invocation -> { 545 final Message msg = (Message) invocation.getArguments()[10]; 546 547 DataCallResponse response = createDataCallResponse(cid, 548 DataCallResponse.LINK_STATUS_ACTIVE); 549 int transport = AccessNetworkConstants.TRANSPORT_TYPE_INVALID; 550 if (dsm == mMockedWwanDataServiceManager) { 551 transport = AccessNetworkConstants.TRANSPORT_TYPE_WWAN; 552 } else if (dsm == mMockedWlanDataServiceManager) { 553 transport = AccessNetworkConstants.TRANSPORT_TYPE_WLAN; 554 } 555 mDataCallResponses.computeIfAbsent(transport, v -> new HashMap<>()); 556 mDataCallResponses.get(transport).put(cid, response); 557 msg.getData().putParcelable("data_call_response", response); 558 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 559 msg.getTarget().sendMessageDelayed(msg, delay); 560 561 final int t = transport; 562 msg.getTarget().postDelayed(() -> { 563 mDataCallListChangedRegistrants.get(t).notifyRegistrants( 564 new AsyncResult(t, new ArrayList<>(mDataCallResponses.get( 565 t).values()), null)); 566 567 }, delay + 100); 568 return null; 569 }).when(dsm).setupDataCall(anyInt(), any(DataProfile.class), anyBoolean(), 570 anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 571 any(Message.class)); 572 } 573 clearCallbacks()574 private void clearCallbacks() throws Exception { 575 Field field = DataNetworkController.class 576 .getDeclaredField("mDataNetworkControllerCallbacks"); 577 field.setAccessible(true); 578 ((Set<DataNetworkControllerCallback>) field.get(mDataNetworkControllerUT)).clear(); 579 } 580 carrierConfigChanged()581 private void carrierConfigChanged() { 582 // Trigger carrier config reloading 583 mCarrierConfigChangeListener.onCarrierConfigChanged(0 /* logicalSlotIndex */, 584 SubscriptionManager.INVALID_SUBSCRIPTION_ID, 585 TelephonyManager.UNKNOWN_CARRIER_ID, TelephonyManager.UNKNOWN_CARRIER_ID); 586 587 processAllMessages(); 588 } 589 setImsRegistered(boolean registered)590 private void setImsRegistered(boolean registered) { 591 if (registered) { 592 final ArraySet<String> features = new ArraySet<>(); 593 features.add("feature1"); 594 features.add("feature2"); 595 ImsRegistrationAttributes attr = new ImsRegistrationAttributes.Builder( 596 ImsRegistrationImplBase.REGISTRATION_TECH_LTE).setFeatureTags(features).build(); 597 598 mMmtelRegCallback.onRegistered(attr); 599 } else { 600 ImsReasonInfo info = new ImsReasonInfo(ImsReasonInfo.CODE_LOCAL_ILLEGAL_STATE, -1, ""); 601 mMmtelRegCallback.onUnregistered(info); 602 } 603 } 604 setRcsRegistered(boolean registered)605 private void setRcsRegistered(boolean registered) { 606 if (registered) { 607 final ArraySet<String> features = new ArraySet<>(); 608 features.add("feature1"); 609 features.add("feature2"); 610 ImsRegistrationAttributes attr = new ImsRegistrationAttributes.Builder( 611 ImsRegistrationImplBase.REGISTRATION_TECH_LTE).setFeatureTags(features).build(); 612 613 mRcsRegCallback.onRegistered(attr); 614 } else { 615 ImsReasonInfo info = new ImsReasonInfo(ImsReasonInfo.CODE_LOCAL_ILLEGAL_STATE, -1, ""); 616 mRcsRegCallback.onUnregistered(info); 617 } 618 } 619 serviceStateChanged(@etworkType int networkType, @RegistrationState int regState)620 private void serviceStateChanged(@NetworkType int networkType, 621 @RegistrationState int regState) { 622 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo.Builder(8) 623 .setNrAvailable(true) 624 .setEnDcAvailable(true) 625 .setVopsSupportInfo(new LteVopsSupportInfo( 626 LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 627 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)) 628 .build(); 629 630 serviceStateChanged(networkType, regState, regState, 631 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 632 } 633 serviceStateChanged(@etworkType int networkType, @RegistrationState int regState, DataSpecificRegistrationInfo dsri)634 private void serviceStateChanged(@NetworkType int networkType, 635 @RegistrationState int regState, DataSpecificRegistrationInfo dsri) { 636 serviceStateChanged(networkType, regState, regState, 637 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 638 } 639 serviceStateChanged(@etworkType int networkType, @RegistrationState int dataRegState, @RegistrationState int voiceRegState, @RegistrationState int iwlanRegState, DataSpecificRegistrationInfo dsri)640 private void serviceStateChanged(@NetworkType int networkType, 641 @RegistrationState int dataRegState, @RegistrationState int voiceRegState, 642 @RegistrationState int iwlanRegState, DataSpecificRegistrationInfo dsri) { 643 boolean isEmergencyOnly = false; 644 if (dataRegState == NetworkRegistrationInfo.REGISTRATION_STATE_DENIED) { 645 isEmergencyOnly = true; 646 } 647 ServiceState ss = createSS(networkType, networkType, dataRegState, voiceRegState, 648 iwlanRegState, dsri, isEmergencyOnly); 649 650 doReturn(ss).when(mSST).getServiceState(); 651 doReturn(ss).when(mPhone).getServiceState(); 652 653 mDataNetworkControllerUT.obtainMessage(17/*EVENT_SERVICE_STATE_CHANGED*/).sendToTarget(); 654 processAllMessages(); 655 } 656 serviceStateChanged(@etworkType int networkType, @RegistrationState int dataRegState, @RegistrationState int voiceRegState, @RegistrationState int iwlanRegState, DataSpecificRegistrationInfo dsri, boolean isEmergencyOnly)657 private void serviceStateChanged(@NetworkType int networkType, 658 @RegistrationState int dataRegState, @RegistrationState int voiceRegState, 659 @RegistrationState int iwlanRegState, DataSpecificRegistrationInfo dsri, 660 boolean isEmergencyOnly) { 661 ServiceState ss = createSS(networkType, networkType, dataRegState, voiceRegState, 662 iwlanRegState, dsri, isEmergencyOnly); 663 664 doReturn(ss).when(mSST).getServiceState(); 665 doReturn(ss).when(mPhone).getServiceState(); 666 667 mDataNetworkControllerUT.obtainMessage(EVENT_SERVICE_STATE_CHANGED).sendToTarget(); 668 processAllMessages(); 669 } 670 createSS(@etworkType int dataNetworkType, @NetworkType int voiceNetworkType, @RegistrationState int dataRegState, @RegistrationState int voiceRegState, @RegistrationState int iwlanRegState, DataSpecificRegistrationInfo dsri, boolean isEmergencyOnly)671 private ServiceState createSS(@NetworkType int dataNetworkType, 672 @NetworkType int voiceNetworkType, 673 @RegistrationState int dataRegState, @RegistrationState int voiceRegState, 674 @RegistrationState int iwlanRegState, DataSpecificRegistrationInfo dsri, 675 boolean isEmergencyOnly) { 676 if (dsri == null) { 677 dsri = new DataSpecificRegistrationInfo.Builder(8) 678 .setNrAvailable(true) 679 .setEnDcAvailable(true) 680 .setVopsSupportInfo(new LteVopsSupportInfo( 681 LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 682 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)) 683 .build(); 684 } 685 686 ServiceState ss = new ServiceState(); 687 688 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 689 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 690 .setAccessNetworkTechnology(dataNetworkType) 691 .setRegistrationState(dataRegState) 692 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 693 .setDataSpecificInfo(dsri) 694 .setIsNonTerrestrialNetwork(mIsNonTerrestrialNetwork) 695 .setAvailableServices(mCarrierSupportedServices) 696 .setEmergencyOnly(isEmergencyOnly) 697 .build()); 698 699 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 700 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 701 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN) 702 .setRegistrationState(iwlanRegState) 703 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 704 .setIsNonTerrestrialNetwork(mIsNonTerrestrialNetwork) 705 .setAvailableServices(mCarrierSupportedServices) 706 .setEmergencyOnly(isEmergencyOnly) 707 .build()); 708 709 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 710 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 711 .setAccessNetworkTechnology(voiceNetworkType) 712 .setRegistrationState(voiceRegState) 713 .setDomain(NetworkRegistrationInfo.DOMAIN_CS) 714 .setEmergencyOnly(isEmergencyOnly) 715 .build()); 716 717 ss.setDataRoamingFromRegistration(dataRegState 718 == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 719 processServiceStateRegStateForTest(ss); 720 return ss; 721 } 722 723 // set SS reg state base on SST impl, where WLAN overrides WWAN's data reg. processServiceStateRegStateForTest(ServiceState ss)724 private void processServiceStateRegStateForTest(ServiceState ss) { 725 int wlanRegState = ss.getNetworkRegistrationInfo(NetworkRegistrationInfo.DOMAIN_PS, 726 AccessNetworkConstants.TRANSPORT_TYPE_WLAN).getRegistrationState(); 727 if (wlanRegState == NetworkRegistrationInfo.REGISTRATION_STATE_HOME) { 728 ss.setDataRegState(ServiceState.STATE_IN_SERVICE); 729 } else { 730 int cellularRegState = ss.getNetworkRegistrationInfo(NetworkRegistrationInfo.DOMAIN_PS, 731 AccessNetworkConstants.TRANSPORT_TYPE_WWAN).getRegistrationState(); 732 int dataState = (cellularRegState == NetworkRegistrationInfo.REGISTRATION_STATE_HOME 733 || cellularRegState == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING) 734 ? ServiceState.STATE_IN_SERVICE : ServiceState.STATE_OUT_OF_SERVICE; 735 ss.setDataRegState(dataState); 736 } 737 int voiceRegState = ss.getNetworkRegistrationInfo(NetworkRegistrationInfo.DOMAIN_CS, 738 AccessNetworkConstants.TRANSPORT_TYPE_WWAN).getRegistrationState(); 739 int voiceState = (voiceRegState == NetworkRegistrationInfo.REGISTRATION_STATE_HOME 740 || voiceRegState == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING) 741 ? ServiceState.STATE_IN_SERVICE : ServiceState.STATE_OUT_OF_SERVICE; 742 ss.setVoiceRegState(voiceState); 743 } 744 updateTransport(@etCapability int capability, @TransportType int transport)745 private void updateTransport(@NetCapability int capability, @TransportType int transport) { 746 doReturn(transport).when(mAccessNetworksManager) 747 .getPreferredTransportByNetworkCapability(capability); 748 mAccessNetworksManagerCallback.onPreferredTransportChanged(capability, false); 749 processAllMessages(); 750 } 751 reconnectTransport(@etCapability int capability, @TransportType int transport)752 private void reconnectTransport(@NetCapability int capability, @TransportType int transport) { 753 doReturn(transport).when(mAccessNetworksManager) 754 .getPreferredTransportByNetworkCapability(capability); 755 mAccessNetworksManagerCallback.onPreferredTransportChanged(capability, true); 756 processAllMessages(); 757 } 758 setVcnManagerPolicy(boolean vcnManaged, boolean shouldTearDown)759 private void setVcnManagerPolicy(boolean vcnManaged, boolean shouldTearDown) { 760 doAnswer(invocation -> { 761 final NetworkCapabilities networkCapabilities = 762 (NetworkCapabilities) invocation.getArguments()[0]; 763 if (vcnManaged) { 764 networkCapabilities.removeCapability( 765 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED); 766 } else { 767 networkCapabilities.addCapability( 768 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED); 769 } 770 return new VcnNetworkPolicyResult( 771 shouldTearDown, networkCapabilities); 772 }).when(mVcnManager).applyVcnNetworkPolicy(any(NetworkCapabilities.class), 773 any(LinkProperties.class)); 774 } 775 initializeConfig()776 private void initializeConfig() { 777 mCarrierConfig = mContextFixture.getCarrierConfigBundle(); 778 when(mCarrierConfigManager.getConfigForSubId(anyInt(), any())).thenReturn(mCarrierConfig); 779 mCarrierConfig.putStringArray( 780 CarrierConfigManager.KEY_TELEPHONY_NETWORK_CAPABILITY_PRIORITIES_STRING_ARRAY, 781 new String[]{ 782 "eims:90", "supl:80", "mms:70", "xcap:70", "cbs:50", "mcx:50", "fota:50", 783 "ims:40", "dun:30", "enterprise:20", "internet:20" 784 }); 785 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CONFIG_APPLIED_BOOL, true); 786 mCarrierConfig.putStringArray( 787 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 788 new String[]{"default", "mms", "dun", "supl", "enterprise"}); 789 mCarrierConfig.putStringArray( 790 CarrierConfigManager.KEY_CARRIER_METERED_ROAMING_APN_TYPES_STRINGS, 791 new String[]{"default", "mms", "dun", "supl", "enterprise"}); 792 793 mCarrierConfig.putStringArray( 794 CarrierConfigManager.KEY_TELEPHONY_DATA_SETUP_RETRY_RULES_STRING_ARRAY, 795 new String[]{ 796 "capabilities=eims, retry_interval=1000, maximum_retries=20", 797 "permanent_fail_causes=8|27|28|29|30|32|33|35|50|51|111|-5|-6|65537|65538|" 798 + "-3|65543|65547|2252|2253|2254, retry_interval=2500", 799 "capabilities=mms|supl|cbs|rcs, retry_interval=2000", 800 "capabilities=internet|enterprise|dun|ims|fota|xcap|mcx|" 801 + "prioritize_bandwidth|prioritize_latency, retry_interval=" 802 + "2500|3000|5000|10000|15000|20000|40000|60000|120000|240000|" 803 + "600000|1200000|1800000, maximum_retries=20" 804 }); 805 mCarrierConfig.putStringArray( 806 CarrierConfigManager.KEY_TELEPHONY_DATA_HANDOVER_RETRY_RULES_STRING_ARRAY, 807 new String[] {"retry_interval=1000|2000|4000|8000|16000, maximum_retries=5" 808 }); 809 810 mCarrierConfig.putInt(CarrierConfigManager.KEY_NR_ADVANCED_CAPABLE_PCO_ID_INT, 1234); 811 812 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_NETWORK_TEMP_NOT_METERED_SUPPORTED_BOOL, 813 true); 814 mCarrierConfig.putStringArray(CarrierConfigManager.KEY_UNMETERED_NETWORK_TYPES_STRING_ARRAY, 815 new String[] {"NR_NSA", "NR_NSA_MMWAVE", "NR_SA", "NR_SA_MMWAVE"}); 816 817 mCarrierConfig.putIntArray(CarrierConfigManager.KEY_ONLY_SINGLE_DC_ALLOWED_INT_ARRAY, 818 new int[]{TelephonyManager.NETWORK_TYPE_CDMA, TelephonyManager.NETWORK_TYPE_1xRTT, 819 TelephonyManager.NETWORK_TYPE_EVDO_0, TelephonyManager.NETWORK_TYPE_EVDO_A, 820 TelephonyManager.NETWORK_TYPE_EVDO_B}); 821 822 mCarrierConfig.putIntArray(CarrierConfigManager 823 .KEY_CAPABILITIES_EXEMPT_FROM_SINGLE_DC_CHECK_INT_ARRAY, 824 new int[]{NetworkCapabilities.NET_CAPABILITY_IMS}); 825 mCarrierConfig.putBooleanArray( 826 CarrierConfigManager.KEY_DATA_STALL_RECOVERY_SHOULD_SKIP_BOOL_ARRAY, 827 new boolean[] {false, false, true, false, false} 828 ); 829 mCarrierConfig.putLongArray(CarrierConfigManager.KEY_DATA_STALL_RECOVERY_TIMERS_LONG_ARRAY, 830 new long[] {180000, 180000, 180000, 180000}); 831 832 mCarrierConfig.putLongArray(CarrierConfigManager.KEY_DATA_STALL_RECOVERY_TIMERS_LONG_ARRAY, 833 new long[] {100, 100, 100, 100}); 834 mCarrierConfig.putBooleanArray( 835 CarrierConfigManager.KEY_DATA_STALL_RECOVERY_SHOULD_SKIP_BOOL_ARRAY, 836 new boolean[] {false, false, true, false, false}); 837 838 mContextFixture.putResource(com.android.internal.R.string.config_bandwidthEstimateSource, 839 "bandwidth_estimator"); 840 841 mContextFixture.putBooleanResource(com.android.internal.R.bool 842 .config_honor_data_retry_timer_for_emergency_network, true); 843 mContextFixture.putIntResource(com.android.internal.R.integer 844 .config_delay_for_ims_dereg_millis, 3000); 845 mContextFixture.putBooleanResource(com.android.internal.R.bool 846 .config_enable_iwlan_handover_policy, true); 847 mContextFixture.putBooleanResource(com.android.internal.R.bool 848 .config_enhanced_iwlan_handover_check, true); 849 mContextFixture.putStringArrayResource(com.android.internal.R.array 850 .config_force_cellular_transport_capabilities, 851 new String[] {"ims", "eims", "xcap"}); 852 mContextFixture.putIntResource(com.android.internal.R.integer 853 .config_reevaluate_bootstrap_sim_data_usage_millis, 60000); 854 } 855 856 @Before setUp()857 public void setUp() throws Exception { 858 logd("DataNetworkControllerTest +Setup!"); 859 super.setUp(getClass().getSimpleName()); 860 mMockedIsub = Mockito.mock(ISub.class); 861 mMockedImsManager = mContext.getSystemService(ImsManager.class); 862 mMockedImsMmTelManager = Mockito.mock(ImsMmTelManager.class); 863 mMockedImsRcsManager = Mockito.mock(ImsRcsManager.class); 864 mMockedImsResolver = Mockito.mock(ImsResolver.class); 865 mMockedDataStallRecoveryManager = Mockito.mock(DataStallRecoveryManager.class); 866 mMockedDataNetworkControllerCallback = Mockito.mock(DataNetworkControllerCallback.class); 867 mMockedDataRetryManagerCallback = Mockito.mock(DataRetryManagerCallback.class); 868 mMockSubInfo = Mockito.mock(SubscriptionInfo.class); 869 mMockPackageManager = Mockito.mock(PackageManager.class); 870 when(mTelephonyComponentFactory.makeDataSettingsManager(any(Phone.class), 871 any(DataNetworkController.class), any(FeatureFlags.class), any(Looper.class), 872 any(DataSettingsManager.DataSettingsManagerCallback.class))).thenCallRealMethod(); 873 doReturn(mMockedImsMmTelManager).when(mMockedImsManager).getImsMmTelManager(anyInt()); 874 doReturn(mMockedImsRcsManager).when(mMockedImsManager).getImsRcsManager(anyInt()); 875 876 initializeConfig(); 877 mMockedDataServiceManagers.put(AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 878 mMockedWwanDataServiceManager); 879 mMockedDataServiceManagers.put(AccessNetworkConstants.TRANSPORT_TYPE_WLAN, 880 mMockedWlanDataServiceManager); 881 882 doReturn(1).when(mMockedIsub).getDefaultDataSubId(); 883 doReturn(mMockedIsub).when(mIBinder).queryLocalInterface(anyString()); 884 doReturn(mPhone).when(mPhone).getImsPhone(); 885 mServiceManagerMockedServices.put("isub", mIBinder); 886 doReturn(new SubscriptionPlan[]{}).when(mNetworkPolicyManager) 887 .getSubscriptionPlans(anyInt(), any()); 888 doReturn(true).when(mSST).getDesiredPowerState(); 889 doReturn(true).when(mSST).getPowerStateFromCarrier(); 890 doReturn(true).when(mSST).isConcurrentVoiceAndDataAllowed(); 891 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 892 doReturn(new SubscriptionInfoInternal.Builder().setId(1).build()) 893 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 894 doReturn(true).when(mFeatureFlags).incallHandoverPolicy(); 895 896 when(mContext.getPackageManager()).thenReturn(mMockPackageManager); 897 doReturn(true).when(mMockPackageManager).hasSystemFeature(anyString()); 898 899 List<SubscriptionInfo> infoList = new ArrayList<>(); 900 infoList.add(mMockSubInfo); 901 doReturn(0).when(mSubscriptionManagerService).getPhoneId(1); 902 doReturn(1).when(mSubscriptionManagerService).getPhoneId(2); 903 904 for (int transport : new int[]{AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 905 AccessNetworkConstants.TRANSPORT_TYPE_WLAN}) { 906 mDataCallListChangedRegistrants.put(transport, new RegistrantList()); 907 setSuccessfulSetupDataResponse(mMockedDataServiceManagers.get(transport), 1); 908 doAnswer(invocation -> { 909 int cid = (int) invocation.getArguments()[0]; 910 Message msg = (Message) invocation.getArguments()[2]; 911 msg.sendToTarget(); 912 mDataCallResponses.get(transport).remove(cid); 913 mDataCallListChangedRegistrants.get(transport).notifyRegistrants( 914 new AsyncResult(transport, new ArrayList<>(mDataCallResponses.get( 915 transport).values()), null)); 916 return null; 917 }).when(mMockedDataServiceManagers.get(transport)).deactivateDataCall( 918 anyInt(), anyInt(), any(Message.class)); 919 920 doAnswer(invocation -> { 921 Handler h = (Handler) invocation.getArguments()[0]; 922 int what = (int) invocation.getArguments()[1]; 923 mDataCallListChangedRegistrants.get(transport).addUnique(h, what, transport); 924 return null; 925 }).when(mMockedDataServiceManagers.get(transport)).registerForDataCallListChanged(any( 926 Handler.class), anyInt()); 927 928 doAnswer(invocation -> { 929 Message msg = (Message) invocation.getArguments()[1]; 930 msg.sendToTarget(); 931 return null; 932 }).when(mMockedDataServiceManagers.get(transport)).startHandover(anyInt(), 933 any(Message.class)); 934 935 doAnswer(invocation -> { 936 Message msg = (Message) invocation.getArguments()[1]; 937 msg.sendToTarget(); 938 return null; 939 }).when(mMockedDataServiceManagers.get(transport)).cancelHandover(anyInt(), 940 any(Message.class)); 941 } 942 943 doReturn(-1).when(mPhone).getSubId(); 944 945 // Capture listener to emulate the carrier config change notification used later 946 ArgumentCaptor<CarrierConfigManager.CarrierConfigChangeListener> listenerArgumentCaptor = 947 ArgumentCaptor.forClass(CarrierConfigManager.CarrierConfigChangeListener.class); 948 // Note that creating a "real" data network controller will also result in creating 949 // real DataRetryManager, DataConfigManager, etc...Normally in unit test we should isolate 950 // other modules and make them mocked, but only focusing on testing the unit we would like 951 // to test, in this case, DataNetworkController. But since there are too many interactions 952 // between DataNetworkController and its sub-modules, we intend to make those modules "real" 953 // as well, except some modules below we replaced with mocks. 954 mDataNetworkControllerUT = new DataNetworkController(mPhone, Looper.myLooper(), 955 mFeatureFlags); 956 // First two come from DataServiceManager and the third comes from DataConfigManager which 957 // is what we want to capture and assign to mCarrierConfigChangeListener 958 verify(mCarrierConfigManager, times(3)).registerCarrierConfigChangeListener(any(), 959 listenerArgumentCaptor.capture()); 960 mCarrierConfigChangeListener = listenerArgumentCaptor.getAllValues().get(2); 961 assertThat(mCarrierConfigChangeListener).isNotNull(); 962 doReturn(mDataNetworkControllerUT).when(mPhone).getDataNetworkController(); 963 964 doReturn(1).when(mPhone).getSubId(); 965 mDataNetworkControllerUT.obtainMessage(15/*EVENT_SUBSCRIPTION_CHANGED*/).sendToTarget(); 966 967 processAllMessages(); 968 // Clear the callbacks created by the real sub-modules created by DataNetworkController. 969 clearCallbacks(); 970 SparseArray<DataServiceManager> dataServiceManagers = new SparseArray<>(); 971 dataServiceManagers.put(AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 972 mMockedWwanDataServiceManager); 973 dataServiceManagers.put(AccessNetworkConstants.TRANSPORT_TYPE_WLAN, 974 mMockedWlanDataServiceManager); 975 replaceInstance(DataNetworkController.class, "mDataServiceManagers", 976 mDataNetworkControllerUT, dataServiceManagers); 977 replaceInstance(DataNetworkController.class, "mDataProfileManager", 978 mDataNetworkControllerUT, mDataProfileManager); 979 replaceInstance(DataNetworkController.class, "mAccessNetworksManager", 980 mDataNetworkControllerUT, mAccessNetworksManager); 981 replaceInstance(ImsResolver.class, "sInstance", null, mMockedImsResolver); 982 replaceInstance(DataNetworkController.class, "mDataStallRecoveryManager", 983 mDataNetworkControllerUT, mMockedDataStallRecoveryManager); 984 985 ArgumentCaptor<AccessNetworksManagerCallback> callbackCaptor = 986 ArgumentCaptor.forClass(AccessNetworksManagerCallback.class); 987 verify(mAccessNetworksManager).registerCallback(callbackCaptor.capture()); 988 mAccessNetworksManagerCallback = callbackCaptor.getValue(); 989 990 ArgumentCaptor<LinkBandwidthEstimatorCallback> linkBandwidthEstimatorCallbackCaptor = 991 ArgumentCaptor.forClass(LinkBandwidthEstimatorCallback.class); 992 verify(mLinkBandwidthEstimator).registerCallback( 993 linkBandwidthEstimatorCallbackCaptor.capture()); 994 mLinkBandwidthEstimatorCallback = linkBandwidthEstimatorCallbackCaptor.getValue(); 995 996 List<DataProfile> profiles = List.of(mGeneralPurposeDataProfile, 997 mGeneralPurposeDataProfileAlternative, mImsCellularDataProfile, 998 mImsIwlanDataProfile, mEmergencyDataProfile, mFotaDataProfile, 999 mTetheringDataProfile, mLowLatencyDataProfile, 1000 mNtnDataProfile, mEsimBootstrapDataProfile, 1001 mEsimBootstrapImsProfile, mEsimBootstrapRcsInfraStructureProfile); 1002 1003 doAnswer(invocation -> { 1004 DataProfile dp = (DataProfile) invocation.getArguments()[0]; 1005 1006 if (dp.getApnSetting() == null) return true; 1007 1008 for (DataProfile dataProfile : profiles) { 1009 if (dataProfile.getApnSetting() != null 1010 && dataProfile.getApnSetting().equals(dp.getApnSetting(), false)) { 1011 return true; 1012 } 1013 } 1014 return null; 1015 }).when(mDataProfileManager).isDataProfileCompatible(any(DataProfile.class)); 1016 1017 doAnswer(invocation -> { 1018 DataProfile a = (DataProfile) invocation.getArguments()[0]; 1019 DataProfile b = (DataProfile) invocation.getArguments()[1]; 1020 return a != null 1021 && b != null 1022 && a.getApnSetting() != null 1023 && a.getApnSetting().equals(b.getApnSetting(), 1024 mPhone.getServiceState().getDataRoamingFromRegistration()); 1025 }).when(mDataProfileManager).areDataProfilesSharingApn(any(DataProfile.class), 1026 any(DataProfile.class)); 1027 1028 doAnswer(invocation -> { 1029 TelephonyNetworkRequest networkRequest = 1030 (TelephonyNetworkRequest) invocation.getArguments()[0]; 1031 int networkType = (int) invocation.getArguments()[1]; 1032 boolean isNtn = (boolean) invocation.getArguments()[2]; 1033 boolean isEsimBootstrapProvisioning = (boolean) invocation.getArguments()[3]; 1034 boolean ignorePermanentFailure = (boolean) invocation.getArguments()[4]; 1035 1036 for (DataProfile dataProfile : profiles) { 1037 ApnSetting apnSetting = dataProfile.getApnSetting(); 1038 if (apnSetting != null 1039 && dataProfile.canSatisfy(networkRequest.getCapabilities()) 1040 && (apnSetting.getNetworkTypeBitmask() == 0 1041 || (apnSetting.getNetworkTypeBitmask() 1042 & ServiceState.getBitmaskForTech(networkType)) != 0) 1043 && (isEsimBootstrapProvisioning 1044 == apnSetting.isEsimBootstrapProvisioning()) 1045 && ((isNtn && apnSetting.isForInfrastructure( 1046 ApnSetting.INFRASTRUCTURE_SATELLITE)) 1047 || (!isNtn && apnSetting.isForInfrastructure( 1048 ApnSetting.INFRASTRUCTURE_CELLULAR))) 1049 && (ignorePermanentFailure || !apnSetting.getPermanentFailed())) { 1050 return dataProfile; 1051 } 1052 } 1053 logd("Cannot find data profile to satisfy " + networkRequest + ", network type=" 1054 + TelephonyManager.getNetworkTypeName(networkType) + ", ignorePermanentFailure=" 1055 + ignorePermanentFailure + ", isNtn=" + isNtn + "," 1056 + "isEsimBootstrapProvisioning=" + isEsimBootstrapProvisioning); 1057 return null; 1058 }).when(mDataProfileManager).getDataProfileForNetworkRequest( 1059 any(TelephonyNetworkRequest.class), anyInt(), anyBoolean(), anyBoolean(), 1060 anyBoolean()); 1061 1062 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 1063 .getPreferredTransportByNetworkCapability(anyInt()); 1064 1065 doAnswer(invocation -> { 1066 ((Runnable) invocation.getArguments()[0]).run(); 1067 return null; 1068 }).when(mMockedDataNetworkControllerCallback).invokeFromExecutor(any(Runnable.class)); 1069 doAnswer(invocation -> { 1070 ((Runnable) invocation.getArguments()[0]).run(); 1071 return null; 1072 }).when(mMockedDataRetryManagerCallback).invokeFromExecutor(any(Runnable.class)); 1073 1074 mDataNetworkControllerUT.registerDataNetworkControllerCallback( 1075 mMockedDataNetworkControllerCallback); 1076 1077 mDataNetworkControllerUT.obtainMessage(EVENT_SIM_STATE_CHANGED, 1078 10/*SIM_STATE_LOADED*/, 0).sendToTarget(); 1079 mDataNetworkControllerUT.obtainMessage(8/*EVENT_DATA_SERVICE_BINDING_CHANGED*/, 1080 new AsyncResult(AccessNetworkConstants.TRANSPORT_TYPE_WWAN, true, null)) 1081 .sendToTarget(); 1082 mDataNetworkControllerUT.obtainMessage(8/*EVENT_DATA_SERVICE_BINDING_CHANGED*/, 1083 new AsyncResult(AccessNetworkConstants.TRANSPORT_TYPE_WLAN, true, null)) 1084 .sendToTarget(); 1085 1086 ArgumentCaptor<ImsStateCallback> imsCallbackCaptor = 1087 ArgumentCaptor.forClass(ImsStateCallback.class); 1088 verify(mMockedImsMmTelManager).registerImsStateCallback(any(Executor.class), 1089 imsCallbackCaptor.capture()); 1090 mMmtelStateCallback = imsCallbackCaptor.getValue(); 1091 1092 verify(mMockedImsRcsManager).registerImsStateCallback(any(Executor.class), 1093 imsCallbackCaptor.capture()); 1094 mRcsStateCallback = imsCallbackCaptor.getValue(); 1095 1096 carrierConfigChanged(); 1097 1098 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1099 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1100 1101 // IMS registration 1102 doReturn(FAKE_MMTEL_PACKAGE).when(mMockedImsResolver).getConfiguredImsServicePackageName( 1103 anyInt(), eq(ImsFeature.FEATURE_MMTEL)); 1104 doReturn(FAKE_RCS_PACKAGE).when(mMockedImsResolver).getConfiguredImsServicePackageName( 1105 anyInt(), eq(ImsFeature.FEATURE_RCS)); 1106 1107 mMmtelStateCallback.onAvailable(); 1108 mRcsStateCallback.onAvailable(); 1109 1110 ArgumentCaptor<RegistrationCallback> regCallbackCaptor = 1111 ArgumentCaptor.forClass(RegistrationCallback.class); 1112 1113 verify(mMockedImsMmTelManager).registerImsRegistrationCallback(any(Executor.class), 1114 regCallbackCaptor.capture()); 1115 mMmtelRegCallback = regCallbackCaptor.getValue(); 1116 1117 verify(mMockedImsRcsManager).registerImsRegistrationCallback(any(Executor.class), 1118 regCallbackCaptor.capture()); 1119 mRcsRegCallback = regCallbackCaptor.getValue(); 1120 1121 processAllMessages(); 1122 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1123 1124 doReturn(CarrierConfigManager.SATELLITE_DATA_SUPPORT_ONLY_RESTRICTED) 1125 .when(mSatelliteController) 1126 .getSatelliteDataServicePolicyForPlmn(anyInt(), any()); 1127 mCarrierSupportedServices.add(NetworkRegistrationInfo.SERVICE_TYPE_DATA); 1128 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1129 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1130 logd("DataNetworkControllerTest -Setup!"); 1131 } 1132 1133 @After tearDown()1134 public void tearDown() throws Exception { 1135 logd("tearDown"); 1136 mMockedDataServiceManagers.clear(); 1137 mDataCallListChangedRegistrants.clear(); 1138 mDataNetworkControllerUT = null; 1139 mCarrierConfig = null; 1140 super.tearDown(); 1141 } 1142 createNetworkRequest(Integer... capabilities)1143 private @NonNull TelephonyNetworkRequest createNetworkRequest(Integer... capabilities) { 1144 return createNetworkRequest(null, capabilities); 1145 } 1146 createNetworkRequest(@ullable Boolean restricted, Integer... capabilities)1147 private @NonNull TelephonyNetworkRequest createNetworkRequest(@Nullable Boolean restricted, 1148 Integer... capabilities) { 1149 NetworkCapabilities netCaps = new NetworkCapabilities(); 1150 for (int networkCapability : capabilities) { 1151 netCaps.addCapability(networkCapability); 1152 } 1153 1154 if (restricted != null) { 1155 if (restricted) { 1156 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 1157 } 1158 } else { 1159 // Data Network uses the same to define its own capabilities. 1160 netCaps.maybeMarkCapabilitiesRestricted(); 1161 } 1162 1163 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 1164 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 1165 1166 return new TelephonyNetworkRequest(nativeNetworkRequest, mPhone, mFeatureFlags); 1167 } 1168 1169 // The purpose of this test is to make sure the network request insertion/removal works as 1170 // expected, and make sure it is always sorted. 1171 @Test testNetworkRequestList()1172 public void testNetworkRequestList() { 1173 NetworkRequestList networkRequestList = new NetworkRequestList(); 1174 1175 TelephonyNetworkRequest internetNetworkRequest = createNetworkRequest( 1176 NetworkCapabilities.NET_CAPABILITY_INTERNET); 1177 TelephonyNetworkRequest eimsNetworkRequest = createNetworkRequest( 1178 NetworkCapabilities.NET_CAPABILITY_EIMS); 1179 TelephonyNetworkRequest mmsNetworkRequest = createNetworkRequest( 1180 NetworkCapabilities.NET_CAPABILITY_MMS); 1181 networkRequestList.add(internetNetworkRequest); 1182 networkRequestList.add(eimsNetworkRequest); 1183 networkRequestList.add(mmsNetworkRequest); 1184 1185 // Check if emergency has the highest priority, then mms, then internet. 1186 assertThat(networkRequestList.get(0).getCapabilities()[0]) 1187 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_EIMS); 1188 assertThat(networkRequestList.get(1).getCapabilities()[0]) 1189 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_MMS); 1190 assertThat(networkRequestList.get(2).getCapabilities()[0]) 1191 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1192 1193 // Add IMS 1194 TelephonyNetworkRequest imsNetworkRequest = createNetworkRequest( 1195 NetworkCapabilities.NET_CAPABILITY_IMS); 1196 assertThat(networkRequestList.add(imsNetworkRequest)).isTrue(); 1197 1198 assertThat(networkRequestList.get(0).getCapabilities()[0]) 1199 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_EIMS); 1200 assertThat(networkRequestList.get(1).getCapabilities()[0]) 1201 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_MMS); 1202 assertThat(networkRequestList.get(2).getCapabilities()[0]) 1203 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 1204 assertThat(networkRequestList.get(3).getCapabilities()[0]) 1205 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1206 1207 // Add IMS again 1208 assertThat(networkRequestList.add(imsNetworkRequest)).isFalse(); 1209 assertThat(networkRequestList.size()).isEqualTo(4); 1210 1211 // Remove MMS 1212 assertThat(networkRequestList.remove(mmsNetworkRequest)).isTrue(); 1213 assertThat(networkRequestList.get(0).getCapabilities()[0]) 1214 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_EIMS); 1215 assertThat(networkRequestList.get(1).getCapabilities()[0]) 1216 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 1217 assertThat(networkRequestList.get(2).getCapabilities()[0]) 1218 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1219 1220 // Remove EIMS 1221 assertThat(networkRequestList.remove(eimsNetworkRequest)).isTrue(); 1222 assertThat(networkRequestList.get(0).getCapabilities()[0]) 1223 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 1224 assertThat(networkRequestList.get(1).getCapabilities()[0]) 1225 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1226 1227 // Remove Internet 1228 assertThat(networkRequestList.remove(internetNetworkRequest)).isTrue(); 1229 assertThat(networkRequestList.get(0).getCapabilities()[0]) 1230 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 1231 1232 // Remove XCAP (which does not exist) 1233 assertThat(networkRequestList.remove( 1234 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_XCAP))).isFalse(); 1235 assertThat(networkRequestList.get(0).getCapabilities()[0]) 1236 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 1237 1238 // Remove IMS 1239 assertThat(networkRequestList.remove(imsNetworkRequest)).isTrue(); 1240 assertThat(networkRequestList).isEmpty(); 1241 } 1242 getDataNetworks()1243 private @NonNull List<DataNetwork> getDataNetworks() throws Exception { 1244 Field field = DataNetworkController.class.getDeclaredField("mDataNetworkList"); 1245 field.setAccessible(true); 1246 return (List<DataNetwork>) field.get(mDataNetworkControllerUT); 1247 } 1248 verifyInternetConnected()1249 private void verifyInternetConnected() throws Exception { 1250 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged(any()); 1251 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1252 } 1253 verifyConnectedNetworkHasCapabilities(@etCapability int... networkCapabilities)1254 private void verifyConnectedNetworkHasCapabilities(@NetCapability int... networkCapabilities) 1255 throws Exception { 1256 List<DataNetwork> dataNetworkList = getDataNetworks(); 1257 for (DataNetwork dataNetwork : getDataNetworks()) { 1258 if (dataNetwork.isConnected() && Arrays.stream(networkCapabilities).boxed() 1259 .allMatch(dataNetwork.getNetworkCapabilities()::hasCapability)) { 1260 return; 1261 } 1262 } 1263 fail("No network with " + DataUtils.networkCapabilitiesToString(networkCapabilities) 1264 + " is connected. dataNetworkList=" + dataNetworkList); 1265 } 1266 verifyNoConnectedNetworkHasCapability(@etCapability int networkCapability)1267 private void verifyNoConnectedNetworkHasCapability(@NetCapability int networkCapability) 1268 throws Exception { 1269 for (DataNetwork dataNetwork : getDataNetworks()) { 1270 assertWithMessage("Network " + dataNetwork + " should not be connected.") 1271 .that(dataNetwork.isConnected() && dataNetwork.getNetworkCapabilities() 1272 .hasCapability(networkCapability)).isFalse(); 1273 } 1274 } 1275 verifyConnectedNetworkHasDataProfile(@onNull DataProfile dataProfile)1276 private void verifyConnectedNetworkHasDataProfile(@NonNull DataProfile dataProfile) 1277 throws Exception { 1278 List<DataNetwork> dataNetworkList = getDataNetworks(); 1279 for (DataNetwork dataNetwork : getDataNetworks()) { 1280 if (dataNetwork.isConnected() && dataNetwork.getDataProfile().equals(dataProfile)) { 1281 return; 1282 } 1283 } 1284 fail("No network with " + dataProfile + " is connected. dataNetworkList=" 1285 + dataNetworkList); 1286 } 1287 verifyConnectedNetworkHasNoDataProfile(@onNull DataProfile dataProfile)1288 private void verifyConnectedNetworkHasNoDataProfile(@NonNull DataProfile dataProfile) 1289 throws Exception { 1290 List<DataNetwork> dataNetworkList = getDataNetworks(); 1291 for (DataNetwork dataNetwork : getDataNetworks()) { 1292 if (dataNetwork.isConnected() && dataNetwork.getDataProfile().equals(dataProfile)) { 1293 fail("network with " + dataProfile + " is connected. dataNetworkList=" 1294 + dataNetworkList); 1295 } 1296 } 1297 return; 1298 } 1299 verifyAllDataDisconnected()1300 private void verifyAllDataDisconnected() throws Exception { 1301 List<DataNetwork> dataNetworkList = getDataNetworks(); 1302 assertWithMessage("All data should be disconnected but it's not. " + dataNetworkList) 1303 .that(dataNetworkList).isEmpty(); 1304 } 1305 1306 // To test the basic data setup. Copy this as example for other tests. 1307 @Test testSetupDataNetwork()1308 public void testSetupDataNetwork() throws Exception { 1309 mDataNetworkControllerUT.addNetworkRequest( 1310 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1311 processAllMessages(); 1312 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1313 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 1314 1315 List<DataNetwork> dataNetworkList = getDataNetworks(); 1316 assertThat(dataNetworkList).hasSize(1); 1317 DataNetwork dataNetwork = dataNetworkList.get(0); 1318 assertThat(dataNetworkList.get(0).getLinkProperties().getAddresses()).containsExactly( 1319 InetAddresses.parseNumericAddress(IPV4_ADDRESS), 1320 InetAddresses.parseNumericAddress(IPV6_ADDRESS)); 1321 1322 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged(any()); 1323 } 1324 1325 @Test testSetupDataNetworkWithSimilarDataProfile()1326 public void testSetupDataNetworkWithSimilarDataProfile() throws Exception { 1327 mDataNetworkControllerUT.addNetworkRequest( 1328 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1329 processAllMessages(); 1330 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1331 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 1332 1333 List<DataNetwork> dataNetworkList = getDataNetworks(); 1334 assertThat(dataNetworkList).hasSize(1); 1335 DataNetwork dataNetwork = dataNetworkList.get(0); 1336 assertThat(dataNetworkList.get(0).getLinkProperties().getAddresses()).containsExactly( 1337 InetAddresses.parseNumericAddress(IPV4_ADDRESS), 1338 InetAddresses.parseNumericAddress(IPV6_ADDRESS)); 1339 1340 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged(any()); 1341 1342 // database updated/reloaded, causing data profile id change 1343 List<DataProfile> profiles = List.of(mDuplicatedGeneralPurposeDataProfile); 1344 doAnswer(invocation -> { 1345 DataProfile dp = (DataProfile) invocation.getArguments()[0]; 1346 1347 if (dp.getApnSetting() == null) return true; 1348 1349 for (DataProfile dataProfile : profiles) { 1350 if (dataProfile.getApnSetting() != null 1351 && dataProfile.getApnSetting().equals(dp.getApnSetting(), false)) { 1352 return true; 1353 } 1354 } 1355 return null; 1356 }).when(mDataProfileManager).isDataProfileCompatible(any(DataProfile.class)); 1357 doAnswer(invocation -> { 1358 TelephonyNetworkRequest networkRequest = 1359 (TelephonyNetworkRequest) invocation.getArguments()[0]; 1360 int networkType = (int) invocation.getArguments()[1]; 1361 1362 for (DataProfile dataProfile : profiles) { 1363 if (dataProfile.canSatisfy(networkRequest.getCapabilities()) 1364 && (dataProfile.getApnSetting().getNetworkTypeBitmask() == 0 1365 || (dataProfile.getApnSetting().getNetworkTypeBitmask() 1366 & ServiceState.getBitmaskForTech(networkType)) != 0)) { 1367 return dataProfile; 1368 } 1369 } 1370 logd("Cannot find data profile to satisfy " + networkRequest + ", network type=" 1371 + TelephonyManager.getNetworkTypeName(networkType)); 1372 return null; 1373 }).when(mDataProfileManager).getDataProfileForNetworkRequest( 1374 any(TelephonyNetworkRequest.class), anyInt(), anyBoolean(), anyBoolean(), 1375 anyBoolean()); 1376 1377 // verify the network still connects 1378 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged(any()); 1379 1380 // A NOT_VCN_MANAGED request cannot be satisfied by the existing network, but will adopt the 1381 // same data profile 1382 mDataNetworkControllerUT.addNetworkRequest( 1383 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET, 1384 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)); 1385 1386 processAllMessages(); 1387 1388 // verify the network still connects 1389 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged(any()); 1390 // verify we don't try to setup a separate network for the not_vcn_managed request 1391 dataNetworkList = getDataNetworks(); 1392 assertThat(dataNetworkList).hasSize(1); 1393 } 1394 1395 @Test testSetupImsDataNetwork()1396 public void testSetupImsDataNetwork() throws Exception { 1397 mDataNetworkControllerUT.addNetworkRequest( 1398 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 1399 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 1400 processAllMessages(); 1401 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 1402 NetworkCapabilities.NET_CAPABILITY_MMTEL); 1403 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 1404 List<DataNetwork> dataNetworkList = getDataNetworks(); 1405 assertThat(dataNetworkList.get(0).getLinkProperties().getAddresses()).containsExactly( 1406 InetAddresses.parseNumericAddress(IPV4_ADDRESS), 1407 InetAddresses.parseNumericAddress(IPV6_ADDRESS)); 1408 } 1409 1410 @Test testSetupEnterpriseDataNetwork()1411 public void testSetupEnterpriseDataNetwork() throws Exception { 1412 List<TrafficDescriptor> tdList = new ArrayList<>(); 1413 tdList.add(new TrafficDescriptor.Builder() 1414 .setOsAppId(new OsAppId(OsAppId.ANDROID_OS_ID, "ENTERPRISE", 1).getBytes()) 1415 .build()); 1416 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 1417 createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE, tdList)); 1418 doReturn(mEnterpriseDataProfile).when(mDataProfileManager) 1419 .getDataProfileForNetworkRequest(any(TelephonyNetworkRequest.class), anyInt(), 1420 anyBoolean(), anyBoolean(), anyBoolean()); 1421 1422 NetworkCapabilities netCaps = new NetworkCapabilities(); 1423 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE); 1424 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 1425 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 1426 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 1427 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 1428 processAllMessages(); 1429 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE); 1430 List<DataNetwork> dataNetworkList = getDataNetworks(); 1431 assertThat(dataNetworkList.get(0).getLinkProperties().getAddresses()).containsExactly( 1432 InetAddresses.parseNumericAddress(IPV4_ADDRESS), 1433 InetAddresses.parseNumericAddress(IPV6_ADDRESS)); 1434 } 1435 1436 @Test testDataNetworkControllerCallback()1437 public void testDataNetworkControllerCallback() throws Exception { 1438 Field field = DataNetworkController.class.getDeclaredField( 1439 "mDataNetworkControllerCallbacks"); 1440 field.setAccessible(true); 1441 Set<DataNetworkControllerCallback> dataNetworkControllerCallbacks = 1442 (Set<DataNetworkControllerCallback>) field.get(mDataNetworkControllerUT); 1443 1444 // Verify register callback 1445 mDataNetworkControllerUT.registerDataNetworkControllerCallback( 1446 mMockedDataNetworkControllerCallback); 1447 TelephonyNetworkRequest request = createNetworkRequest( 1448 NetworkCapabilities.NET_CAPABILITY_INTERNET); 1449 mDataNetworkControllerUT.addNetworkRequest(request); 1450 processAllMessages(); 1451 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(true)); 1452 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged(any()); 1453 1454 int countOfCallbacks = dataNetworkControllerCallbacks.size(); 1455 1456 // Verify unregister callback 1457 mDataNetworkControllerUT.removeNetworkRequest(request); 1458 processAllMessages(); 1459 getDataNetworks().get(0).tearDown(DataNetwork 1460 .TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 1461 processAllFutureMessages(); 1462 1463 assertEquals(countOfCallbacks - 1, dataNetworkControllerCallbacks.size()); 1464 } 1465 1466 @Test testSimRemovalDataTearDown()1467 public void testSimRemovalDataTearDown() throws Exception { 1468 testSetupDataNetwork(); 1469 1470 mDataNetworkControllerUT.obtainMessage(EVENT_SIM_STATE_CHANGED, 1471 TelephonyManager.SIM_STATE_ABSENT, 0).sendToTarget(); 1472 processAllMessages(); 1473 verifyAllDataDisconnected(); 1474 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 1475 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged( 1476 eq(Collections.emptySet())); 1477 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 1478 eq(DataCallResponse.LINK_STATUS_INACTIVE)); 1479 } 1480 1481 @Test testSimRemovalAndThenInserted()1482 public void testSimRemovalAndThenInserted() throws Exception { 1483 testSimRemovalDataTearDown(); 1484 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1485 1486 // Insert the SIM again. 1487 mDataNetworkControllerUT.obtainMessage(EVENT_SIM_STATE_CHANGED, 1488 TelephonyManager.SIM_STATE_LOADED, 0).sendToTarget(); 1489 processAllMessages(); 1490 1491 verifyInternetConnected(); 1492 } 1493 1494 @Test testDuplicateInterface()1495 public void testDuplicateInterface() throws Exception { 1496 mDataNetworkControllerUT.addNetworkRequest( 1497 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1498 processAllMessages(); 1499 1500 // The fota network request would result in duplicate interface. 1501 mDataNetworkControllerUT.addNetworkRequest( 1502 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_FOTA)); 1503 processAllFutureMessages(); 1504 1505 // There should be only one network. 1506 List<DataNetwork> dataNetworkList = getDataNetworks(); 1507 assertThat(dataNetworkList).hasSize(1); 1508 assertThat(dataNetworkList.get(0).getDataProfile()).isEqualTo(mGeneralPurposeDataProfile); 1509 verifyInternetConnected(); 1510 // Fota should not be connected. 1511 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA); 1512 1513 // There should be exactly 2 setup data call requests. 1514 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 1515 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 1516 any(), any(), anyBoolean(), any(Message.class)); 1517 } 1518 1519 @Test testMovingFromNoServiceToInService()1520 public void testMovingFromNoServiceToInService() throws Exception { 1521 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1522 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 1523 1524 mDataNetworkControllerUT.addNetworkRequest( 1525 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1526 processAllMessages(); 1527 1528 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1529 1530 // Network becomes in-service. 1531 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1532 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1533 1534 verifyInternetConnected(); 1535 } 1536 1537 @Test testMovingFromInServiceToNoService()1538 public void testMovingFromInServiceToNoService() throws Exception { 1539 testSetupDataNetwork(); 1540 1541 // clear available services at no service 1542 mCarrierSupportedServices.clear(); 1543 1544 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 1545 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 1546 // Verify we don't tear down the data network. 1547 verifyInternetConnected(); 1548 } 1549 1550 @Test testInServiceAvailableServicesChanged()1551 public void testInServiceAvailableServicesChanged() throws Exception { 1552 testSetupDataNetwork(); 1553 1554 List<DataDisallowedReason> reasons = mDataNetworkControllerUT 1555 .getInternetDataDisallowedReasons(); 1556 assertThat(reasons).isEmpty(); 1557 1558 // Add available services sms to existing available services with data 1559 mCarrierSupportedServices.add(NetworkRegistrationInfo.SERVICE_TYPE_SMS); 1560 1561 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1562 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1563 1564 // Verify we don't tear down the data network. 1565 verifyInternetConnected(); 1566 1567 1568 mCarrierSupportedServices.clear(); 1569 // Add available services data and mms 1570 mCarrierSupportedServices.add(NetworkRegistrationInfo.SERVICE_TYPE_DATA); 1571 mCarrierSupportedServices.add(NetworkRegistrationInfo.SERVICE_TYPE_MMS); 1572 1573 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1574 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1575 1576 // Verify we don't tear down the data network. 1577 verifyInternetConnected(); 1578 1579 // clear all available services 1580 mCarrierSupportedServices.clear(); 1581 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1582 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1583 1584 // Verify internet is not connected 1585 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1586 1587 reasons = mDataNetworkControllerUT.getInternetDataDisallowedReasons(); 1588 assertThat(reasons).contains(DataDisallowedReason.SERVICE_OPTION_NOT_SUPPORTED); 1589 1590 } 1591 1592 @Test testHomeToRoamingAvailableServicesChangedWithDataRoamingDisabled()1593 public void testHomeToRoamingAvailableServicesChangedWithDataRoamingDisabled() 1594 throws Exception { 1595 testSetupDataNetwork(); 1596 1597 List<DataDisallowedReason> reasons = mDataNetworkControllerUT 1598 .getInternetDataDisallowedReasons(); 1599 assertThat(reasons).isEmpty(); 1600 1601 // Disable data roaming setting 1602 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 1603 1604 // Home to roaming with same available services 1605 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1606 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 1607 1608 // Verify internet is not connected due to roaming disabled 1609 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1610 1611 reasons = mDataNetworkControllerUT.getInternetDataDisallowedReasons(); 1612 assertThat(reasons).contains(DataDisallowedReason.ROAMING_DISABLED); 1613 } 1614 1615 @Test testHomeToRoamingAvailableServicesChangedWithDataRoamingEnabled()1616 public void testHomeToRoamingAvailableServicesChangedWithDataRoamingEnabled() 1617 throws Exception { 1618 testSetupDataNetwork(); 1619 1620 List<DataDisallowedReason> reasons = mDataNetworkControllerUT 1621 .getInternetDataDisallowedReasons(); 1622 assertThat(reasons).isEmpty(); 1623 1624 // Enable data roaming setting 1625 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(true); 1626 1627 // Home to roaming with same available services 1628 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1629 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 1630 1631 // Verify we don't tear down the data network since available services as still data 1632 // with data roaming enabled 1633 verifyInternetConnected(); 1634 1635 // clear all available services 1636 mCarrierSupportedServices.clear(); 1637 // At roaming 1638 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1639 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 1640 1641 // Verify internet is not connected 1642 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1643 1644 reasons = mDataNetworkControllerUT.getInternetDataDisallowedReasons(); 1645 assertThat(reasons).contains(DataDisallowedReason.SERVICE_OPTION_NOT_SUPPORTED); 1646 } 1647 1648 @Test testOnAvailableServiceChanged_WithReevaluateNetworkRequest()1649 public void testOnAvailableServiceChanged_WithReevaluateNetworkRequest() 1650 throws Exception { 1651 // clear available services at no service 1652 mCarrierSupportedServices.clear(); 1653 1654 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1655 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1656 1657 // Set network request transport with Internet capability 1658 mDataNetworkControllerUT.addNetworkRequest( 1659 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1660 processAllMessages(); 1661 1662 // Verify internet is not connected due to roaming disabled 1663 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1664 1665 List<DataDisallowedReason> reasons = mDataNetworkControllerUT 1666 .getInternetDataDisallowedReasons(); 1667 assertThat(reasons).contains(DataDisallowedReason.SERVICE_OPTION_NOT_SUPPORTED); 1668 1669 // add available services with data, re-evaluate network request 1670 mCarrierSupportedServices.add(NetworkRegistrationInfo.SERVICE_TYPE_DATA); 1671 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1672 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1673 1674 // Verify now internet was connected 1675 verifyInternetConnected(); 1676 1677 reasons = mDataNetworkControllerUT.getInternetDataDisallowedReasons(); 1678 assertThat(reasons).isEmpty(); 1679 } 1680 1681 @Test testPsRestrictedAndLifted()1682 public void testPsRestrictedAndLifted() throws Exception { 1683 testSetupDataNetwork(); 1684 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1685 1686 // PS restricted, existing PDN should stay. 1687 mDataNetworkControllerUT.obtainMessage(6/*EVENT_PS_RESTRICT_ENABLED*/).sendToTarget(); 1688 processAllMessages(); 1689 1690 List<DataNetwork> dataNetworkList = getDataNetworks(); 1691 assertThat(dataNetworkList).hasSize(1); 1692 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1693 1694 // PS restricted, new setup NOT allowed 1695 mDataNetworkControllerUT.addNetworkRequest( 1696 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 1697 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 1698 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 1699 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 1700 processAllMessages(); 1701 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 1702 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1703 1704 // PS unrestricted, new setup is allowed 1705 mDataNetworkControllerUT.obtainMessage(7/*EVENT_PS_RESTRICT_DISABLED*/).sendToTarget(); 1706 processAllMessages(); 1707 1708 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 1709 NetworkCapabilities.NET_CAPABILITY_MMTEL); 1710 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1711 } 1712 1713 @Test testPsRestrictedAllowIwlan()1714 public void testPsRestrictedAllowIwlan() throws Exception { 1715 // IMS preferred on IWLAN. 1716 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 1717 .getPreferredTransportByNetworkCapability( 1718 eq(NetworkCapabilities.NET_CAPABILITY_IMS)); 1719 1720 // PS restricted 1721 mDataNetworkControllerUT.obtainMessage(6/*EVENT_PS_RESTRICT_ENABLED*/).sendToTarget(); 1722 processAllMessages(); 1723 1724 // PS restricted, new setup NOT allowed 1725 mDataNetworkControllerUT.addNetworkRequest( 1726 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1727 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 1728 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 1729 processAllMessages(); 1730 verifyAllDataDisconnected(); 1731 1732 // Request IMS 1733 mDataNetworkControllerUT.addNetworkRequest( 1734 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 1735 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 1736 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 1737 .get(AccessNetworkConstants.TRANSPORT_TYPE_WLAN), 3); 1738 processAllMessages(); 1739 1740 // Make sure IMS on IWLAN. 1741 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS); 1742 assertThat(getDataNetworks()).hasSize(1); 1743 DataNetwork dataNetwork = getDataNetworks().get(0); 1744 assertThat(dataNetwork.getTransport()).isEqualTo( 1745 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 1746 } 1747 1748 @Test testRatChanges()1749 public void testRatChanges() throws Exception { 1750 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1751 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1752 1753 testSetupDataNetwork(); 1754 1755 // Now RAT changes from LTE to UMTS, make sure the network is lingered. 1756 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UMTS, 1757 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1758 verifyInternetConnected(); 1759 1760 // Now RAT changes from UMTS to GSM 1761 doReturn(null).when(mDataProfileManager).getDataProfileForNetworkRequest( 1762 any(TelephonyNetworkRequest.class), eq(TelephonyManager.NETWORK_TYPE_GSM), 1763 anyBoolean(), anyBoolean(), anyBoolean()); 1764 serviceStateChanged(TelephonyManager.NETWORK_TYPE_GSM, 1765 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1766 verifyAllDataDisconnected(); 1767 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 1768 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged( 1769 eq(Collections.emptySet())); 1770 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 1771 eq(DataCallResponse.LINK_STATUS_INACTIVE)); 1772 1773 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1774 // Now RAT changes from GSM to UMTS 1775 doReturn(null).when(mDataProfileManager).getDataProfileForNetworkRequest( 1776 any(TelephonyNetworkRequest.class), eq(TelephonyManager.NETWORK_TYPE_UMTS), 1777 anyBoolean(), anyBoolean(), anyBoolean()); 1778 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UMTS, 1779 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1780 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1781 1782 doReturn(mGeneralPurposeDataProfile).when(mDataProfileManager) 1783 .getDataProfileForNetworkRequest(any(TelephonyNetworkRequest.class), anyInt(), 1784 anyBoolean(), anyBoolean(), anyBoolean()); 1785 // Now RAT changes from UMTS to LTE 1786 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1787 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1788 verifyInternetConnected(); 1789 } 1790 1791 @Test testRatChangesLingeringNotSet()1792 public void testRatChangesLingeringNotSet() throws Exception { 1793 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1794 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1795 TelephonyNetworkRequest fotaRequest = createNetworkRequest( 1796 NetworkCapabilities.NET_CAPABILITY_FOTA); 1797 mDataNetworkControllerUT.addNetworkRequest(fotaRequest); 1798 processAllMessages(); 1799 1800 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_FOTA); 1801 1802 // Now RAT changes from LTE to UMTS, since FOTA APN does not have lingering set, only 1803 // network type bitmask should be used. Fota network should be torn down. 1804 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UMTS, 1805 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1806 processAllMessages(); 1807 1808 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA); 1809 verifyAllDataDisconnected(); 1810 } 1811 1812 @Test testVoiceCallEndedOnVoiceDataNonConcurrentNetwork()1813 public void testVoiceCallEndedOnVoiceDataNonConcurrentNetwork() throws Exception { 1814 doReturn(false).when(mSST).isConcurrentVoiceAndDataAllowed(); 1815 doReturn(PhoneConstants.State.OFFHOOK).when(mCT).getState(); 1816 1817 mDataNetworkControllerUT.addNetworkRequest( 1818 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1819 processAllMessages(); 1820 1821 // Data should not be allowed when voice/data concurrent is not supported. 1822 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1823 1824 // Call ended. 1825 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 1826 mDataNetworkControllerUT.obtainMessage(EVENT_VOICE_CALL_ENDED).sendToTarget(); 1827 processAllMessages(); 1828 1829 // It should have no internet setup at the beginning. 1830 verifyAllDataDisconnected(); 1831 1832 // But after some delays data should be restored. 1833 moveTimeForward(500); 1834 processAllMessages(); 1835 verifyInternetConnected(); 1836 } 1837 1838 @Test testEcbmChanged()1839 public void testEcbmChanged() throws Exception { 1840 doReturn(true).when(mPhone).isInCdmaEcm(); 1841 mDataNetworkControllerUT.addNetworkRequest( 1842 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1843 processAllMessages(); 1844 1845 // Data should not be allowed when the device is in ECBM. 1846 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1847 1848 // Exit ECBM 1849 doReturn(false).when(mPhone).isInCdmaEcm(); 1850 mDataNetworkControllerUT.obtainMessage(20/*EVENT_EMERGENCY_CALL_CHANGED*/).sendToTarget(); 1851 processAllMessages(); 1852 1853 // Verify data is restored. 1854 verifyInternetConnected(); 1855 } 1856 1857 @Test testIsNetworkRequestSatisfiedByTransportCellularTransportRequest()1858 public void testIsNetworkRequestSatisfiedByTransportCellularTransportRequest() { 1859 mIsNonTerrestrialNetwork = true; 1860 1861 // Data is not supported for cellular transport network request while using satellite 1862 // network 1863 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1864 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1865 1866 // Set network request transport as Cellular in satellite network 1867 NetworkCapabilities netCaps = new NetworkCapabilities(); 1868 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR); 1869 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1870 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 1871 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 1872 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 1873 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 1874 processAllMessages(); 1875 1876 // Verify data is not connected since Network request cannot satisfy by transport 1877 verify(mMockedDataNetworkControllerCallback, never()) 1878 .onConnectedInternetDataNetworksChanged(any()); 1879 1880 // However, WLAN network setup shouldn't be affected 1881 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 1882 .getPreferredTransportByNetworkCapability(anyInt()); 1883 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 1884 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 1885 processAllMessages(); 1886 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged(any()); 1887 1888 mIsNonTerrestrialNetwork = false; 1889 } 1890 1891 @Test testMobileDataDisabledIsValidRestrictedRequestWithSatelliteInternetRequest()1892 public void testMobileDataDisabledIsValidRestrictedRequestWithSatelliteInternetRequest() { 1893 mIsNonTerrestrialNetwork = true; 1894 1895 //Mobile Data Disabled 1896 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1897 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 1898 processAllMessages(); 1899 1900 // Data is not supported for cellular transport network request while using satellite 1901 // network 1902 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1903 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1904 1905 // Set network request transport as Satellite with restricted capability + internet 1906 NetworkCapabilities netCaps = new NetworkCapabilities(); 1907 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE); 1908 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1909 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 1910 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 1911 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 1912 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 1913 processAllMessages(); 1914 1915 // Verify data is not connected since Network request cannot satisfy by transport 1916 verify(mMockedDataNetworkControllerCallback, never()) 1917 .onConnectedInternetDataNetworksChanged(any()); 1918 1919 mIsNonTerrestrialNetwork = false; 1920 } 1921 1922 @Test testMobileDataDisabledIsValidRestrictedRequestWithTransportSatelliteMMSRequest()1923 public void testMobileDataDisabledIsValidRestrictedRequestWithTransportSatelliteMMSRequest() 1924 throws Exception { 1925 mIsNonTerrestrialNetwork = true; 1926 1927 // Data disabled 1928 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1929 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 1930 // Always allow MMS off 1931 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 1932 .MOBILE_DATA_POLICY_MMS_ALWAYS_ALLOWED, false); 1933 processAllMessages(); 1934 1935 // Data is not supported for cellular transport network request while using satellite 1936 // network 1937 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1938 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1939 1940 // Set network request transport as Cellular+Satellite with restricted capability + mms 1941 NetworkCapabilities netCaps = new NetworkCapabilities(); 1942 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE); 1943 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR); 1944 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 1945 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 1946 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 1947 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 1948 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 1949 processAllMessages(); 1950 1951 // Verify mms is not connected 1952 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 1953 1954 mIsNonTerrestrialNetwork = false; 1955 } 1956 1957 @Test testOnMmsAlwaysALlowedIsValidRestrictedRequestWithTransportSatelliteMMSRequest()1958 public void testOnMmsAlwaysALlowedIsValidRestrictedRequestWithTransportSatelliteMMSRequest() 1959 throws Exception { 1960 mIsNonTerrestrialNetwork = true; 1961 1962 // Data disabled 1963 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1964 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 1965 // Always allow MMS On 1966 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 1967 .MOBILE_DATA_POLICY_MMS_ALWAYS_ALLOWED, true); 1968 processAllMessages(); 1969 1970 // Data is not supported for cellular transport network request while using satellite 1971 // network 1972 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1973 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1974 1975 // Set network request transport as Cellular+Satellite with restricted capability + mms 1976 NetworkCapabilities netCaps = new NetworkCapabilities(); 1977 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE); 1978 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR); 1979 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 1980 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 1981 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 1982 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 1983 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 1984 processAllMessages(); 1985 1986 // Verify mms is connected if mms always allowed is on 1987 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 1988 1989 mIsNonTerrestrialNetwork = false; 1990 } 1991 1992 @Test testIsNetworkRequestSatisfiedByTransportSatelliteTransportRequest_Terrestrial()1993 public void testIsNetworkRequestSatisfiedByTransportSatelliteTransportRequest_Terrestrial() { 1994 // Set network request transport as satellite in satellite network 1995 NetworkCapabilities netCaps = new NetworkCapabilities(); 1996 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE); 1997 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1998 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 1999 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 2000 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 2001 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 2002 processAllMessages(); 2003 2004 // Verify data is not supported for satellite transport network request while using cellular 2005 verify(mMockedDataNetworkControllerCallback, never()) 2006 .onConnectedInternetDataNetworksChanged(any()); 2007 2008 } 2009 2010 @Test testIsNetworkRequestSatisfiedByTransportSatelliteTransportRequest()2011 public void testIsNetworkRequestSatisfiedByTransportSatelliteTransportRequest() { 2012 mIsNonTerrestrialNetwork = true; 2013 2014 // Data is supported for satellite transport network request while using satellite network 2015 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2016 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2017 2018 // Set network request transport as satellite while using satellite network 2019 NetworkCapabilities netCaps = new NetworkCapabilities(); 2020 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE); 2021 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2022 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2023 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 2024 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 2025 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 2026 processAllMessages(); 2027 2028 // Verify data is connected since Network request satisfy by transport 2029 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged(any()); 2030 2031 mIsNonTerrestrialNetwork = false; 2032 } 2033 2034 @Test testIsNetworkRequestSatisfiedByTransportNoTransportRequest()2035 public void testIsNetworkRequestSatisfiedByTransportNoTransportRequest() { 2036 mIsNonTerrestrialNetwork = true; 2037 2038 // Data is supported for no transport network request while using satellite network 2039 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2040 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2041 2042 // Set network request transport as no transport with Internet capability 2043 NetworkCapabilities netCaps = new NetworkCapabilities(); 2044 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2045 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2046 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 2047 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 2048 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 2049 processAllMessages(); 2050 2051 // Verify data is connected since Network request satisfy by transport 2052 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged(any()); 2053 2054 mIsNonTerrestrialNetwork = false; 2055 } 2056 2057 @Test testIsNetworkCapabilitySatelliteAndCellularCapableImsCellularTransportRequest()2058 public void testIsNetworkCapabilitySatelliteAndCellularCapableImsCellularTransportRequest() 2059 throws Exception { 2060 mIsNonTerrestrialNetwork = true; 2061 2062 // IMS PDN is supported for cellular network request while using satellite network 2063 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2064 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2065 2066 // Set network request transport as Cellular + IMS 2067 NetworkCapabilities netCaps = new NetworkCapabilities(); 2068 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR); 2069 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 2070 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL); 2071 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2072 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 2073 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 2074 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 2075 processAllMessages(); 2076 2077 // Verify ims is connected since, cellular network request for ims is allowed while using 2078 // satellite network 2079 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2080 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2081 2082 mIsNonTerrestrialNetwork = false; 2083 } 2084 2085 @Test testRoamingDataChanged()2086 public void testRoamingDataChanged() throws Exception { 2087 doReturn(true).when(mServiceState).getDataRoaming(); 2088 2089 // Roaming data disabled 2090 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 2091 processAllMessages(); 2092 2093 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2094 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 2095 mDataNetworkControllerUT.addNetworkRequest( 2096 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2097 processAllMessages(); 2098 2099 // Data should not be allowed when roaming data is disabled. 2100 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2101 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2102 2103 // Roaming data enabled 2104 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(true); 2105 processAllMessages(); 2106 2107 // Verify data is restored. 2108 verifyInternetConnected(); 2109 2110 // Roaming data disabled 2111 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 2112 processAllMessages(); 2113 2114 // Verify data is torn down. 2115 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2116 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2117 2118 // Registration is back to HOME. 2119 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2120 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2121 processAllFutureMessages(); 2122 2123 // Verify data is restored. 2124 verifyInternetConnected(); 2125 } 2126 2127 @Test testIgnoreDataRoamingSettingForSatellite()2128 public void testIgnoreDataRoamingSettingForSatellite() throws Exception { 2129 // set up satellite network and register data roaming 2130 mIsNonTerrestrialNetwork = true; 2131 doReturn(true).when(mServiceState).getDataRoaming(); 2132 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2133 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 2134 2135 // Enable data roaming setting 2136 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(true); 2137 2138 // Set network request transport with Internet capability 2139 mDataNetworkControllerUT.addNetworkRequest( 2140 createNetworkRequest(true, 2141 NetworkCapabilities.NET_CAPABILITY_INTERNET, 2142 NetworkCapabilities.NET_CAPABILITY_NOT_BANDWIDTH_CONSTRAINED)); 2143 processAllMessages(); 2144 2145 // Verify internet is connected 2146 verifyInternetConnected(); 2147 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2148 2149 // Disable data roaming setting 2150 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 2151 processAllMessages(); 2152 2153 // Verify internet is not connected 2154 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2155 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2156 2157 // Setup carrier to bypass data roaming off setting for satellite network 2158 mCarrierConfig.putBoolean( 2159 CarrierConfigManager.KEY_SATELLITE_IGNORE_DATA_ROAMING_SETTING_BOOL, true); 2160 carrierConfigChanged(); 2161 processAllMessages(); 2162 2163 // Verify internet is connected 2164 verifyInternetConnected(); 2165 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2166 2167 // reset satellite network and roaming registration 2168 mIsNonTerrestrialNetwork = false; 2169 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2170 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2171 } 2172 2173 @Test testIgnoreDataRoamingSettingForSatelliteWithBandwithConstrained()2174 public void testIgnoreDataRoamingSettingForSatelliteWithBandwithConstrained() throws Exception { 2175 // set up satellite network and register data roaming 2176 mIsNonTerrestrialNetwork = true; 2177 doReturn(true).when(mServiceState).getDataRoaming(); 2178 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2179 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 2180 2181 // Enable data roaming setting 2182 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(true); 2183 2184 // Set network request transport with Internet capability 2185 mDataNetworkControllerUT.addNetworkRequest( 2186 createNetworkRequest(true, NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2187 processAllMessages(); 2188 2189 // Verify internet is connected 2190 verifyInternetConnected(); 2191 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2192 2193 // Disable data roaming setting 2194 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 2195 processAllMessages(); 2196 2197 // Verify internet is not connected 2198 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2199 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2200 2201 // Setup carrier to bypass data roaming off setting for satellite network 2202 mCarrierConfig.putBoolean( 2203 CarrierConfigManager.KEY_SATELLITE_IGNORE_DATA_ROAMING_SETTING_BOOL, true); 2204 carrierConfigChanged(); 2205 processAllMessages(); 2206 2207 // Verify internet is connected 2208 verifyInternetConnected(); 2209 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2210 2211 // reset satellite network and roaming registration 2212 mIsNonTerrestrialNetwork = false; 2213 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2214 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2215 } 2216 2217 @Test testIgnoreDataRoamingSettingForSatelliteForUnrestrictedNetwork()2218 public void testIgnoreDataRoamingSettingForSatelliteForUnrestrictedNetwork() throws Exception { 2219 // set up satellite network and register data roaming 2220 mIsNonTerrestrialNetwork = true; 2221 doReturn(true).when(mServiceState).getDataRoaming(); 2222 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2223 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 2224 2225 // Disable data roaming setting 2226 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 2227 2228 // Set network request transport with Internet capability 2229 mDataNetworkControllerUT.addNetworkRequest( 2230 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2231 processAllMessages(); 2232 2233 // Verify internet is not connected 2234 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2235 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2236 2237 // Setup carrier to bypass data roaming off setting for satellite network 2238 mCarrierConfig.putBoolean( 2239 CarrierConfigManager.KEY_SATELLITE_IGNORE_DATA_ROAMING_SETTING_BOOL, true); 2240 carrierConfigChanged(); 2241 processAllMessages(); 2242 2243 // Verify internet is still not connected 2244 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2245 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2246 2247 doReturn(CarrierConfigManager.SATELLITE_DATA_SUPPORT_ALL) 2248 .when(mSatelliteController) 2249 .getSatelliteDataServicePolicyForPlmn(anyInt(), any()); 2250 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 2251 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 2252 processAllMessages(); 2253 2254 // Verify internet is connected 2255 verifyInternetConnected(); 2256 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2257 2258 // reset satellite network and roaming registration 2259 mIsNonTerrestrialNetwork = false; 2260 mCarrierSupportedServices.clear(); 2261 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2262 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2263 } 2264 2265 @Test testIgnoreDataRoamingSettingForSatelliteConfigForTerrestialNetwork()2266 public void testIgnoreDataRoamingSettingForSatelliteConfigForTerrestialNetwork() throws Exception { 2267 // set up terrestrial network and roaming registration 2268 mIsNonTerrestrialNetwork = false; 2269 doReturn(true).when(mServiceState).getDataRoaming(); 2270 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2271 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 2272 2273 // Enable data roaming setting 2274 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(true); 2275 2276 // Set network request transport with Internet capability 2277 mDataNetworkControllerUT.addNetworkRequest( 2278 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2279 processAllMessages(); 2280 2281 // Verify internet is connected 2282 verifyInternetConnected(); 2283 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2284 2285 // Disable data roaming setting 2286 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 2287 processAllMessages(); 2288 2289 // Verify internet is not connected 2290 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2291 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2292 2293 // Setup carrier to bypass data roaming off setting for satellite network 2294 mCarrierConfig.putBoolean( 2295 CarrierConfigManager.KEY_SATELLITE_IGNORE_DATA_ROAMING_SETTING_BOOL, true); 2296 carrierConfigChanged(); 2297 processAllMessages(); 2298 2299 // Verify internet is still not connected 2300 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2301 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2302 2303 // Enable data roaming again 2304 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(true); 2305 processAllMessages(); 2306 2307 // Verify internet is connected again 2308 verifyInternetConnected(); 2309 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2310 2311 // reset roaming registration 2312 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2313 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2314 } 2315 2316 @Test testDataEnabledChanged()2317 public void testDataEnabledChanged() throws Exception { 2318 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2319 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2320 mDataNetworkControllerUT.addNetworkRequest( 2321 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2322 processAllMessages(); 2323 2324 // Data should not be allowed when user data is disabled. 2325 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2326 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2327 2328 // User data enabled 2329 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2330 TelephonyManager.DATA_ENABLED_REASON_USER, true, mContext.getOpPackageName()); 2331 processAllMessages(); 2332 2333 // Verify data is restored. 2334 verifyInternetConnected(); 2335 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2336 2337 // User data disabled 2338 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2339 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2340 processAllMessages(); 2341 2342 // Verify data is torn down. 2343 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2344 } 2345 2346 @Test testNotifyWhenSetDataEnabled()2347 public void testNotifyWhenSetDataEnabled() throws Exception { 2348 // Set a valid sub id, DEFAULT_SUBSCRIPTION_ID 2349 int subId = Integer.MAX_VALUE; 2350 Field field = DataSettingsManager.class.getDeclaredField("mSubId"); 2351 field.setAccessible(true); 2352 field.setInt(mDataNetworkControllerUT.getDataSettingsManager(), subId); 2353 boolean isDataEnabled = mDataNetworkControllerUT.getDataSettingsManager().isDataEnabled(); 2354 doReturn(mDataNetworkControllerUT.getDataSettingsManager()) 2355 .when(mPhone).getDataSettingsManager(); 2356 MultiSimSettingController controller = Mockito.spy(new MultiSimSettingController(mContext, 2357 mFeatureFlags)); 2358 doReturn(true).when(controller).isCarrierConfigLoadedForAllSub(); 2359 replaceInstance(MultiSimSettingController.class, "sInstance", null, controller); 2360 2361 // Mock Data Overall data is always enabled due to auto data switch, 2362 // verify the test shouldn't rely on the overall data status 2363 doReturn(1).when(mPhone).getSubId(); 2364 doReturn(2).when(mSubscriptionManagerService).getDefaultDataSubId(); 2365 Phone phone2 = Mockito.mock(Phone.class); 2366 phone2.mCi = mSimulatedCommands; 2367 doReturn(true).when(phone2).isUserDataEnabled(); 2368 doReturn(mDataSettingsManager).when(phone2).getDataSettingsManager(); 2369 replaceInstance(PhoneFactory.class, "sPhones", null, new Phone[]{mPhone, phone2}); 2370 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2371 .MOBILE_DATA_POLICY_AUTO_DATA_SWITCH, true); 2372 processAllMessages(); 2373 clearInvocations(mPhone); 2374 2375 controller.notifyAllSubscriptionLoaded(); 2376 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2377 TelephonyManager.DATA_ENABLED_REASON_USER, !isDataEnabled, 2378 mContext.getOpPackageName()); 2379 processAllMessages(); 2380 2381 // Verify not to notify MultiSimSettingController due to internal calling package 2382 verify(controller, never()).notifyUserDataEnabled(anyInt(), anyBoolean()); 2383 2384 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2385 TelephonyManager.DATA_ENABLED_REASON_USER, isDataEnabled, 2386 mContext.getOpPackageName()); 2387 processAllMessages(); 2388 2389 // Verify not to notify MultiSimSettingController due to internal calling package 2390 verify(controller, never()).notifyUserDataEnabled(anyInt(), anyBoolean()); 2391 2392 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2393 TelephonyManager.DATA_ENABLED_REASON_USER, !isDataEnabled, "com.android.settings"); 2394 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2395 TelephonyManager.DATA_ENABLED_REASON_USER, isDataEnabled, "com.android.settings"); 2396 processAllMessages(); 2397 2398 // Verify to notify MultiSimSettingController exactly 2 times 2399 verify(controller, times(2)).notifyUserDataEnabled(anyInt(), anyBoolean()); 2400 verify(mPhone, never()).notifyDataEnabled(anyBoolean(), anyInt()); 2401 } 2402 2403 @Test testMmsAlwaysAllowedDataDisabled()2404 public void testMmsAlwaysAllowedDataDisabled() throws Exception { 2405 // Data disabled 2406 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2407 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2408 // Always allow MMS 2409 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2410 .MOBILE_DATA_POLICY_MMS_ALWAYS_ALLOWED, true); 2411 processAllMessages(); 2412 mDataNetworkControllerUT.addNetworkRequest( 2413 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 2414 processAllMessages(); 2415 2416 // Make sure MMS is the only capability advertised, but not internet or SUPL. 2417 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 2418 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 2419 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2420 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL); 2421 2422 mDataNetworkControllerUT.obtainMessage(16 /*EVENT_REEVALUATE_EXISTING_DATA_NETWORKS*/, 2423 DataEvaluation.DataEvaluationReason.DATA_SERVICE_STATE_CHANGED).sendToTarget(); 2424 2425 processAllFutureMessages(); 2426 2427 // Make sure IMS network is not torn down 2428 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 2429 2430 // Remove MMS data enabled override 2431 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2432 .MOBILE_DATA_POLICY_MMS_ALWAYS_ALLOWED, false); 2433 processAllMessages(); 2434 2435 // Make sure MMS is torn down when the override is disabled. 2436 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 2437 } 2438 2439 @Test testMmsAlwaysAllowedRoamingDisabled()2440 public void testMmsAlwaysAllowedRoamingDisabled() throws Exception { 2441 // Data roaming disabled 2442 doReturn(true).when(mServiceState).getDataRoaming(); 2443 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 2444 processAllMessages(); 2445 2446 // Device is roaming 2447 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2448 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 2449 // Always allow MMS 2450 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2451 .MOBILE_DATA_POLICY_MMS_ALWAYS_ALLOWED, true); 2452 processAllMessages(); 2453 2454 mDataNetworkControllerUT.addNetworkRequest( 2455 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 2456 processAllMessages(); 2457 2458 // Make sure MMS is not allowed. MMS always allowed should be only applicable to data 2459 // disabled case. 2460 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 2461 } 2462 2463 @Test testIsDataEnabledOverriddenForApnDataDuringCall()2464 public void testIsDataEnabledOverriddenForApnDataDuringCall() throws Exception { 2465 // Assume phone2 is the default data phone 2466 Phone phone2 = Mockito.mock(Phone.class); 2467 replaceInstance(PhoneFactory.class, "sPhones", null, new Phone[]{mPhone, phone2}); 2468 doReturn(2).when(mSubscriptionManagerService).getDefaultDataSubId(); 2469 doReturn(1).when(mPhone).getSubId(); 2470 2471 // Data disabled on nonDDS 2472 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2473 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2474 2475 // Enable during data call mobile policy 2476 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2477 .MOBILE_DATA_POLICY_DATA_ON_NON_DEFAULT_DURING_VOICE_CALL, true); 2478 processAllMessages(); 2479 2480 // No active phone call 2481 doReturn(PhoneConstants.State.IDLE).when(mPhone).getState(); 2482 mDataNetworkControllerUT.addNetworkRequest( 2483 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2484 processAllMessages(); 2485 2486 // Verify no internet connection due to no active phone call 2487 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2488 2489 // Phone ringing 2490 doReturn(PhoneConstants.State.RINGING).when(mPhone).getState(); 2491 // Data is user enabled on DDS 2492 doReturn(true).when(phone2).isUserDataEnabled(); 2493 mDataNetworkControllerUT.addNetworkRequest( 2494 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2495 processAllMessages(); 2496 2497 // Verify internet connection 2498 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2499 2500 // Disable during data call mobile policy 2501 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2502 .MOBILE_DATA_POLICY_DATA_ON_NON_DEFAULT_DURING_VOICE_CALL, false); 2503 processAllMessages(); 2504 2505 // Verify no internet connection 2506 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2507 } 2508 2509 @Test testIsDataEnabledOverriddenForApnAutoDataSwitch()2510 public void testIsDataEnabledOverriddenForApnAutoDataSwitch() throws Exception { 2511 // Assume phone2 is the default data phone 2512 Phone phone2 = Mockito.mock(Phone.class); 2513 replaceInstance(PhoneFactory.class, "sPhones", null, new Phone[]{mPhone, phone2}); 2514 doReturn(2).when(mSubscriptionManagerService).getDefaultDataSubId(); 2515 2516 // Data disabled on nonDDS 2517 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2518 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2519 2520 // Enable auto data switch mobile policy 2521 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2522 .MOBILE_DATA_POLICY_AUTO_DATA_SWITCH, true); 2523 processAllMessages(); 2524 2525 // use disabled data on DDS 2526 doReturn(false).when(phone2).isUserDataEnabled(); 2527 mDataNetworkControllerUT.addNetworkRequest( 2528 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2529 processAllMessages(); 2530 2531 // Verify no internet connection 2532 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2533 2534 // use enabled data on DDS 2535 doReturn(true).when(phone2).isUserDataEnabled(); 2536 mDataNetworkControllerUT.addNetworkRequest( 2537 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2538 processAllMessages(); 2539 2540 // Verify internet connection 2541 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2542 2543 // Disable auto data switch mobile policy, but enabled data during call 2544 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2545 .MOBILE_DATA_POLICY_AUTO_DATA_SWITCH, false); 2546 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2547 .MOBILE_DATA_POLICY_DATA_ON_NON_DEFAULT_DURING_VOICE_CALL, true); 2548 doReturn(PhoneConstants.State.RINGING).when(phone2).getState(); 2549 processAllMessages(); 2550 2551 // Verify internet connection 2552 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2553 2554 // Disable data during call 2555 mDataNetworkControllerUT.getDataSettingsManager().setMobileDataPolicy(TelephonyManager 2556 .MOBILE_DATA_POLICY_DATA_ON_NON_DEFAULT_DURING_VOICE_CALL, false); 2557 processAllMessages(); 2558 2559 // Verify no internet connection 2560 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2561 } 2562 2563 @Test testUnmeteredRequestPreferredOnIwlan()2564 public void testUnmeteredRequestPreferredOnIwlan() throws Exception { 2565 // Preferred on cellular 2566 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 2567 .getPreferredTransportByNetworkCapability(anyInt()); 2568 // Data disabled 2569 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2570 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2571 mDataNetworkControllerUT.addNetworkRequest( 2572 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2573 processAllMessages(); 2574 2575 // Data should not be allowed when roaming + user data are disabled (soft failure reasons) 2576 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2577 2578 // Set transport to WLAN (unmetered) 2579 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 2580 .getPreferredTransportByNetworkCapability( 2581 eq(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2582 // Data remain disabled, but trigger the preference evaluation. 2583 mDataNetworkControllerUT.obtainMessage(21 /*EVENT_EVALUATE_PREFERRED_TRANSPORT*/, 2584 NetworkCapabilities.NET_CAPABILITY_INTERNET, 0).sendToTarget(); 2585 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 2586 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 2587 processAllMessages(); 2588 2589 // Verify data is allowed even if data is disabled. 2590 verifyInternetConnected(); 2591 } 2592 2593 @Test testUnmeteredRequestDataRoamingDisabled()2594 public void testUnmeteredRequestDataRoamingDisabled() throws Exception { 2595 // Data roaming disabled 2596 doReturn(true).when(mServiceState).getDataRoaming(); 2597 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 2598 processAllMessages(); 2599 2600 // MMS is unmetered 2601 mCarrierConfig.putStringArray( 2602 CarrierConfigManager.KEY_CARRIER_METERED_ROAMING_APN_TYPES_STRINGS, 2603 new String[]{"default", "dun", "supl"}); 2604 carrierConfigChanged(); 2605 // Manually set data roaming to false in case ro.com.android.dataroaming is true. 2606 // TODO(b/232575718): Figure out a way to mock ro.com.android.dataroaming for tests. 2607 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 2608 // Device is roaming 2609 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2610 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 2611 2612 mDataNetworkControllerUT.addNetworkRequest( 2613 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 2614 processAllMessages(); 2615 2616 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 2617 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2618 } 2619 2620 @Test testUnmeteredRequestDataDisabled()2621 public void testUnmeteredRequestDataDisabled() throws Exception { 2622 // MMS is unmetered 2623 mCarrierConfig.putStringArray( 2624 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 2625 new String[]{"default", "dun", "supl"}); 2626 carrierConfigChanged(); 2627 2628 // Data disabled 2629 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2630 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2631 2632 mDataNetworkControllerUT.addNetworkRequest( 2633 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 2634 2635 processAllMessages(); 2636 2637 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 2638 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2639 } 2640 2641 @Test testEmergencyRequest()2642 public void testEmergencyRequest() throws Exception { 2643 // Data disabled 2644 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2645 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2646 mDataNetworkControllerUT.addNetworkRequest( 2647 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_EIMS)); 2648 processAllMessages(); 2649 2650 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_EIMS); 2651 verifyConnectedNetworkHasDataProfile(mEmergencyDataProfile); 2652 } 2653 2654 @Test testEmergencyRequestWithThrottling()2655 public void testEmergencyRequestWithThrottling() throws Exception { 2656 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 2657 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, /* data */ 2658 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, /* voice */ 2659 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, /* iwlan */ 2660 null, false); 2661 mDataNetworkControllerUT.getDataRetryManager() 2662 .registerCallback(mMockedDataRetryManagerCallback); 2663 2664 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.PROTOCOL_ERRORS, 2665 10000, false); 2666 mDataNetworkControllerUT.addNetworkRequest( 2667 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_EIMS)); 2668 processAllMessages(); 2669 2670 // There should be only one attempt, and no retry should happen because the second one 2671 // was throttled. 2672 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 2673 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2674 any(), any(), anyBoolean(), any(Message.class)); 2675 2676 ArgumentCaptor<List<ThrottleStatus>> throttleStatusCaptor = 2677 ArgumentCaptor.forClass(List.class); 2678 verify(mMockedDataRetryManagerCallback) 2679 .onThrottleStatusChanged(throttleStatusCaptor.capture()); 2680 assertThat(throttleStatusCaptor.getValue()).hasSize(1); 2681 ThrottleStatus throttleStatus = throttleStatusCaptor.getValue().get(0); 2682 assertThat(throttleStatus.getApnType()).isEqualTo(ApnSetting.TYPE_EMERGENCY); 2683 assertThat(throttleStatus.getRetryType()) 2684 .isEqualTo(ThrottleStatus.RETRY_TYPE_NEW_CONNECTION); 2685 assertThat(throttleStatus.getTransportType()) 2686 .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2687 2688 Mockito.reset(mMockedWwanDataServiceManager); 2689 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2690 NetworkRegistrationInfo.REGISTRATION_STATE_DENIED, /* data */ 2691 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, /* voice */ 2692 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, /* iwlan */ 2693 null, true); 2694 2695 // No retry should happen because the second one was throttled. 2696 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 2697 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2698 any(), any(), anyBoolean(), any(Message.class)); 2699 } 2700 2701 @Test testHandoverRuleFromString()2702 public void testHandoverRuleFromString() { 2703 HandoverRule handoverRule = new HandoverRule("source=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN, " 2704 + "target=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN, type=allowed", mFeatureFlags); 2705 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.GERAN, 2706 AccessNetworkType.UTRAN, AccessNetworkType.EUTRAN, AccessNetworkType.NGRAN, 2707 AccessNetworkType.IWLAN); 2708 assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.GERAN, 2709 AccessNetworkType.UTRAN, AccessNetworkType.EUTRAN, AccessNetworkType.NGRAN, 2710 AccessNetworkType.IWLAN); 2711 assertThat(handoverRule.type).isEqualTo(HandoverRule.RULE_TYPE_ALLOWED); 2712 assertThat(handoverRule.isOnlyForRoaming).isFalse(); 2713 assertThat(handoverRule.networkCapabilities).isEmpty(); 2714 2715 handoverRule = new HandoverRule("source= NGRAN| IWLAN, " 2716 + "target = EUTRAN, type = disallowed ", mFeatureFlags); 2717 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.NGRAN, 2718 AccessNetworkType.IWLAN); 2719 assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.EUTRAN); 2720 assertThat(handoverRule.type).isEqualTo(HandoverRule.RULE_TYPE_DISALLOWED); 2721 assertThat(handoverRule.isOnlyForRoaming).isFalse(); 2722 assertThat(handoverRule.networkCapabilities).isEmpty(); 2723 2724 handoverRule = new HandoverRule("source= IWLAN, " 2725 + "target = EUTRAN, type = disallowed, roaming = true," 2726 + " capabilities = IMS | EIMS ", mFeatureFlags); 2727 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.IWLAN); 2728 assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.EUTRAN); 2729 assertThat(handoverRule.type).isEqualTo(HandoverRule.RULE_TYPE_DISALLOWED); 2730 assertThat(handoverRule.networkCapabilities).containsExactly( 2731 NetworkCapabilities.NET_CAPABILITY_IMS, NetworkCapabilities.NET_CAPABILITY_EIMS); 2732 assertThat(handoverRule.isOnlyForRoaming).isTrue(); 2733 2734 handoverRule = new HandoverRule("source=EUTRAN|NGRAN|IWLAN|UNKNOWN, " 2735 + "target=EUTRAN|NGRAN|IWLAN, type=disallowed, capabilities = IMS|EIMS", 2736 mFeatureFlags); 2737 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.EUTRAN, 2738 AccessNetworkType.NGRAN, AccessNetworkType.IWLAN, AccessNetworkType.UNKNOWN); 2739 assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.EUTRAN, 2740 AccessNetworkType.NGRAN, AccessNetworkType.IWLAN); 2741 assertThat(handoverRule.type).isEqualTo(HandoverRule.RULE_TYPE_DISALLOWED); 2742 assertThat(handoverRule.networkCapabilities).containsExactly( 2743 NetworkCapabilities.NET_CAPABILITY_IMS, NetworkCapabilities.NET_CAPABILITY_EIMS); 2744 2745 handoverRule = new HandoverRule("source=NGRAN|IWLAN, " 2746 + "target = NGRAN|IWLAN, type=disallowed, incall = true," 2747 + " capabilities = IMS|EIMS ", mFeatureFlags); 2748 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.NGRAN, 2749 AccessNetworkType.IWLAN); 2750 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.NGRAN, 2751 AccessNetworkType.IWLAN); 2752 assertThat(handoverRule.type).isEqualTo(HandoverRule.RULE_TYPE_DISALLOWED); 2753 assertThat(handoverRule.networkCapabilities).containsExactly( 2754 NetworkCapabilities.NET_CAPABILITY_IMS, NetworkCapabilities.NET_CAPABILITY_EIMS); 2755 assertThat(handoverRule.isOnlyForIncall).isTrue(); 2756 2757 assertThrows(IllegalArgumentException.class, 2758 () -> new HandoverRule("V2hhdCBUaGUgRnVjayBpcyB0aGlzIQ==", mFeatureFlags)); 2759 2760 assertThrows(IllegalArgumentException.class, 2761 () -> new HandoverRule("target=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN, type=allowed", 2762 mFeatureFlags)); 2763 2764 assertThrows(IllegalArgumentException.class, 2765 () -> new HandoverRule("source=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN, type=allowed", 2766 mFeatureFlags)); 2767 2768 assertThrows(IllegalArgumentException.class, 2769 () -> new HandoverRule("source=GERAN, target=UNKNOWN, type=disallowed, " 2770 + "capabilities=IMS", mFeatureFlags)); 2771 2772 assertThrows(IllegalArgumentException.class, 2773 () -> new HandoverRule("source=UNKNOWN, target=IWLAN, type=allowed, " 2774 + "capabilities=IMS", mFeatureFlags)); 2775 2776 assertThrows(IllegalArgumentException.class, 2777 () -> new HandoverRule("source=GERAN, target=IWLAN, type=wtf", mFeatureFlags)); 2778 2779 assertThrows(IllegalArgumentException.class, 2780 () -> new HandoverRule("source=GERAN, target=NGRAN, type=allowed", mFeatureFlags)); 2781 2782 assertThrows(IllegalArgumentException.class, 2783 () -> new HandoverRule("source=IWLAN, target=WTFRAN, type=allowed", 2784 mFeatureFlags)); 2785 2786 assertThrows(IllegalArgumentException.class, 2787 () -> new HandoverRule("source=IWLAN, target=|, type=allowed", mFeatureFlags)); 2788 2789 assertThrows(IllegalArgumentException.class, 2790 () -> new HandoverRule("source=GERAN, target=IWLAN, type=allowed, capabilities=|", 2791 mFeatureFlags)); 2792 2793 assertThrows(IllegalArgumentException.class, 2794 () -> new HandoverRule("source=GERAN, target=IWLAN, type=allowed, capabilities=", 2795 mFeatureFlags)); 2796 2797 assertThrows(IllegalArgumentException.class, 2798 () -> new HandoverRule("source=GERAN, target=IWLAN, type=allowed, " 2799 + "capabilities=wtf", mFeatureFlags)); 2800 } 2801 2802 @Test testIsNetworkTypeCongested()2803 public void testIsNetworkTypeCongested() throws Exception { 2804 Set<Integer> congestedNetworkTypes = new ArraySet<>(); 2805 doReturn(congestedNetworkTypes).when(mDataNetworkController) 2806 .getCongestedOverrideNetworkTypes(); 2807 testSetupDataNetwork(); 2808 DataNetwork dataNetwork = getDataNetworks().get(0); 2809 2810 // Set 5G unmetered 2811 congestedNetworkTypes.add(TelephonyManager.NETWORK_TYPE_NR); 2812 mDataNetworkControllerUT.obtainMessage(EVENT_SUBSCRIPTION_OVERRIDE, 2813 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_CONGESTED, 2814 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_CONGESTED, 2815 new int[]{TelephonyManager.NETWORK_TYPE_NR}).sendToTarget(); 2816 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 2817 processAllMessages(); 2818 assertEquals(congestedNetworkTypes, 2819 mDataNetworkControllerUT.getCongestedOverrideNetworkTypes()); 2820 assertTrue(dataNetwork.getNetworkCapabilities().hasCapability( 2821 NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED)); 2822 2823 // Change data network type to NR 2824 doReturn(new TelephonyDisplayInfo(TelephonyManager.NETWORK_TYPE_NR, 2825 TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NONE, false, false, false)) 2826 .when(mDisplayInfoController).getTelephonyDisplayInfo(); 2827 dataNetwork.sendMessage(13/*EVENT_DISPLAY_INFO_CHANGED*/); 2828 processAllMessages(); 2829 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 2830 NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED)); 2831 2832 // Set all network types metered 2833 congestedNetworkTypes.clear(); 2834 mDataNetworkControllerUT.obtainMessage(EVENT_SUBSCRIPTION_OVERRIDE, 2835 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_CONGESTED, 0, 2836 TelephonyManager.getAllNetworkTypes()).sendToTarget(); 2837 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 2838 processAllMessages(); 2839 assertTrue(mDataNetworkControllerUT.getCongestedOverrideNetworkTypes().isEmpty()); 2840 assertTrue(dataNetwork.getNetworkCapabilities().hasCapability( 2841 NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED)); 2842 } 2843 2844 @Test testIsNetworkTypeUnmeteredViaSubscriptionOverride()2845 public void testIsNetworkTypeUnmeteredViaSubscriptionOverride() throws Exception { 2846 Set<Integer> unmeteredNetworkTypes = new ArraySet<>(); 2847 doReturn(unmeteredNetworkTypes).when(mDataNetworkController) 2848 .getUnmeteredOverrideNetworkTypes(); 2849 testSetupDataNetwork(); 2850 DataNetwork dataNetwork = getDataNetworks().get(0); 2851 2852 // Set 5G unmetered 2853 unmeteredNetworkTypes.add(TelephonyManager.NETWORK_TYPE_NR); 2854 mDataNetworkControllerUT.obtainMessage(EVENT_SUBSCRIPTION_OVERRIDE, 2855 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_UNMETERED, 2856 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_UNMETERED, 2857 new int[]{TelephonyManager.NETWORK_TYPE_NR}).sendToTarget(); 2858 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 2859 processAllMessages(); 2860 assertEquals(unmeteredNetworkTypes, 2861 mDataNetworkControllerUT.getUnmeteredOverrideNetworkTypes()); 2862 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 2863 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 2864 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isFalse(); 2865 2866 // Change data network type to NR 2867 doReturn(new TelephonyDisplayInfo(TelephonyManager.NETWORK_TYPE_NR, 2868 TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NONE, false, false, false)) 2869 .when(mDisplayInfoController).getTelephonyDisplayInfo(); 2870 dataNetwork.sendMessage(13/*EVENT_DISPLAY_INFO_CHANGED*/); 2871 processAllMessages(); 2872 assertTrue(dataNetwork.getNetworkCapabilities().hasCapability( 2873 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 2874 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isTrue(); 2875 2876 // Set all network types metered 2877 unmeteredNetworkTypes.clear(); 2878 mDataNetworkControllerUT.obtainMessage(EVENT_SUBSCRIPTION_OVERRIDE, 2879 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_UNMETERED, 0, 2880 TelephonyManager.getAllNetworkTypes()).sendToTarget(); 2881 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 2882 processAllMessages(); 2883 assertTrue(mDataNetworkControllerUT.getUnmeteredOverrideNetworkTypes().isEmpty()); 2884 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 2885 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 2886 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isFalse(); 2887 } 2888 2889 @Test testIsNetworkTypeUnmeteredViaSubscriptionPlans()2890 public void testIsNetworkTypeUnmeteredViaSubscriptionPlans() throws Exception { 2891 List<SubscriptionPlan> subscriptionPlans = new ArrayList<>(); 2892 doReturn(subscriptionPlans).when(mDataNetworkController).getSubscriptionPlans(); 2893 testSetupDataNetwork(); 2894 DataNetwork dataNetwork = getDataNetworks().get(0); 2895 2896 // Set 5G unmetered 2897 SubscriptionPlan unmetered5GPlan = SubscriptionPlan.Builder 2898 .createRecurring(ZonedDateTime.parse("2007-03-14T00:00:00.000Z"), 2899 Period.ofMonths(1)) 2900 .setDataLimit(SubscriptionPlan.BYTES_UNLIMITED, 2901 SubscriptionPlan.LIMIT_BEHAVIOR_THROTTLED) 2902 .setNetworkTypes(new int[]{TelephonyManager.NETWORK_TYPE_NR}) 2903 .build(); 2904 SubscriptionPlan generalMeteredPlan = SubscriptionPlan.Builder 2905 .createRecurring(ZonedDateTime.parse("2007-03-14T00:00:00.000Z"), 2906 Period.ofMonths(1)) 2907 .setDataLimit(1_000_000_000, SubscriptionPlan.LIMIT_BEHAVIOR_DISABLED) 2908 .setDataUsage(500_000_000, System.currentTimeMillis()) 2909 .build(); 2910 subscriptionPlans.add(generalMeteredPlan); 2911 subscriptionPlans.add(unmetered5GPlan); 2912 mDataNetworkControllerUT.obtainMessage(22/*EVENT_SUBSCRIPTION_PLANS_CHANGED*/, 2913 new SubscriptionPlan[]{generalMeteredPlan, unmetered5GPlan}).sendToTarget(); 2914 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 2915 processAllMessages(); 2916 assertEquals(subscriptionPlans, mDataNetworkControllerUT.getSubscriptionPlans()); 2917 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 2918 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 2919 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isFalse(); 2920 2921 2922 // Change data network type to NR 2923 doReturn(new TelephonyDisplayInfo(TelephonyManager.NETWORK_TYPE_NR, 2924 TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NONE, false, false, false)) 2925 .when(mDisplayInfoController).getTelephonyDisplayInfo(); 2926 dataNetwork.sendMessage(13/*EVENT_DISPLAY_INFO_CHANGED*/); 2927 processAllMessages(); 2928 assertTrue(dataNetwork.getNetworkCapabilities().hasCapability( 2929 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 2930 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isTrue(); 2931 2932 // Set all network types metered 2933 subscriptionPlans.clear(); 2934 mDataNetworkControllerUT.obtainMessage(22/*EVENT_SUBSCRIPTION_PLANS_CHANGED*/, 2935 new SubscriptionPlan[]{}).sendToTarget(); 2936 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 2937 processAllMessages(); 2938 assertTrue(mDataNetworkControllerUT.getSubscriptionPlans().isEmpty()); 2939 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 2940 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 2941 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isFalse(); 2942 } 2943 2944 @Test testOnSinglePdnArbitrationExemptIms()2945 public void testOnSinglePdnArbitrationExemptIms() throws Exception { 2946 // On CDMA network, only one data network is allowed. 2947 serviceStateChanged(TelephonyManager.NETWORK_TYPE_1xRTT, 2948 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2949 // Preferred on cellular 2950 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 2951 .getPreferredTransportByNetworkCapability(anyInt()); 2952 // Add IMS 2953 TelephonyNetworkRequest ims = createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 2954 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2955 mDataNetworkControllerUT.addNetworkRequest(ims); 2956 processAllMessages(); 2957 2958 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2959 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2960 2961 // Add internet, should be compatible 2962 mDataNetworkControllerUT.addNetworkRequest( 2963 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2964 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 2965 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 2966 processAllMessages(); 2967 2968 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2969 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2970 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2971 2972 // Both internet and IMS should be retained after network re-evaluation 2973 mDataNetworkControllerUT.obtainMessage(EVENT_REEVALUATE_EXISTING_DATA_NETWORKS) 2974 .sendToTarget(); 2975 processAllMessages(); 2976 2977 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2978 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2979 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2980 2981 // Add MMS, whose priority > internet, internet should be town down, IMS left untouched 2982 mDataNetworkControllerUT.addNetworkRequest( 2983 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 2984 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 2985 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 3); 2986 processAllMessages(); 2987 2988 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 2989 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2990 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2991 2992 // Both internet and IMS should be retained after network re-evaluation 2993 mDataNetworkControllerUT.obtainMessage(EVENT_REEVALUATE_EXISTING_DATA_NETWORKS) 2994 .sendToTarget(); 2995 processAllMessages(); 2996 2997 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 2998 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2999 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3000 3001 // Temporarily remove IMS 3002 mDataNetworkControllerUT.removeNetworkRequest(ims); 3003 processAllMessages(); 3004 List<DataNetwork> dataNetworks = getDataNetworks(); 3005 dataNetworks.get(0).tearDown(DataNetwork.TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 3006 processAllMessages(); 3007 3008 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3009 3010 // Add IMS, should be compatible with the existing internet 3011 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 3012 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 4); 3013 mDataNetworkControllerUT.addNetworkRequest( 3014 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 3015 processAllMessages(); 3016 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3017 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3018 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3019 } 3020 3021 @Test testLinkStatusChanged()3022 public void testLinkStatusChanged() throws Exception { 3023 testSetupDataNetwork(); 3024 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 3025 eq(DataCallResponse.LINK_STATUS_ACTIVE)); 3026 3027 DataNetwork dataNetwork = getDataNetworks().get(0); 3028 3029 DataCallResponse response = createDataCallResponse(1, DataCallResponse.LINK_STATUS_DORMANT); 3030 dataNetwork.obtainMessage(8 /*EVENT_DATA_STATE_CHANGED */, 3031 new AsyncResult(AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 3032 List.of(response), null)).sendToTarget(); 3033 3034 processAllMessages(); 3035 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 3036 eq(DataCallResponse.LINK_STATUS_DORMANT)); 3037 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 3038 TelephonyManager.DATA_ACTIVITY_DORMANT); 3039 } 3040 3041 @Test testHandoverDataNetwork()3042 public void testHandoverDataNetwork() throws Exception { 3043 testSetupImsDataNetwork(); 3044 3045 DataNetwork dataNetwork = getDataNetworks().get(0); 3046 // Before handover the data profile is the cellular IMS data profile 3047 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 3048 3049 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3050 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3051 3052 // Verify that IWLAN handover succeeded. 3053 assertThat(dataNetwork.getTransport()).isEqualTo( 3054 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3055 3056 // After handover the data profile is the IWLAN IMS data profile 3057 verifyConnectedNetworkHasDataProfile(mImsIwlanDataProfile); 3058 } 3059 3060 @Test testHandoverDataNetworkBackToBackPreferenceChanged()3061 public void testHandoverDataNetworkBackToBackPreferenceChanged() throws Exception { 3062 testSetupImsDataNetwork(); 3063 3064 Mockito.reset(mMockedWlanDataServiceManager); 3065 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3066 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3067 3068 // Capture the message for setup data call response. We want to delay it. 3069 ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class); 3070 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 3071 anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 3072 messageCaptor.capture()); 3073 3074 // Before setup data call response, change the preference back to cellular. 3075 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3076 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3077 3078 // Before setup data call response, change the preference back to IWLAN. 3079 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3080 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3081 3082 // Finally handover is completed. 3083 Message msg = messageCaptor.getValue(); 3084 DataCallResponse response = new DataCallResponse.Builder() 3085 .setCause(DataFailCause.NONE) 3086 .build(); 3087 msg.getData().putParcelable("data_call_response", response); 3088 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 3089 msg.sendToTarget(); 3090 processAllMessages(); 3091 3092 // Make sure handover request is only sent once. 3093 verify(mMockedWlanDataServiceManager, times(1)).setupDataCall(anyInt(), 3094 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3095 any(), any(), anyBoolean(), messageCaptor.capture()); 3096 } 3097 3098 @Test testHandoverDataNetworkBackToBackPreferenceChangedHandoverFail()3099 public void testHandoverDataNetworkBackToBackPreferenceChangedHandoverFail() throws Exception { 3100 testSetupImsDataNetwork(); 3101 DataNetwork dataNetwork = getDataNetworks().get(0); 3102 3103 Mockito.reset(mMockedWlanDataServiceManager); 3104 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3105 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3106 3107 // Capture the message for setup data call response. We want to delay it. 3108 ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class); 3109 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 3110 anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 3111 messageCaptor.capture()); 3112 3113 // Before setup data call response, change the preference back to cellular. 3114 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3115 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3116 3117 // Finally handover is completed. 3118 Message msg = messageCaptor.getValue(); 3119 DataCallResponse response = new DataCallResponse.Builder() 3120 .setCause(DataFailCause.ERROR_UNSPECIFIED) 3121 .setRetryDurationMillis(123) 3122 .setHandoverFailureMode( 3123 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_SETUP_NORMAL) 3124 .build(); 3125 msg.getData().putParcelable("data_call_response", response); 3126 msg.arg1 = DataServiceCallback.RESULT_ERROR_UNSUPPORTED; 3127 msg.sendToTarget(); 3128 processAllMessages(); 3129 3130 // Make sure handover request is only sent once. 3131 verify(mMockedWlanDataServiceManager, times(1)).setupDataCall(anyInt(), 3132 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3133 any(), any(), anyBoolean(), messageCaptor.capture()); 3134 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS); 3135 assertSame(dataNetwork, getDataNetworks().get(0)); 3136 } 3137 3138 @Test testHandoverDataNetworkNotAllowedByPolicy()3139 public void testHandoverDataNetworkNotAllowedByPolicy() throws Exception { 3140 mCarrierConfig.putStringArray(CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 3141 new String[]{"source=EUTRAN, target=IWLAN, type=disallowed, capabilities=MMS|IMS", 3142 "source=IWLAN, target=EUTRAN, type=disallowed, capabilities=MMS"}); 3143 // Force data config manager to reload the carrier config. 3144 carrierConfigChanged(); 3145 processAllMessages(); 3146 3147 testSetupImsDataNetwork(); 3148 3149 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3150 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3151 // After this, IMS data network should be disconnected, and DNC should attempt to 3152 // establish a new one on IWLAN 3153 3154 // Verify all data disconnected. 3155 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 3156 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 3157 eq(DataCallResponse.LINK_STATUS_INACTIVE)); 3158 3159 // A new data network should be connected on IWLAN 3160 List<DataNetwork> dataNetworkList = getDataNetworks(); 3161 assertThat(dataNetworkList).hasSize(1); 3162 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 3163 assertThat(dataNetworkList.get(0).getNetworkCapabilities().hasCapability( 3164 NetworkCapabilities.NET_CAPABILITY_IMS)).isTrue(); 3165 assertThat(dataNetworkList.get(0).getTransport()) 3166 .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3167 3168 // test IWLAN -> EUTRAN no need to tear down because the disallowed rule only applies to MMS 3169 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 3170 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3171 mDataNetworkControllerUT.obtainMessage(21/*EVENT_PREFERRED_TRANSPORT_CHANGED*/, 3172 NetworkCapabilities.NET_CAPABILITY_IMS, 0).sendToTarget(); 3173 Mockito.clearInvocations(mMockedWwanDataServiceManager); 3174 processAllMessages(); 3175 // Verify that IWWAN handover succeeded. 3176 assertThat(getDataNetworks().get(0).getTransport()).isEqualTo( 3177 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3178 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall( 3179 anyInt(), any(), anyBoolean(), anyBoolean(), 3180 eq(DataService.REQUEST_REASON_HANDOVER), any(), anyInt(), any(), any(), eq(true), 3181 any()); 3182 } 3183 3184 @Test testHandoverDataNetworkNotAllowedByPolicyDelayDueToVoiceCall()3185 public void testHandoverDataNetworkNotAllowedByPolicyDelayDueToVoiceCall() throws Exception { 3186 // Config delay IMS tear down enabled 3187 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL, 3188 true); 3189 mCarrierConfig.putStringArray(CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 3190 new String[]{"source=EUTRAN, target=IWLAN, type=disallowed, capabilities=MMS|IMS"}); 3191 carrierConfigChanged(); 3192 3193 testSetupImsDataNetwork(); 3194 3195 // Ringing an active call, should delay handover tear down 3196 doReturn(PhoneConstants.State.RINGING).when(mCT).getState(); 3197 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3198 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3199 3200 // Verify network is still connected due to active voice call 3201 verify(mMockedWwanDataServiceManager, never()).deactivateDataCall(anyInt(), 3202 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 3203 3204 // Verify tear down after call ends 3205 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 3206 mDataNetworkControllerUT.obtainMessage(EVENT_VOICE_CALL_ENDED).sendToTarget(); 3207 processAllFutureMessages(); 3208 3209 verify(mMockedWwanDataServiceManager).deactivateDataCall(anyInt(), 3210 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 3211 } 3212 3213 @Test testHandoverDataNetworkNotAllowedByRoamingPolicy()3214 public void testHandoverDataNetworkNotAllowedByRoamingPolicy() throws Exception { 3215 mCarrierConfig.putStringArray(CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 3216 new String[]{"source=EUTRAN|NGRAN|IWLAN, target=EUTRAN|NGRAN|IWLAN, roaming=true, " 3217 + "type=disallowed, capabilities=IMS"}); 3218 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 3219 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 3220 // Force data config manager to reload the carrier config. 3221 mDataNetworkControllerUT.getDataConfigManager().obtainMessage( 3222 1/*EVENT_CARRIER_CONFIG_CHANGED*/).sendToTarget(); 3223 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 3224 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3225 3226 processAllMessages(); 3227 3228 // Bring up IMS PDN on IWLAN 3229 mDataNetworkControllerUT.addNetworkRequest( 3230 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 3231 processAllMessages(); 3232 verifyConnectedNetworkHasDataProfile(mImsIwlanDataProfile); 3233 3234 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3235 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3236 3237 // Verify IMS PDN is connected. 3238 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3239 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3240 3241 // After this, IMS data network should be disconnected, and DNC should attempt to 3242 // establish a new one on cellular 3243 processAllMessages(); 3244 3245 // Verify all data disconnected. 3246 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 3247 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 3248 eq(DataCallResponse.LINK_STATUS_INACTIVE)); 3249 3250 // Should setup a new one instead of handover. 3251 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 3252 anyBoolean(), anyBoolean(), eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), 3253 any(), any(), anyBoolean(), any(Message.class)); 3254 3255 3256 // A new data network should be connected on IWLAN 3257 List<DataNetwork> dataNetworkList = getDataNetworks(); 3258 assertThat(dataNetworkList).hasSize(1); 3259 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 3260 assertThat(dataNetworkList.get(0).getNetworkCapabilities().hasCapability( 3261 NetworkCapabilities.NET_CAPABILITY_IMS)).isTrue(); 3262 assertThat(dataNetworkList.get(0).getTransport()) 3263 .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3264 } 3265 3266 @Test testHandoverDataNetworkNotAllowedByIncallPolicy()3267 public void testHandoverDataNetworkNotAllowedByIncallPolicy() throws Exception { 3268 mCarrierConfig.putStringArray(CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 3269 new String[]{"source=EUTRAN, target=IWLAN, type=disallowed, incall=true, " 3270 + "capabilities=IMS"}); 3271 carrierConfigChanged(); 3272 testSetupImsDataNetwork(); 3273 doReturn(PhoneConstants.State.RINGING).when(mCT).getState(); 3274 3275 // After this, IMS data network should be disconnected, and DNC should attempt to 3276 // establish a new one on IWLAN 3277 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3278 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3279 3280 // Verify all data disconnected. 3281 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 3282 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 3283 eq(DataCallResponse.LINK_STATUS_INACTIVE)); 3284 3285 // A new data network should be connected on IWLAN 3286 List<DataNetwork> dataNetworkList = getDataNetworks(); 3287 assertThat(dataNetworkList).hasSize(1); 3288 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 3289 assertThat(dataNetworkList.get(0).getNetworkCapabilities().hasCapability( 3290 NetworkCapabilities.NET_CAPABILITY_IMS)).isTrue(); 3291 assertThat(dataNetworkList.get(0).getTransport()) 3292 .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3293 } 3294 3295 @Test testHandoverDataNetworkRetry()3296 public void testHandoverDataNetworkRetry() throws Exception { 3297 testSetupImsDataNetwork(); 3298 3299 setFailedSetupDataResponse(mMockedWlanDataServiceManager, 3300 DataFailCause.HANDOVER_FAILED, -1, true); 3301 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3302 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3303 3304 DataNetwork dataNetwork = getDataNetworks().get(0); 3305 // Verify that data network is still on cellular 3306 assertThat(dataNetwork.getTransport()).isEqualTo( 3307 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3308 3309 // Set target transport OOS 3310 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 3311 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* data */ 3312 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* voice */ 3313 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, /* iwlan */ 3314 null); 3315 setSuccessfulSetupDataResponse(mMockedWlanDataServiceManager, 1); 3316 3317 processAllFutureMessages(); 3318 // Verify that data network is still on cellular 3319 assertThat(dataNetwork.getTransport()).isEqualTo( 3320 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3321 3322 // Set target transport back to service 3323 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 3324 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* data */ 3325 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* voice */ 3326 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* iwlan */ 3327 null); 3328 processAllFutureMessages(); 3329 3330 dataNetwork = getDataNetworks().get(0); 3331 // Verify that data network is handovered to IWLAN 3332 assertThat(dataNetwork.getTransport()).isEqualTo( 3333 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3334 } 3335 3336 @Test testHandoverDataNetworkDuplicateRetry()3337 public void testHandoverDataNetworkDuplicateRetry() throws Exception { 3338 testSetupImsDataNetwork(); 3339 DataNetwork dataNetwork = getDataNetworks().get(0); 3340 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 3341 .when(mAccessNetworksManager).getPreferredTransportByNetworkCapability(anyInt()); 3342 3343 DataRetryManager.DataHandoverRetryEntry retry1 = 3344 new DataRetryManager.DataHandoverRetryEntry.Builder<>() 3345 .setDataNetwork(dataNetwork) 3346 .build(); 3347 DataRetryManager.DataHandoverRetryEntry retry2 = 3348 new DataRetryManager.DataHandoverRetryEntry.Builder<>() 3349 .setDataNetwork(dataNetwork) 3350 .build(); 3351 final Message msg1 = new Message(); 3352 msg1.what = 4 /*EVENT_DATA_HANDOVER_RETRY*/; 3353 msg1.obj = retry1; 3354 3355 final Message msg2 = new Message(); 3356 msg2.what = 4 /*EVENT_DATA_HANDOVER_RETRY*/; 3357 msg2.obj = retry2; 3358 3359 Field field = DataRetryManager.class.getDeclaredField("mDataRetryEntries"); 3360 field.setAccessible(true); 3361 List<DataRetryManager.DataRetryEntry> dataRetryEntries = 3362 (List<DataRetryManager.DataRetryEntry>) 3363 field.get(mDataNetworkControllerUT.getDataRetryManager()); 3364 dataRetryEntries.add(retry1); 3365 dataRetryEntries.add(retry2); 3366 3367 mDataNetworkControllerUT.getDataRetryManager().sendMessageDelayed(msg1, 0); 3368 mDataNetworkControllerUT.getDataRetryManager().sendMessageDelayed(msg2, 0); 3369 3370 processAllFutureMessages(); 3371 3372 setSuccessfulSetupDataResponse(mMockedWlanDataServiceManager, 1); 3373 processAllMessages(); 3374 3375 dataNetwork = getDataNetworks().get(0); 3376 assertThat(dataNetwork.getTransport()).isEqualTo( 3377 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3378 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 3379 anyBoolean(), anyBoolean(), eq(DataService.REQUEST_REASON_HANDOVER), any(), 3380 anyInt(), any(), any(), anyBoolean(), any(Message.class)); 3381 assertThat(mDataNetworkControllerUT.getDataRetryManager() 3382 .isAnyHandoverRetryScheduled(dataNetwork)).isFalse(); 3383 } 3384 3385 @Test testHandoverDataNetworkRetryReachedMaximum()3386 public void testHandoverDataNetworkRetryReachedMaximum() throws Exception { 3387 testSetupImsDataNetwork(); 3388 3389 // 1. Normal case 3390 setFailedSetupDataResponse(mMockedWlanDataServiceManager, 3391 DataFailCause.HANDOVER_FAILED, -1, true); 3392 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3393 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3394 processAllFutureMessages(); 3395 3396 // Should retried 5 times, which is the maximum based on the retry config rules. 3397 verify(mMockedWlanDataServiceManager, times(6)).setupDataCall(anyInt(), 3398 any(DataProfile.class), anyBoolean(), anyBoolean(), 3399 eq(DataService.REQUEST_REASON_HANDOVER), any(), anyInt(), any(), any(), 3400 anyBoolean(), any(Message.class)); 3401 3402 DataNetwork dataNetwork = getDataNetworks().get(0); 3403 // Verify that data network is finally setup on IWLAN. 3404 assertThat(dataNetwork.getTransport()).isEqualTo( 3405 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3406 3407 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 3408 anyBoolean(), anyBoolean(), eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), 3409 any(), any(), anyBoolean(), any(Message.class)); 3410 3411 // 2. Active VoPS call, should delay tear down 3412 doReturn(PhoneConstants.State.RINGING).when(mCT).getState(); 3413 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL, 3414 true); 3415 carrierConfigChanged(); 3416 3417 setFailedSetupDataResponse(mMockedWwanDataServiceManager, 3418 DataFailCause.HANDOVER_FAILED, -1, true); 3419 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3420 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3421 processAllFutureMessages(); 3422 3423 // Verify the network wasn't torn down 3424 verify(mMockedWlanDataServiceManager, never()).deactivateDataCall(anyInt(), 3425 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 3426 3427 // Verify tear down after call ends 3428 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 3429 mDataNetworkControllerUT.obtainMessage(EVENT_VOICE_CALL_ENDED).sendToTarget(); 3430 processAllFutureMessages(); 3431 3432 verify(mMockedWlanDataServiceManager).deactivateDataCall(anyInt(), 3433 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 3434 } 3435 3436 @Test testHandoverDataNetworkRetryReachedMaximumNetworkRequestRemoved()3437 public void testHandoverDataNetworkRetryReachedMaximumNetworkRequestRemoved() throws Exception { 3438 TelephonyNetworkRequest networkRequest = createNetworkRequest( 3439 NetworkCapabilities.NET_CAPABILITY_IMS); 3440 mDataNetworkControllerUT.addNetworkRequest(networkRequest); 3441 processAllMessages(); 3442 3443 setFailedSetupDataResponse(mMockedWlanDataServiceManager, 3444 DataFailCause.HANDOVER_FAILED, -1, true); 3445 mDataNetworkControllerUT.removeNetworkRequest(networkRequest); 3446 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3447 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3448 processAllMessages(); 3449 3450 DataNetwork dataNetwork = getDataNetworks().get(0); 3451 // Verify that data network should remain on cellular. 3452 assertThat(dataNetwork.getTransport()).isEqualTo( 3453 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3454 3455 // There shouldn't be any attempt to retry handover on IWLAN. 3456 verify(mMockedWlanDataServiceManager, times(1)).setupDataCall(anyInt(), 3457 any(DataProfile.class), anyBoolean(), anyBoolean(), 3458 eq(DataService.REQUEST_REASON_HANDOVER), any(), anyInt(), any(), any(), 3459 anyBoolean(), any(Message.class)); 3460 3461 // There shouldn't be any attempt to bring up a new one on IWLAN as well. 3462 verify(mMockedWlanDataServiceManager, never()).setupDataCall(anyInt(), 3463 any(DataProfile.class), anyBoolean(), anyBoolean(), 3464 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), 3465 anyBoolean(), any(Message.class)); 3466 } 3467 3468 @Test testHandoverDataNetworkRetryReachedMaximumDelayImsTearDown()3469 public void testHandoverDataNetworkRetryReachedMaximumDelayImsTearDown() throws Exception { 3470 // Voice call is ongoing 3471 doReturn(PhoneConstants.State.OFFHOOK).when(mCT).getState(); 3472 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL, 3473 true); 3474 carrierConfigChanged(); 3475 3476 testSetupImsDataNetwork(); 3477 3478 setFailedSetupDataResponse(mMockedWlanDataServiceManager, 3479 DataFailCause.HANDOVER_FAILED, -1, true); 3480 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3481 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3482 processAllFutureMessages(); 3483 3484 // Should retried 5 times, which is the maximum based on the retry config rules. 3485 verify(mMockedWlanDataServiceManager, times(6)).setupDataCall(anyInt(), 3486 any(DataProfile.class), anyBoolean(), anyBoolean(), 3487 eq(DataService.REQUEST_REASON_HANDOVER), any(), anyInt(), any(), any(), 3488 anyBoolean(), any(Message.class)); 3489 3490 DataNetwork dataNetwork = getDataNetworks().get(0); 3491 // Verify that data network is still on WWAN because voice call is still ongoing. 3492 assertThat(dataNetwork.getTransport()).isEqualTo( 3493 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3494 3495 } 3496 3497 // Test the device enters from 4G to 3G, and QNS switches the pref just before that happens. 3498 // Make sure we don't tear down the network and let it handover to IWLAN successfully. 3499 @Test testHandoverDataNetworkWhileSwitchTo3G()3500 public void testHandoverDataNetworkWhileSwitchTo3G() throws Exception { 3501 testSetupImsDataNetwork(); 3502 3503 // Before handover the data profile is the cellular IMS data profile 3504 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 3505 3506 // Long delay handover 3507 setSuccessfulSetupDataResponse(mMockedWlanDataServiceManager, 1, 3000); 3508 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 3509 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3510 mAccessNetworksManagerCallback.onPreferredTransportChanged( 3511 NetworkCapabilities.NET_CAPABILITY_IMS, false); 3512 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UMTS, 3513 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 3514 processAllMessages(); 3515 3516 // Move the time a little bit, handover still not responded. 3517 moveTimeForward(500); 3518 processAllMessages(); 3519 DataNetwork dataNetwork = getDataNetworks().get(0); 3520 // Verify the network is still on cellular, waiting for handover, although already on 3G. 3521 assertThat(dataNetwork.getTransport()).isEqualTo( 3522 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3523 3524 // Now handover should complete. 3525 moveTimeForward(5000); 3526 processAllMessages(); 3527 3528 dataNetwork = getDataNetworks().get(0); 3529 // Verify that IWLAN handover succeeded. 3530 assertThat(dataNetwork.getTransport()).isEqualTo( 3531 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3532 3533 // After handover the data profile is the IWLAN IMS data profile 3534 verifyConnectedNetworkHasDataProfile(mImsIwlanDataProfile); 3535 } 3536 3537 @Test testHandoverDataNetworkFailedNullResponse()3538 public void testHandoverDataNetworkFailedNullResponse() throws Exception { 3539 testSetupImsDataNetwork(); 3540 DataNetwork dataNetwork = getDataNetworks().get(0); 3541 3542 // Set failed null response 3543 doAnswer(invocation -> { 3544 final Message msg = (Message) invocation.getArguments()[10]; 3545 msg.getData().putParcelable("data_call_response", null); 3546 msg.arg1 = DataServiceCallback.RESULT_ERROR_TEMPORARILY_UNAVAILABLE; 3547 msg.getTarget().sendMessageDelayed(msg, 0); 3548 return null; 3549 }).when(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 3550 anyBoolean(), anyBoolean(), eq(DataService.REQUEST_REASON_HANDOVER), any(), 3551 anyInt(), any(), any(), anyBoolean(), any(Message.class)); 3552 3553 // Attempt handover 3554 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3555 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3556 processAllMessages(); 3557 3558 // Verify that data network is still on cellular and data network was not torn down 3559 assertThat(dataNetwork.getTransport()).isEqualTo( 3560 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3561 assertThat(dataNetwork.isConnected()).isTrue(); 3562 3563 // Process all handover retries and failures 3564 processAllFutureMessages(); 3565 3566 // Verify that original data network was torn down and new connection set up on cellular 3567 assertThat(dataNetwork.getTransport()).isEqualTo( 3568 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3569 assertThat(dataNetwork.isConnected()).isFalse(); 3570 dataNetwork = getDataNetworks().get(0); 3571 assertThat(dataNetwork.getTransport()).isEqualTo( 3572 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3573 assertThat(dataNetwork.isConnected()).isTrue(); 3574 } 3575 3576 @Test testSetupDataNetworkRetrySuggestedByNetwork()3577 public void testSetupDataNetworkRetrySuggestedByNetwork() { 3578 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 3579 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 3580 mDataNetworkControllerUT.addNetworkRequest( 3581 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 3582 processAllFutureMessages(); 3583 3584 // The first 8 retries are short timers that scheduled by handler, future retries are 3585 // scheduled by intent and require more complex mock, so we only verify the first 8 here. 3586 verify(mMockedWwanDataServiceManager, times(9)).setupDataCall(anyInt(), 3587 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3588 any(), any(), anyBoolean(), any(Message.class)); 3589 } 3590 3591 @Test testSetupDataNetworkWithCandidateProfileWithIncompatibleRetryDataProfile()3592 public void testSetupDataNetworkWithCandidateProfileWithIncompatibleRetryDataProfile() throws Exception { 3593 mDataNetworkControllerUT 3594 .getDataRetryManager() 3595 .registerCallback(mMockedDataRetryManagerCallback); 3596 setFailedSetupDataResponse(mMockedWwanDataServiceManager, 3597 DataFailCause.ONLY_IPV4_ALLOWED, 2500 /* mSec */, false); 3598 mDataNetworkControllerUT.addNetworkRequest( 3599 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 3600 processAllMessages(); 3601 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3602 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3603 any(), any(), anyBoolean(), any(Message.class)); 3604 3605 moveTimeForward(2500); 3606 processAllMessages(); 3607 ArgumentCaptor<DataRetryManager.DataSetupRetryEntry> retryEntry = 3608 ArgumentCaptor.forClass(DataRetryManager.DataSetupRetryEntry.class); 3609 verify(mMockedDataRetryManagerCallback, times(1)) 3610 .onDataNetworkSetupRetry(retryEntry.capture()); 3611 3612 ArgumentCaptor<List<ThrottleStatus>> throttleStatusCaptor = 3613 ArgumentCaptor.forClass(List.class); 3614 verify(mMockedDataRetryManagerCallback) 3615 .onThrottleStatusChanged(throttleStatusCaptor.capture()); 3616 3617 assertThat(retryEntry.getValue().dataProfile).isNotNull(); 3618 3619 assertThat(retryEntry.getValue().dataProfile).isEqualTo(mGeneralPurposeDataProfile); 3620 doReturn(false) 3621 .when(mDataProfileManager) 3622 .isDataProfileCompatible(retryEntry.getValue().dataProfile); 3623 3624 doReturn(mDuplicatedGeneralPurposeDataProfile).when(mDataProfileManager) 3625 .getDataProfileForNetworkRequest(any(TelephonyNetworkRequest.class), 3626 anyInt(), anyBoolean(), anyBoolean(), anyBoolean()); 3627 3628 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 2); 3629 3630 mDataNetworkControllerUT 3631 .getDataRetryManager() 3632 .obtainMessage( 3633 6 /* EVENT_DATA_PROFILE_UNTHROTTLED*/, 3634 new AsyncResult( 3635 AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 3636 mGeneralPurposeDataProfile, 3637 null)) 3638 .sendToTarget(); 3639 processAllFutureMessages(); 3640 3641 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 3642 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3643 any(), any(), anyBoolean(), any(Message.class)); 3644 3645 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3646 verifyConnectedNetworkHasDataProfile(mDuplicatedGeneralPurposeDataProfile); 3647 } 3648 3649 @Test testSetupDataNetworkRetryWithCompatibleRetryDataProfile()3650 public void testSetupDataNetworkRetryWithCompatibleRetryDataProfile() throws Exception { 3651 mDataNetworkControllerUT 3652 .getDataRetryManager() 3653 .registerCallback(mMockedDataRetryManagerCallback); 3654 setFailedSetupDataResponse(mMockedWwanDataServiceManager, 3655 DataFailCause.ONLY_IPV4_ALLOWED, 2500 /* mSec */, false); 3656 mDataNetworkControllerUT.addNetworkRequest( 3657 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 3658 processAllMessages(); 3659 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3660 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3661 any(), any(), anyBoolean(), any(Message.class)); 3662 3663 moveTimeForward(2500); 3664 processAllMessages(); 3665 ArgumentCaptor<DataRetryManager.DataSetupRetryEntry> retryEntry = 3666 ArgumentCaptor.forClass(DataRetryManager.DataSetupRetryEntry.class); 3667 verify(mMockedDataRetryManagerCallback, times(1)) 3668 .onDataNetworkSetupRetry(retryEntry.capture()); 3669 3670 ArgumentCaptor<List<ThrottleStatus>> throttleStatusCaptor = 3671 ArgumentCaptor.forClass(List.class); 3672 verify(mMockedDataRetryManagerCallback) 3673 .onThrottleStatusChanged(throttleStatusCaptor.capture()); 3674 3675 assertThat(retryEntry.getValue().dataProfile).isNotNull(); 3676 3677 assertThat(retryEntry.getValue().dataProfile).isEqualTo(mGeneralPurposeDataProfile); 3678 3679 assertThat(mDataProfileManager.isDataProfileCompatible(retryEntry.getValue().dataProfile)) 3680 .isTrue(); 3681 3682 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 2); 3683 3684 mDataNetworkControllerUT 3685 .getDataRetryManager() 3686 .obtainMessage( 3687 6 /* EVENT_DATA_PROFILE_UNTHROTTLED*/, 3688 new AsyncResult( 3689 AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 3690 mGeneralPurposeDataProfile, 3691 null)) 3692 .sendToTarget(); 3693 processAllFutureMessages(); 3694 3695 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 3696 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3697 any(), any(), anyBoolean(), any(Message.class)); 3698 3699 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3700 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 3701 } 3702 3703 @Test testSetupDataNetworkRetryFailed()3704 public void testSetupDataNetworkRetryFailed() { 3705 mDataNetworkControllerUT.getDataRetryManager() 3706 .registerCallback(mMockedDataRetryManagerCallback); 3707 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 3708 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 3709 mDataNetworkControllerUT.addNetworkRequest( 3710 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 3711 processAllMessages(); 3712 3713 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3714 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3715 any(), any(), anyBoolean(), any(Message.class)); 3716 3717 // Process first retry 3718 moveTimeForward(2500); 3719 processAllMessages(); 3720 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 3721 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3722 any(), any(), anyBoolean(), any(Message.class)); 3723 ArgumentCaptor<DataRetryManager.DataSetupRetryEntry> retryEntry = 3724 ArgumentCaptor.forClass(DataRetryManager.DataSetupRetryEntry.class); 3725 verify(mMockedDataRetryManagerCallback, times(1)) 3726 .onDataNetworkSetupRetry(retryEntry.capture()); 3727 assertThat(retryEntry.getValue().getState()).isEqualTo( 3728 DataRetryManager.DataRetryEntry.RETRY_STATE_FAILED); 3729 3730 // Cause data network setup failed due to RADIO_DISABLED_BY_CARRIER 3731 doReturn(false).when(mSST).getPowerStateFromCarrier(); 3732 3733 // Process second retry and ensure data network setup failed 3734 moveTimeForward(3000); 3735 processAllMessages(); 3736 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 3737 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3738 any(), any(), anyBoolean(), any(Message.class)); 3739 verify(mMockedDataRetryManagerCallback, times(2)) 3740 .onDataNetworkSetupRetry(retryEntry.capture()); 3741 assertThat(retryEntry.getValue().getState()).isEqualTo( 3742 DataRetryManager.DataRetryEntry.RETRY_STATE_FAILED); 3743 3744 // Data network setup allowed again 3745 doReturn(true).when(mSST).getPowerStateFromCarrier(); 3746 3747 // Should not retry again after retry failure 3748 processAllFutureMessages(); 3749 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 3750 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3751 any(), any(), anyBoolean(), any(Message.class)); 3752 } 3753 3754 @Test testSetupDataNetworkRetryFailedNetworkRequestRemoved()3755 public void testSetupDataNetworkRetryFailedNetworkRequestRemoved() { 3756 mDataNetworkControllerUT.getDataRetryManager() 3757 .registerCallback(mMockedDataRetryManagerCallback); 3758 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 3759 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 3760 TelephonyNetworkRequest tnr = createNetworkRequest( 3761 NetworkCapabilities.NET_CAPABILITY_INTERNET); 3762 mDataNetworkControllerUT.addNetworkRequest(tnr); 3763 3764 processAllMessages(); 3765 3766 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3767 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3768 any(), any(), anyBoolean(), any(Message.class)); 3769 Mockito.clearInvocations(mMockedWwanDataServiceManager); 3770 3771 logd("Remove internet network request"); 3772 mDataNetworkControllerUT.removeNetworkRequest(tnr); 3773 3774 moveTimeForward(2500); 3775 processAllMessages(); 3776 3777 // There should be no retry since request has been removed. 3778 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 3779 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3780 any(), any(), anyBoolean(), any(Message.class)); 3781 Mockito.clearInvocations(mMockedWwanDataServiceManager); 3782 3783 // Now send another IMS request 3784 tnr = createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS); 3785 mDataNetworkControllerUT.addNetworkRequest(tnr); 3786 processAllMessages(); 3787 3788 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3789 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3790 any(), any(), anyBoolean(), any(Message.class)); 3791 Mockito.clearInvocations(mMockedWwanDataServiceManager); 3792 3793 logd("Remove IMS network request"); 3794 mDataNetworkControllerUT.removeNetworkRequest(tnr); 3795 3796 // There should be no retry since request has been removed. 3797 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 3798 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3799 any(), any(), anyBoolean(), any(Message.class)); 3800 } 3801 3802 @Test testSetupDataNetworkRetryFailedNetworkRequestRemovedAndAdded()3803 public void testSetupDataNetworkRetryFailedNetworkRequestRemovedAndAdded() throws Exception { 3804 mDataNetworkControllerUT.getDataRetryManager() 3805 .registerCallback(mMockedDataRetryManagerCallback); 3806 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 3807 10000, false); 3808 3809 TelephonyNetworkRequest firstTnr = createNetworkRequest( 3810 NetworkCapabilities.NET_CAPABILITY_IMS); 3811 TelephonyNetworkRequest secondTnr = createNetworkRequest( 3812 NetworkCapabilities.NET_CAPABILITY_IMS); 3813 TelephonyNetworkRequest thirdTnr = new TelephonyNetworkRequest( 3814 new NetworkRequest((new NetworkCapabilities.Builder()) 3815 .addCapability(NetworkCapabilities.NET_CAPABILITY_IMS) 3816 .addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE) 3817 .build(), 3818 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 3819 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags); 3820 3821 mDataNetworkControllerUT.addNetworkRequest(firstTnr); 3822 processAllMessages(); 3823 3824 mDataNetworkControllerUT.removeNetworkRequest(firstTnr); 3825 mDataNetworkControllerUT.addNetworkRequest(secondTnr); 3826 mDataNetworkControllerUT.addNetworkRequest(thirdTnr); 3827 processAllFutureMessages(); 3828 3829 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3830 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3831 any(), any(), anyBoolean(), any(Message.class)); 3832 3833 ArgumentCaptor<DataRetryManager.DataSetupRetryEntry> retryEntry = 3834 ArgumentCaptor.forClass(DataRetryManager.DataSetupRetryEntry.class); 3835 verify(mMockedDataRetryManagerCallback, times(1)) 3836 .onDataNetworkSetupRetry(retryEntry.capture()); 3837 assertThat(retryEntry.getValue().getState()).isEqualTo( 3838 DataRetryManager.DataRetryEntry.RETRY_STATE_FAILED); 3839 assertThat(retryEntry.getValue().networkRequestList.size()).isEqualTo(1); 3840 assertThat(retryEntry.getValue().networkRequestList.get(0)).isEqualTo(firstTnr); 3841 3842 DataRetryManager.DataSetupRetryEntry dataSetupRetryEntry = retryEntry.getValue(); 3843 logd("DataSetupRetryEntry:" + dataSetupRetryEntry); 3844 3845 processAllMessages(); 3846 processAllFutureMessages(); 3847 3848 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 1); 3849 logd("Sending TAC_CHANGED event"); 3850 mDataNetworkControllerUT.obtainMessage(25/*EVENT_TAC_CHANGED*/).sendToTarget(); 3851 mDataNetworkControllerUT.getDataRetryManager().obtainMessage(10/*EVENT_TAC_CHANGED*/) 3852 .sendToTarget(); 3853 processAllFutureMessages(); 3854 3855 // TAC changes should clear the already-scheduled retry and throttling. 3856 assertThat(mDataNetworkControllerUT.getDataRetryManager().isDataProfileThrottled( 3857 mImsCellularDataProfile, AccessNetworkConstants.TRANSPORT_TYPE_WWAN)).isFalse(); 3858 3859 // But DNC should re-evaluate unsatisfied request and setup IMS again. 3860 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3861 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3862 3863 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 3864 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3865 any(), any(), anyBoolean(), any(Message.class)); 3866 } 3867 3868 @Test testSetupDataNetworkPermanentFailure()3869 public void testSetupDataNetworkPermanentFailure() { 3870 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.PROTOCOL_ERRORS, 3871 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 3872 mDataNetworkControllerUT.addNetworkRequest( 3873 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 3874 processAllFutureMessages(); 3875 3876 // There should be only one attempt, and no retry should happen because it's a permanent 3877 // failure. 3878 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3879 eq(mGeneralPurposeDataProfile), anyBoolean(), anyBoolean(), anyInt(), any(), 3880 anyInt(), any(), any(), anyBoolean(), any(Message.class)); 3881 3882 Mockito.clearInvocations(mMockedWwanDataServiceManager); 3883 mDataNetworkControllerUT.addNetworkRequest( 3884 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 3885 processAllFutureMessages(); 3886 3887 // Even receiving a new network request, setup data call should not be sent. 3888 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 3889 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3890 any(), any(), anyBoolean(), any(Message.class)); 3891 // APN should be marked as permanent failure. 3892 assertThat(mGeneralPurposeDataProfile.getApnSetting().getPermanentFailed()).isTrue(); 3893 } 3894 3895 @Test testSetupDataNetworkConditionChangesAfterPermanentFailure()3896 public void testSetupDataNetworkConditionChangesAfterPermanentFailure() throws Exception { 3897 testSetupDataNetworkPermanentFailure(); 3898 3899 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 3900 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 1); 3901 3902 // From LTE to NR 3903 serviceStateChanged(TelephonyManager.NETWORK_TYPE_NR, 3904 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 3905 3906 // condition change should trigger setup data, even though previously the APN has been 3907 // marked as permanent failure. 3908 verifyInternetConnected(); 3909 } 3910 3911 @Test testSetupDataNetworkNetworkSuggestedNeverRetry()3912 public void testSetupDataNetworkNetworkSuggestedNeverRetry() { 3913 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.PROTOCOL_ERRORS, 3914 Long.MAX_VALUE, false); 3915 mDataNetworkControllerUT.addNetworkRequest( 3916 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 3917 processAllFutureMessages(); 3918 3919 // There should be only one attempt, and no retry should happen because it's a permanent 3920 // failure. 3921 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3922 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3923 any(), any(), anyBoolean(), any(Message.class)); 3924 } 3925 3926 @Test testSetupDataNetworkNetworkSuggestedRetryTimerDataThrottled()3927 public void testSetupDataNetworkNetworkSuggestedRetryTimerDataThrottled() { 3928 mDataNetworkControllerUT.getDataRetryManager() 3929 .registerCallback(mMockedDataRetryManagerCallback); 3930 3931 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.PROTOCOL_ERRORS, 3932 10000, false); 3933 mDataNetworkControllerUT.addNetworkRequest( 3934 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 3935 processAllMessages(); 3936 3937 mDataNetworkControllerUT.addNetworkRequest( 3938 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 3939 processAllMessages(); 3940 3941 // There should be only one attempt, and no retry should happen because the second one 3942 // was throttled. 3943 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3944 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3945 any(), any(), anyBoolean(), any(Message.class)); 3946 3947 ArgumentCaptor<List<ThrottleStatus>> throttleStatusCaptor = 3948 ArgumentCaptor.forClass(List.class); 3949 verify(mMockedDataRetryManagerCallback) 3950 .onThrottleStatusChanged(throttleStatusCaptor.capture()); 3951 assertThat(throttleStatusCaptor.getValue()).hasSize(1); 3952 ThrottleStatus throttleStatus = throttleStatusCaptor.getValue().get(0); 3953 assertThat(throttleStatus.getApnType()).isEqualTo(ApnSetting.TYPE_IMS); 3954 assertThat(throttleStatus.getRetryType()) 3955 .isEqualTo(ThrottleStatus.RETRY_TYPE_NEW_CONNECTION); 3956 assertThat(throttleStatus.getTransportType()) 3957 .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3958 } 3959 3960 @Test testHandoverDataNetworkNetworkSuggestedRetryTimerDataThrottled()3961 public void testHandoverDataNetworkNetworkSuggestedRetryTimerDataThrottled() throws Exception { 3962 testSetupImsDataNetwork(); 3963 3964 DataNetwork network = getDataNetworks().get(0); 3965 setFailedSetupDataResponse(mMockedWlanDataServiceManager, 3966 DataFailCause.HANDOVER_FAILED, 10000, true); 3967 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3968 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3969 3970 // Verify retry scheduled on this network 3971 assertThat(mDataNetworkControllerUT.getDataRetryManager() 3972 .isAnyHandoverRetryScheduled(network)).isTrue(); 3973 // Verify the data profile is throttled on WLAN 3974 assertThat(mDataNetworkControllerUT.getDataRetryManager().isDataProfileThrottled( 3975 network.getDataProfile(), AccessNetworkConstants.TRANSPORT_TYPE_WLAN)).isTrue(); 3976 3977 // Test even if network disconnected, the throttle status should remain 3978 network.tearDown(DataNetwork.TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 3979 processAllFutureMessages(); 3980 3981 // Verify retry is cleared on this network 3982 assertThat(mDataNetworkControllerUT.getDataRetryManager() 3983 .isAnyHandoverRetryScheduled(network)).isFalse(); 3984 } 3985 3986 @Test testTacChangesClearThrottlingAndRetryHappens()3987 public void testTacChangesClearThrottlingAndRetryHappens() throws Exception { 3988 testSetupDataNetworkNetworkSuggestedRetryTimerDataThrottled(); 3989 processAllFutureMessages(); 3990 3991 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 1); 3992 logd("Sending TAC_CHANGED event"); 3993 mDataNetworkControllerUT.obtainMessage(25/*EVENT_TAC_CHANGED*/).sendToTarget(); 3994 mDataNetworkControllerUT.getDataRetryManager().obtainMessage(10/*EVENT_TAC_CHANGED*/) 3995 .sendToTarget(); 3996 processAllFutureMessages(); 3997 3998 // TAC changes should clear the already-scheduled retry and throttling. 3999 assertThat(mDataNetworkControllerUT.getDataRetryManager().isDataProfileThrottled( 4000 mImsCellularDataProfile, AccessNetworkConstants.TRANSPORT_TYPE_WWAN)).isFalse(); 4001 4002 // But DNC should re-evaluate unsatisfied request and setup IMS again. 4003 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 4004 NetworkCapabilities.NET_CAPABILITY_MMTEL); 4005 } 4006 4007 @Test testNrAdvancedByPco()4008 public void testNrAdvancedByPco() throws Exception { 4009 testSetupDataNetwork(); 4010 verify(mMockedDataNetworkControllerCallback, never()) 4011 .onNrAdvancedCapableByPcoChanged(anyBoolean()); 4012 mSimulatedCommands.triggerPcoData(1, "IPV6", 1234, new byte[]{1}); 4013 processAllMessages(); 4014 verify(mMockedDataNetworkControllerCallback).onNrAdvancedCapableByPcoChanged(eq(true)); 4015 4016 mSimulatedCommands.triggerPcoData(1, "IPV6", 1234, new byte[]{0}); 4017 processAllMessages(); 4018 verify(mMockedDataNetworkControllerCallback).onNrAdvancedCapableByPcoChanged(eq(false)); 4019 } 4020 4021 @Test testNrAdvancedByEarlyPco()4022 public void testNrAdvancedByEarlyPco() { 4023 Mockito.reset(mMockedWwanDataServiceManager); 4024 mDataNetworkControllerUT.addNetworkRequest( 4025 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 4026 processAllMessages(); 4027 4028 // PCO data arrives before data network entering connected state. 4029 mSimulatedCommands.triggerPcoData(1, "IPV6", 1234, new byte[]{1}); 4030 processAllMessages(); 4031 4032 ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class); 4033 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 4034 anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 4035 messageCaptor.capture()); 4036 4037 // Send setup data call complete message. 4038 Message msg = messageCaptor.getValue(); 4039 msg.getData().putParcelable("data_call_response", 4040 createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE)); 4041 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 4042 msg.sendToTarget(); 4043 processAllMessages(); 4044 4045 verify(mMockedDataNetworkControllerCallback).onNrAdvancedCapableByPcoChanged(eq(true)); 4046 4047 // Deactivate the data, verify notify PCO gone. 4048 mDataNetworkControllerUT.tearDownAllDataNetworks( 4049 DataNetwork.TEAR_DOWN_REASON_AIRPLANE_MODE_ON); 4050 processAllFutureMessages(); 4051 4052 verify(mMockedDataNetworkControllerCallback).onNrAdvancedCapableByPcoChanged(eq(false)); 4053 } 4054 4055 @Test testNrAdvancedByPcoMultipleNetworks()4056 public void testNrAdvancedByPcoMultipleNetworks() throws Exception { 4057 testSetupDataNetwork(); 4058 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 4059 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 4060 testSetupImsDataNetwork(); 4061 4062 verify(mMockedDataNetworkControllerCallback, never()) 4063 .onNrAdvancedCapableByPcoChanged(anyBoolean()); 4064 mSimulatedCommands.triggerPcoData(2, "IPV6", 1234, new byte[]{1}); 4065 processAllMessages(); 4066 verify(mMockedDataNetworkControllerCallback).onNrAdvancedCapableByPcoChanged(eq(true)); 4067 } 4068 4069 @Test testNrAdvancedByEarlyUnrelatedPco()4070 public void testNrAdvancedByEarlyUnrelatedPco() { 4071 Mockito.reset(mMockedWwanDataServiceManager); 4072 mDataNetworkControllerUT.addNetworkRequest( 4073 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 4074 processAllMessages(); 4075 4076 // Unrelated PCO data arrives before data network entering connected state. 4077 mSimulatedCommands.triggerPcoData(2, "IPV6", 1234, new byte[]{1}); 4078 processAllMessages(); 4079 4080 ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class); 4081 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 4082 anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 4083 messageCaptor.capture()); 4084 4085 // Send setup data call complete message. 4086 Message msg = messageCaptor.getValue(); 4087 msg.getData().putParcelable("data_call_response", 4088 createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE)); 4089 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 4090 msg.sendToTarget(); 4091 processAllMessages(); 4092 4093 verify(mMockedDataNetworkControllerCallback, never()).onNrAdvancedCapableByPcoChanged( 4094 anyBoolean()); 4095 } 4096 4097 4098 @Test testSetupDataNetworkVcnManaged()4099 public void testSetupDataNetworkVcnManaged() throws Exception { 4100 // VCN managed 4101 setVcnManagerPolicy(true, false); 4102 NetworkRequest request = new NetworkRequest.Builder() 4103 .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) 4104 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED) 4105 .build(); 4106 TelephonyNetworkRequest tnr = new TelephonyNetworkRequest(request, mPhone, mFeatureFlags); 4107 4108 mDataNetworkControllerUT.addNetworkRequest(tnr); 4109 processAllMessages(); 4110 4111 verify(mMockedDataNetworkControllerCallback) 4112 .onConnectedInternetDataNetworksChanged(any()); 4113 List<DataNetwork> dataNetworks = getDataNetworks(); 4114 assertThat(dataNetworks).hasSize(1); 4115 assertThat(dataNetworks.get(0).getNetworkCapabilities().hasCapability( 4116 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)).isFalse(); 4117 assertThat(dataNetworks.get(0).isInternetSupported()).isTrue(); 4118 assertThat(dataNetworks.get(0).getNetworkCapabilities().hasCapability( 4119 NetworkCapabilities.NET_CAPABILITY_INTERNET)).isTrue(); 4120 } 4121 4122 @Test testSetupDataNetworkVcnRequestedTeardown()4123 public void testSetupDataNetworkVcnRequestedTeardown() throws Exception { 4124 // VCN managed, tear down on setup. 4125 setVcnManagerPolicy(true, true); 4126 NetworkRequest request = new NetworkRequest.Builder() 4127 .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) 4128 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED) 4129 .build(); 4130 TelephonyNetworkRequest tnr = new TelephonyNetworkRequest(request, mPhone, mFeatureFlags); 4131 4132 mDataNetworkControllerUT.addNetworkRequest(tnr); 4133 processAllMessages(); 4134 4135 // Should not be any data network created. 4136 List<DataNetwork> dataNetworks = getDataNetworks(); 4137 assertThat(dataNetworks).hasSize(0); 4138 } 4139 4140 @Test testVcnManagedNetworkPolicyChanged()4141 public void testVcnManagedNetworkPolicyChanged() throws Exception { 4142 testSetupDataNetworkVcnManaged(); 4143 4144 setVcnManagerPolicy(true, true); 4145 ArgumentCaptor<VcnNetworkPolicyChangeListener> listenerCaptor = 4146 ArgumentCaptor.forClass(VcnNetworkPolicyChangeListener.class); 4147 verify(mVcnManager).addVcnNetworkPolicyChangeListener(any(Executor.class), 4148 listenerCaptor.capture()); 4149 4150 // Trigger policy changed event 4151 VcnNetworkPolicyChangeListener listener = listenerCaptor.getValue(); 4152 listener.onPolicyChanged(); 4153 processAllMessages(); 4154 4155 List<DataNetwork> dataNetworks = getDataNetworks(); 4156 assertThat(dataNetworks).hasSize(0); 4157 } 4158 4159 @Test testDataDisableNotTearingDownUnmetered()4160 public void testDataDisableNotTearingDownUnmetered() throws Exception { 4161 // User data enabled 4162 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4163 TelephonyManager.DATA_ENABLED_REASON_USER, true, mContext.getOpPackageName()); 4164 processAllMessages(); 4165 4166 testSetupImsDataNetwork(); 4167 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 4168 4169 // User data disabled 4170 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4171 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 4172 processAllMessages(); 4173 4174 // There shouldn't be all data disconnected event. 4175 verify(mMockedDataNetworkControllerCallback, never()) 4176 .onAnyDataNetworkExistingChanged(anyBoolean()); 4177 4178 // Verify IMS is still alive. 4179 List<DataNetwork> dataNetworkList = getDataNetworks(); 4180 assertThat(dataNetworkList).hasSize(1); 4181 assertThat(dataNetworkList.get(0).getNetworkCapabilities() 4182 .hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)).isTrue(); 4183 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 4184 } 4185 4186 @Test testDataDisableTearingDownTetheringNetwork()4187 public void testDataDisableTearingDownTetheringNetwork() throws Exception { 4188 // User data enabled 4189 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4190 TelephonyManager.DATA_ENABLED_REASON_USER, true, mContext.getOpPackageName()); 4191 processAllMessages(); 4192 4193 // Request the restricted tethering network. 4194 NetworkCapabilities netCaps = new NetworkCapabilities(); 4195 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_DUN); 4196 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 4197 4198 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 4199 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 4200 4201 mDataNetworkControllerUT.addNetworkRequest( 4202 new TelephonyNetworkRequest(nativeNetworkRequest, mPhone, mFeatureFlags)); 4203 processAllMessages(); 4204 4205 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_DUN); 4206 4207 // User data disabled 4208 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4209 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 4210 processAllMessages(); 4211 4212 // Everything should be disconnected. 4213 verifyAllDataDisconnected(); 4214 } 4215 4216 @Test testDataDisableTearingDownEnterpriseNetwork()4217 public void testDataDisableTearingDownEnterpriseNetwork() throws Exception { 4218 // User data enabled 4219 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4220 TelephonyManager.DATA_ENABLED_REASON_USER, true, mContext.getOpPackageName()); 4221 processAllMessages(); 4222 4223 // Request the restricted enterprise network. 4224 testSetupEnterpriseDataNetwork(); 4225 4226 // User data disabled 4227 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4228 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 4229 processAllMessages(); 4230 4231 // Everything should be disconnected. 4232 verifyAllDataDisconnected(); 4233 } 4234 4235 @Test testSetPreferredDataProfileMultiInternetDataProfile()4236 public void testSetPreferredDataProfileMultiInternetDataProfile() throws Exception { 4237 // No preferred data profile in the beginning 4238 doReturn(false).when(mDataProfileManager).canPreferredDataProfileSatisfy( 4239 any(NetworkRequestList.class)); 4240 4241 testSetupDataNetwork(); 4242 4243 // Verify this network still alive after evaluation 4244 mDataNetworkControllerUT.obtainMessage(EVENT_REEVALUATE_EXISTING_DATA_NETWORKS) 4245 .sendToTarget(); 4246 processAllMessages(); 4247 4248 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 4249 4250 // Network connected, became preferred data profile 4251 doAnswer(invocation -> { 4252 NetworkRequestList networkRequests = 4253 (NetworkRequestList) invocation.getArguments()[0]; 4254 return networkRequests.stream() 4255 .allMatch(request -> request.canBeSatisfiedBy(mGeneralPurposeDataProfile)); 4256 }).when(mDataProfileManager).canPreferredDataProfileSatisfy( 4257 any(NetworkRequestList.class)); 4258 doReturn(true).when(mDataProfileManager) 4259 .isDataProfilePreferred(mGeneralPurposeDataProfile); 4260 4261 // 1. Test DUN | DEFAULT data profile is compatible with preferred default internet 4262 mDataNetworkControllerUT.addNetworkRequest( 4263 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_DUN)); 4264 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 2); 4265 processAllMessages(); 4266 4267 // Verify both DUN and preferred default network are alive 4268 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 4269 verifyConnectedNetworkHasDataProfile(mTetheringDataProfile); 4270 4271 // Verify this network still alive after evaluation 4272 mDataNetworkControllerUT.obtainMessage(EVENT_REEVALUATE_EXISTING_DATA_NETWORKS) 4273 .sendToTarget(); 4274 processAllMessages(); 4275 4276 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 4277 verifyConnectedNetworkHasDataProfile(mTetheringDataProfile); 4278 4279 // 2. Test tear down when user changes preferred data profile 4280 doAnswer(invocation -> { 4281 NetworkRequestList networkRequests = 4282 (NetworkRequestList) invocation.getArguments()[0]; 4283 return networkRequests.stream() 4284 .allMatch(request -> request.canBeSatisfiedBy( 4285 mGeneralPurposeDataProfileAlternative)); 4286 }).when(mDataProfileManager).canPreferredDataProfileSatisfy( 4287 any(NetworkRequestList.class)); 4288 doReturn(true).when(mDataProfileManager) 4289 .isDataProfilePreferred(mGeneralPurposeDataProfileAlternative); 4290 doReturn(false).when(mDataProfileManager) 4291 .isDataProfilePreferred(mGeneralPurposeDataProfile); 4292 4293 mDataNetworkControllerUT.obtainMessage(EVENT_REEVALUATE_EXISTING_DATA_NETWORKS) 4294 .sendToTarget(); 4295 processAllMessages(); 4296 4297 List<DataNetwork> dataNetworks = getDataNetworks(); 4298 assertThat(dataNetworks).hasSize(1); 4299 verifyConnectedNetworkHasDataProfile(mTetheringDataProfile); 4300 } 4301 4302 @Test testDataDisableNotAllowingBringingUpTetheringNetwork()4303 public void testDataDisableNotAllowingBringingUpTetheringNetwork() throws Exception { 4304 // User data disabled 4305 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4306 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 4307 processAllMessages(); 4308 4309 // Request the restricted tethering network. 4310 NetworkCapabilities netCaps = new NetworkCapabilities(); 4311 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_DUN); 4312 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 4313 4314 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 4315 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 4316 4317 mDataNetworkControllerUT.addNetworkRequest( 4318 new TelephonyNetworkRequest(nativeNetworkRequest, mPhone, mFeatureFlags)); 4319 processAllMessages(); 4320 4321 // Everything should be disconnected. 4322 verifyAllDataDisconnected(); 4323 4324 // Telephony should not try to setup a data call for DUN. 4325 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 4326 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 4327 any(), any(), anyBoolean(), any(Message.class)); 4328 } 4329 4330 @Test testDataDisableNotAllowingBringingUpEnterpriseNetwork()4331 public void testDataDisableNotAllowingBringingUpEnterpriseNetwork() throws Exception { 4332 // User data disabled 4333 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4334 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 4335 processAllMessages(); 4336 4337 // Request the restricted tethering network. 4338 List<TrafficDescriptor> tdList = new ArrayList<>(); 4339 tdList.add(new TrafficDescriptor.Builder() 4340 .setOsAppId(new OsAppId(OsAppId.ANDROID_OS_ID, "ENTERPRISE", 1).getBytes()) 4341 .build()); 4342 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 4343 createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE, tdList)); 4344 doReturn(mEnterpriseDataProfile).when(mDataProfileManager) 4345 .getDataProfileForNetworkRequest(any(TelephonyNetworkRequest.class), anyInt(), 4346 anyBoolean(), anyBoolean(), anyBoolean()); 4347 4348 NetworkCapabilities netCaps = new NetworkCapabilities(); 4349 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE); 4350 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 4351 4352 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 4353 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 4354 4355 mDataNetworkControllerUT.addNetworkRequest( 4356 new TelephonyNetworkRequest(nativeNetworkRequest, mPhone, mFeatureFlags)); 4357 processAllMessages(); 4358 4359 // Everything should be disconnected. 4360 verifyAllDataDisconnected(); 4361 4362 // Telephony should not try to setup a data call for Enterprise. 4363 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 4364 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 4365 any(), any(), anyBoolean(), any(Message.class)); 4366 } 4367 @Test testNonVoPSNoIMSSetup()4368 public void testNonVoPSNoIMSSetup() throws Exception { 4369 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo.Builder(8) 4370 .setNrAvailable(true) 4371 .setEnDcAvailable(true) 4372 .setVopsSupportInfo(new LteVopsSupportInfo( 4373 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 4374 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)) 4375 .build(); 4376 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4377 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 4378 4379 mDataNetworkControllerUT.addNetworkRequest( 4380 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 4381 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 4382 processAllMessages(); 4383 4384 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 4385 verifyAllDataDisconnected(); 4386 } 4387 4388 @Test testNonVoPStoVoPSImsSetup()4389 public void testNonVoPStoVoPSImsSetup() throws Exception { 4390 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(true); 4391 // Config that allows non-vops bring up when Roaming 4392 mCarrierConfig.putIntArray(CarrierConfigManager.Ims 4393 .KEY_IMS_PDN_ENABLED_IN_NO_VOPS_SUPPORT_INT_ARRAY, new int[] 4394 {CarrierConfigManager.Ims.NETWORK_TYPE_ROAMING}); 4395 carrierConfigChanged(); 4396 4397 // VOPS not supported 4398 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo.Builder(8) 4399 .setNrAvailable(true) 4400 .setEnDcAvailable(true) 4401 .setVopsSupportInfo(new LteVopsSupportInfo( 4402 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 4403 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)) 4404 .build(); 4405 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4406 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 4407 4408 mDataNetworkControllerUT.addNetworkRequest( 4409 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 4410 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 4411 processAllMessages(); 4412 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 4413 4414 // Verify bring up in Home is not allowed. 4415 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4416 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 4417 processAllMessages(); 4418 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 4419 4420 // Verify bring up in Roaming is allowed. 4421 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4422 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING, dsri); 4423 processAllMessages(); 4424 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 4425 NetworkCapabilities.NET_CAPABILITY_MMTEL); 4426 4427 // Verify the roaming network survives network re-evaluation. 4428 mDataNetworkControllerUT.obtainMessage(EVENT_REEVALUATE_EXISTING_DATA_NETWORKS) 4429 .sendToTarget(); 4430 processAllMessages(); 4431 4432 // Service state changed to Home, non-vops area is no longer allowed 4433 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4434 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 4435 processAllMessages(); 4436 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 4437 4438 // VoPS supported 4439 dsri = new DataSpecificRegistrationInfo.Builder(8) 4440 .setNrAvailable(true) 4441 .setEnDcAvailable(true) 4442 .setVopsSupportInfo(new LteVopsSupportInfo( 4443 LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 4444 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)) 4445 .build(); 4446 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4447 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 4448 4449 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 4450 NetworkCapabilities.NET_CAPABILITY_MMTEL); 4451 } 4452 4453 @Test testDelayImsTearDownCsRequestsToTearDown()4454 public void testDelayImsTearDownCsRequestsToTearDown() throws Exception { 4455 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL, 4456 true); 4457 TelephonyNetworkRequest networkRequest = createNetworkRequest( 4458 NetworkCapabilities.NET_CAPABILITY_IMS); 4459 mDataNetworkControllerUT.addNetworkRequest(networkRequest); 4460 processAllMessages(); 4461 4462 // Call is ongoing 4463 doReturn(PhoneConstants.State.OFFHOOK).when(mCT).getState(); 4464 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 4465 NetworkCapabilities.NET_CAPABILITY_MMTEL); 4466 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 4467 List<DataNetwork> dataNetworks = getDataNetworks(); 4468 assertThat(dataNetworks).hasSize(1); 4469 dataNetworks.get(0).tearDown(DataNetwork.TEAR_DOWN_REASON_RAT_NOT_ALLOWED); 4470 processAllMessages(); 4471 4472 // Make sure IMS network is still connected. 4473 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 4474 NetworkCapabilities.NET_CAPABILITY_MMTEL); 4475 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 4476 4477 // Now connectivity service requests to tear down the data network. 4478 mDataNetworkControllerUT.removeNetworkRequest(networkRequest); 4479 dataNetworks.get(0).tearDown(DataNetwork.TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 4480 processAllMessages(); 4481 4482 // All data (including IMS) should be torn down. 4483 verifyAllDataDisconnected(); 4484 } 4485 4486 @Test testDelayImsTearDownDuringSrvcc()4487 public void testDelayImsTearDownDuringSrvcc() throws Exception { 4488 testSetupImsDataNetwork(); 4489 // SRVCC in progress, delay tear down 4490 mDataNetworkControllerUT.obtainMessage(4 /*EVENT_SRVCC_STATE_CHANGED*/, 4491 new AsyncResult(null, 4492 new int[]{TelephonyManager.SRVCC_STATE_HANDOVER_STARTED}, null)) 4493 .sendToTarget(); 4494 serviceStateChanged(TelephonyManager.NETWORK_TYPE_HSPAP, 4495 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 4496 processAllMessages(); 4497 4498 // Make sure IMS network is still connected. 4499 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 4500 NetworkCapabilities.NET_CAPABILITY_MMTEL); 4501 4502 // SRVCC handover ends, tear down as normal 4503 mDataNetworkControllerUT.obtainMessage(4 /*EVENT_SRVCC_STATE_CHANGED*/, 4504 new AsyncResult(null, 4505 new int[]{TelephonyManager.SRVCC_STATE_HANDOVER_CANCELED}, null)) 4506 .sendToTarget(); 4507 processAllFutureMessages(); 4508 4509 // Make sure IMS network is torn down 4510 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL); 4511 } 4512 4513 @Test testUnmeteredMmsWhenDataDisabled()4514 public void testUnmeteredMmsWhenDataDisabled() throws Exception { 4515 mCarrierConfig.putStringArray( 4516 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 4517 new String[]{"default", "dun", "supl"}); 4518 carrierConfigChanged(); 4519 4520 // User data disabled 4521 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4522 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 4523 processAllMessages(); 4524 4525 mDataNetworkControllerUT.addNetworkRequest( 4526 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 4527 processAllMessages(); 4528 4529 // Make sure MMS is the only capability advertised, but not internet or SUPL. 4530 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 4531 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 4532 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 4533 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL); 4534 } 4535 4536 @Test testUnmeteredMmsWhenRoamingDisabled()4537 public void testUnmeteredMmsWhenRoamingDisabled() throws Exception { 4538 mCarrierConfig.putStringArray( 4539 CarrierConfigManager.KEY_CARRIER_METERED_ROAMING_APN_TYPES_STRINGS, 4540 new String[]{"default", "dun", "supl"}); 4541 carrierConfigChanged(); 4542 4543 // Roaming data disabled 4544 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 4545 processAllMessages(); 4546 4547 // Device is roaming 4548 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4549 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 4550 4551 mDataNetworkControllerUT.addNetworkRequest( 4552 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 4553 processAllMessages(); 4554 4555 // Make sure MMS is the only capability advertised, but not internet or SUPL. 4556 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 4557 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 4558 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 4559 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL); 4560 } 4561 4562 @Test testRestrictedNetworkRequestDataDisabled()4563 public void testRestrictedNetworkRequestDataDisabled() throws Exception { 4564 // User data disabled 4565 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4566 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 4567 processAllMessages(); 4568 4569 // Create a restricted network request. 4570 NetworkCapabilities netCaps = new NetworkCapabilities(); 4571 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 4572 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 4573 4574 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 4575 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 4576 4577 mDataNetworkControllerUT.addNetworkRequest( 4578 new TelephonyNetworkRequest(nativeNetworkRequest, mPhone, mFeatureFlags)); 4579 processAllMessages(); 4580 4581 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 4582 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET, 4583 NetworkCapabilities.NET_CAPABILITY_SUPL, NetworkCapabilities.NET_CAPABILITY_MMS); 4584 4585 List<DataNetwork> dataNetworks = getDataNetworks(); 4586 // Make sure the network is restricted. 4587 assertThat(dataNetworks.get(0).getNetworkCapabilities() 4588 .hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)).isFalse(); 4589 } 4590 4591 @Test testRestrictedNetworkRequestDataEnabled()4592 public void testRestrictedNetworkRequestDataEnabled() throws Exception { 4593 // Create a restricted network request. 4594 NetworkCapabilities netCaps = new NetworkCapabilities(); 4595 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 4596 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 4597 4598 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 4599 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 4600 4601 mDataNetworkControllerUT.addNetworkRequest( 4602 new TelephonyNetworkRequest(nativeNetworkRequest, mPhone, mFeatureFlags)); 4603 processAllMessages(); 4604 4605 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 4606 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET, 4607 NetworkCapabilities.NET_CAPABILITY_SUPL, NetworkCapabilities.NET_CAPABILITY_MMS, 4608 // Because data is enabled, even though the network request is restricted, the 4609 // network should still be not-restricted. 4610 NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 4611 } 4612 4613 @Test testSinglePdnArbitration()4614 public void testSinglePdnArbitration() throws Exception { 4615 // On old 1x network, only one data network is allowed. 4616 serviceStateChanged(TelephonyManager.NETWORK_TYPE_1xRTT, 4617 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 4618 4619 mDataNetworkControllerUT.addNetworkRequest( 4620 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_DUN)); 4621 processAllMessages(); 4622 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_DUN); 4623 4624 mDataNetworkControllerUT.addNetworkRequest( 4625 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 4626 processAllFutureMessages(); 4627 // Lower priority network should not trump the higher priority network. 4628 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_DUN); 4629 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE); 4630 4631 // Now send a higher priority network request 4632 TelephonyNetworkRequest fotaRequest = createNetworkRequest( 4633 NetworkCapabilities.NET_CAPABILITY_FOTA); 4634 mDataNetworkControllerUT.addNetworkRequest(fotaRequest); 4635 4636 processAllFutureMessages(); 4637 // The existing internet data network should be torn down. 4638 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_DUN); 4639 // The higher priority emergency data network should be established. 4640 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_FOTA); 4641 4642 // Now remove the fota request and tear down fota network. 4643 mDataNetworkControllerUT.removeNetworkRequest(fotaRequest); 4644 processAllMessages(); 4645 List<DataNetwork> dataNetworks = getDataNetworks(); 4646 dataNetworks.get(0).tearDown(DataNetwork.TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 4647 processAllMessages(); 4648 4649 // The tethering data network should come back since now it has the highest priority after 4650 // fota is gone. 4651 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_DUN); 4652 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA); 4653 } 4654 4655 @Test testNetworkValidationStatusChangeCallback()4656 public void testNetworkValidationStatusChangeCallback() throws Exception { 4657 // Request not restricted network 4658 TelephonyNetworkRequest request = createNetworkRequest( 4659 NetworkCapabilities.NET_CAPABILITY_INTERNET); 4660 mDataNetworkControllerUT.addNetworkRequest(request); 4661 processAllMessages(); 4662 TelephonyNetworkAgent agent = getPrivateField(getDataNetworks().get(0), "mNetworkAgent", 4663 TelephonyNetworkAgent.class); 4664 agent.onValidationStatus(1/*status*/, Uri.EMPTY); 4665 processAllMessages(); 4666 4667 // Verify notify 4668 verify(mMockedDataNetworkControllerCallback) 4669 .onInternetDataNetworkValidationStatusChanged(1); 4670 4671 // Request restricted network 4672 mDataNetworkControllerUT.removeNetworkRequest(request); 4673 getDataNetworks().get(0).tearDown(DataNetwork.TEAR_DOWN_REASON_NONE); 4674 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled(0, false, ""); 4675 processAllMessages(); 4676 clearInvocations(mMockedDataNetworkControllerCallback); 4677 mDataNetworkControllerUT.addNetworkRequest(createNetworkRequest( 4678 true, NetworkCapabilities.NET_CAPABILITY_INTERNET)); 4679 processAllMessages(); 4680 agent = getPrivateField(getDataNetworks().get(0), "mNetworkAgent", 4681 TelephonyNetworkAgent.class); 4682 agent.onValidationStatus(1/*status*/, Uri.EMPTY); 4683 processAllMessages(); 4684 4685 // Verify not notified 4686 verify(mMockedDataNetworkControllerCallback, never()) 4687 .onInternetDataNetworkValidationStatusChanged(anyInt()); 4688 } 4689 4690 @Test testImsGracefulTearDown()4691 public void testImsGracefulTearDown() throws Exception { 4692 setImsRegistered(true); 4693 setRcsRegistered(true); 4694 4695 NetworkCapabilities netCaps = new NetworkCapabilities(); 4696 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 4697 netCaps.maybeMarkCapabilitiesRestricted(); 4698 netCaps.setRequestorPackageName(FAKE_MMTEL_PACKAGE); 4699 4700 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 4701 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 4702 TelephonyNetworkRequest networkRequest = new TelephonyNetworkRequest( 4703 nativeNetworkRequest, mPhone, mFeatureFlags); 4704 4705 mDataNetworkControllerUT.addNetworkRequest(networkRequest); 4706 4707 processAllMessages(); 4708 Mockito.clearInvocations(mPhone); 4709 4710 // SIM removal 4711 mDataNetworkControllerUT.obtainMessage(9/*EVENT_SIM_STATE_CHANGED*/, 4712 TelephonyManager.SIM_STATE_ABSENT, 0).sendToTarget(); 4713 processAllMessages(); 4714 4715 // Make sure data network enters disconnecting state 4716 ArgumentCaptor<PreciseDataConnectionState> pdcsCaptor = 4717 ArgumentCaptor.forClass(PreciseDataConnectionState.class); 4718 verify(mPhone).notifyDataConnection(pdcsCaptor.capture()); 4719 PreciseDataConnectionState pdcs = pdcsCaptor.getValue(); 4720 assertThat(pdcs.getState()).isEqualTo(TelephonyManager.DATA_DISCONNECTING); 4721 4722 // IMS de-registered. Now data network is safe to be torn down. 4723 Mockito.clearInvocations(mPhone); 4724 setImsRegistered(false); 4725 setRcsRegistered(false); 4726 processAllMessages(); 4727 4728 // All data should be disconnected. 4729 verifyAllDataDisconnected(); 4730 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 4731 verify(mPhone).notifyDataConnection(pdcsCaptor.capture()); 4732 pdcs = pdcsCaptor.getValue(); 4733 assertThat(pdcs.getState()).isEqualTo(TelephonyManager.DATA_DISCONNECTED); 4734 } 4735 4736 @Test testNoGracefulTearDownForEmergencyDataNetwork()4737 public void testNoGracefulTearDownForEmergencyDataNetwork() throws Exception { 4738 setImsRegistered(true); 4739 4740 mCarrierConfig.putStringArray(CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 4741 new String[]{"source=EUTRAN, target=IWLAN, type=disallowed, capabilities=EIMS|IMS", 4742 "source=IWLAN, target=EUTRAN, type=disallowed, capabilities=MMS"}); 4743 // Force data config manager to reload the carrier config. 4744 carrierConfigChanged(); 4745 processAllMessages(); 4746 4747 // setup emergency data network. 4748 NetworkCapabilities netCaps = new NetworkCapabilities(); 4749 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_EIMS); 4750 netCaps.maybeMarkCapabilitiesRestricted(); 4751 netCaps.setRequestorPackageName(FAKE_MMTEL_PACKAGE); 4752 4753 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 4754 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 4755 TelephonyNetworkRequest networkRequest = new TelephonyNetworkRequest( 4756 nativeNetworkRequest, mPhone, mFeatureFlags); 4757 4758 mDataNetworkControllerUT.addNetworkRequest(networkRequest); 4759 processAllMessages(); 4760 4761 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_EIMS); 4762 4763 updateTransport(NetworkCapabilities.NET_CAPABILITY_EIMS, 4764 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 4765 4766 // Verify all data disconnected. 4767 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 4768 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 4769 eq(DataCallResponse.LINK_STATUS_INACTIVE)); 4770 4771 // A new data network should be connected on IWLAN 4772 List<DataNetwork> dataNetworkList = getDataNetworks(); 4773 assertThat(dataNetworkList).hasSize(1); 4774 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 4775 assertThat(dataNetworkList.get(0).getNetworkCapabilities().hasCapability( 4776 NetworkCapabilities.NET_CAPABILITY_EIMS)).isTrue(); 4777 assertThat(dataNetworkList.get(0).getTransport()) 4778 .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 4779 } 4780 4781 @Test testNetworkRequestRemovedBeforeRetry()4782 public void testNetworkRequestRemovedBeforeRetry() { 4783 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 4784 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 4785 TelephonyNetworkRequest networkRequest = createNetworkRequest( 4786 NetworkCapabilities.NET_CAPABILITY_INTERNET); 4787 mDataNetworkControllerUT.addNetworkRequest(networkRequest); 4788 logd("Removing network request."); 4789 mDataNetworkControllerUT.removeNetworkRequest(networkRequest); 4790 processAllMessages(); 4791 4792 // There should be only one invocation, which is the original setup data request. There 4793 // shouldn't be more than 1 (i.e. should not retry). 4794 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 4795 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 4796 any(), any(), anyBoolean(), any(Message.class)); 4797 } 4798 4799 @Test testGetInternetDataDisallowedReasons()4800 public void testGetInternetDataDisallowedReasons() { 4801 List<DataDisallowedReason> reasons = mDataNetworkControllerUT 4802 .getInternetDataDisallowedReasons(); 4803 assertThat(reasons).isEmpty(); 4804 4805 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 4806 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 4807 4808 reasons = mDataNetworkControllerUT.getInternetDataDisallowedReasons(); 4809 assertThat(reasons).containsExactly(DataDisallowedReason.NOT_IN_SERVICE, 4810 DataDisallowedReason.NO_SUITABLE_DATA_PROFILE); 4811 } 4812 4813 @Test testEmergencySuplDataDisabled()4814 public void testEmergencySuplDataDisabled() throws Exception { 4815 // Data disabled 4816 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4817 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 4818 processAllMessages(); 4819 doReturn(true).when(mTelecomManager).isInEmergencyCall(); 4820 mDataNetworkControllerUT.addNetworkRequest( 4821 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_SUPL)); 4822 processAllMessages(); 4823 4824 // Make sure SUPL is the only capability advertised, but not internet or MMS. 4825 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_SUPL); 4826 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 4827 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 4828 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 4829 } 4830 4831 @Test testEmergencyCallDataDisabled()4832 public void testEmergencyCallDataDisabled() throws Exception { 4833 doReturn(true).when(mTelecomManager).isInEmergencyCall(); 4834 mDataNetworkControllerUT.addNetworkRequest( 4835 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 4836 processAllMessages(); 4837 4838 verifyInternetConnected(); 4839 4840 // Data disabled 4841 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 4842 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 4843 processAllMessages(); 4844 4845 // Make sure internet is not connected. (Previously it has a bug due to incorrect logic 4846 // to determine it's for emergency SUPL). 4847 verifyAllDataDisconnected(); 4848 } 4849 4850 @Test testDataActivity()4851 public void testDataActivity() { 4852 doReturn(TelephonyManager.DATA_ACTIVITY_IN).when(mLinkBandwidthEstimator).getDataActivity(); 4853 mLinkBandwidthEstimatorCallback.onDataActivityChanged(TelephonyManager.DATA_ACTIVITY_IN); 4854 processAllMessages(); 4855 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 4856 TelephonyManager.DATA_ACTIVITY_IN); 4857 4858 doReturn(TelephonyManager.DATA_ACTIVITY_OUT).when(mLinkBandwidthEstimator) 4859 .getDataActivity(); 4860 mLinkBandwidthEstimatorCallback.onDataActivityChanged(TelephonyManager.DATA_ACTIVITY_OUT); 4861 processAllMessages(); 4862 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 4863 TelephonyManager.DATA_ACTIVITY_OUT); 4864 4865 doReturn(TelephonyManager.DATA_ACTIVITY_INOUT).when(mLinkBandwidthEstimator) 4866 .getDataActivity(); 4867 mLinkBandwidthEstimatorCallback.onDataActivityChanged(TelephonyManager.DATA_ACTIVITY_INOUT); 4868 processAllMessages(); 4869 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 4870 TelephonyManager.DATA_ACTIVITY_INOUT); 4871 4872 doReturn(TelephonyManager.DATA_ACTIVITY_NONE).when(mLinkBandwidthEstimator) 4873 .getDataActivity(); 4874 mLinkBandwidthEstimatorCallback.onDataActivityChanged(TelephonyManager.DATA_ACTIVITY_NONE); 4875 processAllMessages(); 4876 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 4877 TelephonyManager.DATA_ACTIVITY_NONE); 4878 } 4879 4880 @Test testHandoverDataNetworkOos()4881 public void testHandoverDataNetworkOos() throws Exception { 4882 // Config delay IMS tear down enabled 4883 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL, 4884 true); 4885 carrierConfigChanged(); 4886 4887 // VoPS supported 4888 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo.Builder(8) 4889 .setNrAvailable(true) 4890 .setEnDcAvailable(true) 4891 .setVopsSupportInfo(new LteVopsSupportInfo( 4892 LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 4893 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)) 4894 .build(); 4895 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4896 NetworkRegistrationInfo.REGISTRATION_STATE_HOME /*data*/, 4897 NetworkRegistrationInfo.REGISTRATION_STATE_HOME /*voice*/, 4898 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING /*iwlan*/, 4899 dsri); 4900 4901 testSetupImsDataNetwork(); 4902 DataNetwork dataNetwork = getDataNetworks().get(0); 4903 4904 // 1. Active VoPS call, mock target IWLAN OOS, should schedule retry 4905 doReturn(PhoneConstants.State.RINGING).when(mCT).getState(); 4906 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 4907 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 4908 // Process DRM event to schedule retry 4909 processAllMessages(); 4910 4911 // Verify scheduled new handover retry 4912 assertTrue(mDataNetworkControllerUT.getDataRetryManager() 4913 .isAnyHandoverRetryScheduled(dataNetwork)); 4914 // Verify the network wasn't torn down 4915 verify(mMockedWwanDataServiceManager, never()).deactivateDataCall(anyInt(), 4916 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 4917 4918 // Get the scheduled retry 4919 Field field = DataRetryManager.class.getDeclaredField("mDataRetryEntries"); 4920 field.setAccessible(true); 4921 DataRetryManager.DataHandoverRetryEntry dataRetryEntry = 4922 (DataRetryManager.DataHandoverRetryEntry) ((List<DataRetryManager.DataRetryEntry>) 4923 field.get(mDataNetworkControllerUT.getDataRetryManager())).get(0); 4924 4925 // Process the retry 4926 moveTimeForward(1000 /*The retry delay of the first attempt*/); 4927 processAllMessages(); 4928 4929 // Verify the previous retry is set to FAILED 4930 assertEquals(DataRetryManager.DataRetryEntry.RETRY_STATE_FAILED, dataRetryEntry.getState()); 4931 // Verify a new retry is scheduled 4932 assertTrue(mDataNetworkControllerUT.getDataRetryManager() 4933 .isAnyHandoverRetryScheduled(dataNetwork)); 4934 4935 // 2. Normal case (call ended), should tear down 4936 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 4937 mDataNetworkControllerUT.obtainMessage(EVENT_VOICE_CALL_ENDED).sendToTarget(); 4938 processAllFutureMessages(); 4939 4940 // Verify that handover is not performed. 4941 verify(mMockedWlanDataServiceManager, never()).setupDataCall(anyInt(), 4942 any(DataProfile.class), anyBoolean(), anyBoolean(), 4943 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(), 4944 any(Message.class)); 4945 4946 // Verify IMS network should be torn down. 4947 verifyAllDataDisconnected(); 4948 } 4949 4950 @Test testHandoverDataNetworkSourceOos()4951 public void testHandoverDataNetworkSourceOos() throws Exception { 4952 testSetupImsDataNetwork(); 4953 // Configured handover is disallowed from OOS to 4G/5G/IWLAN. 4954 mCarrierConfig.putStringArray( 4955 CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 4956 new String[]{ 4957 "source=EUTRAN|NGRAN|IWLAN|UNKNOWN, target=EUTRAN|NGRAN|IWLAN, " 4958 + "type=disallowed, capabilities=IMS|EIMS|MMS|XCAP|CBS" 4959 }); 4960 carrierConfigChanged(); 4961 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4962 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 4963 4964 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 4965 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 4966 4967 // Verify IMS network was torn down on source first. 4968 verify(mMockedWwanDataServiceManager).deactivateDataCall(anyInt(), 4969 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 4970 4971 // Verify that IWLAN is brought up again on IWLAN. 4972 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), 4973 any(DataProfile.class), anyBoolean(), anyBoolean(), 4974 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(), 4975 any(Message.class)); 4976 4977 DataNetwork dataNetwork = getDataNetworks().get(0); 4978 assertThat(dataNetwork.getTransport()).isEqualTo( 4979 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 4980 } 4981 4982 @Test testHandoverDataNetworkRoamingOos()4983 public void testHandoverDataNetworkRoamingOos() throws Exception { 4984 testSetupImsDataNetwork(); 4985 // Configured handover is disallowed at Roaming. 4986 mCarrierConfig.putStringArray( 4987 CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 4988 new String[]{ 4989 "source=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN|UNKNOWN, " 4990 + "target=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN, roaming=true, " 4991 + "type=disallowed, capabilities=IMS" 4992 }); 4993 carrierConfigChanged(); 4994 DataNetwork dataNetwork = getDataNetworks().get(0); 4995 //Enter ROAMING 4996 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 4997 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 4998 updateServiceStateForDatatNetwork(TelephonyManager.NETWORK_TYPE_LTE, 4999 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING, dataNetwork); 5000 //OOS 5001 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 5002 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 5003 updateServiceStateForDatatNetwork(TelephonyManager.NETWORK_TYPE_UNKNOWN, 5004 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, 5005 dataNetwork); 5006 5007 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5008 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 5009 5010 // Verify IMS network was torn down on source first. 5011 verify(mMockedWwanDataServiceManager).deactivateDataCall(anyInt(), 5012 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 5013 5014 // Verify that IWLAN is brought up again on IWLAN. 5015 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), 5016 any(DataProfile.class), anyBoolean(), anyBoolean(), 5017 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(), 5018 any(Message.class)); 5019 5020 DataNetwork dataNetworkIwlan = getDataNetworks().get(0); 5021 assertThat(dataNetworkIwlan.getTransport()).isEqualTo( 5022 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 5023 } 5024 updateServiceStateForDatatNetwork(@nnotation.NetworkType int networkType, @NetworkRegistrationInfo.RegistrationState int regState, DataNetwork dataNetwork)5025 private void updateServiceStateForDatatNetwork(@Annotation.NetworkType int networkType, 5026 @NetworkRegistrationInfo.RegistrationState int regState, DataNetwork dataNetwork) { 5027 ServiceState ss = new ServiceState(); 5028 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 5029 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 5030 .setAccessNetworkTechnology(networkType) 5031 .setRegistrationState(regState) 5032 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 5033 .setDataSpecificInfo(null) 5034 .build()); 5035 5036 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 5037 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 5038 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN) 5039 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 5040 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 5041 .build()); 5042 5043 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 5044 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 5045 .setAccessNetworkTechnology(networkType) 5046 .setRegistrationState(regState) 5047 .setDomain(NetworkRegistrationInfo.DOMAIN_CS) 5048 .build()); 5049 ss.setDataRoamingFromRegistration(regState 5050 == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 5051 doReturn(ss).when(mSST).getServiceState(); 5052 doReturn(ss).when(mPhone).getServiceState(); 5053 5054 if (dataNetwork != null) { 5055 dataNetwork.obtainMessage(9/*EVENT_SERVICE_STATE_CHANGED*/).sendToTarget(); 5056 processAllMessages(); 5057 } 5058 } 5059 5060 @Test testHandoverDataNetworkSourceOosNoUnknownRule()5061 public void testHandoverDataNetworkSourceOosNoUnknownRule() throws Exception { 5062 testSetupImsDataNetwork(); 5063 // Configured handover is allowed from OOS to 4G/5G/IWLAN. 5064 mCarrierConfig.putStringArray( 5065 CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 5066 new String[]{ 5067 "source=EUTRAN|NGRAN|IWLAN, target=EUTRAN|NGRAN|IWLAN, " 5068 + "type=disallowed, capabilities=IMS|EIMS|MMS|XCAP|CBS" 5069 }); 5070 carrierConfigChanged(); 5071 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5072 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 5073 5074 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5075 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 5076 5077 // Verify IMS network was torn down on source first. 5078 verify(mMockedWwanDataServiceManager).deactivateDataCall(anyInt(), 5079 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 5080 5081 // Verify that IWLAN is brought up again on IWLAN. 5082 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), 5083 any(DataProfile.class), anyBoolean(), anyBoolean(), 5084 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(), 5085 any(Message.class)); 5086 5087 DataNetwork dataNetwork = getDataNetworks().get(0); 5088 assertThat(dataNetwork.getTransport()).isEqualTo( 5089 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 5090 } 5091 5092 @Test testHandoverDataNetworkNonVops()5093 public void testHandoverDataNetworkNonVops() throws Exception { 5094 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo.Builder(8) 5095 .setNrAvailable(true) 5096 .setEnDcAvailable(true) 5097 .setVopsSupportInfo(new LteVopsSupportInfo( 5098 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 5099 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)) 5100 .build(); 5101 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5102 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 5103 5104 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 5105 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 5106 5107 mDataNetworkControllerUT.obtainMessage(EVENT_SERVICE_STATE_CHANGED).sendToTarget(); 5108 processAllMessages(); 5109 5110 mDataNetworkControllerUT.addNetworkRequest( 5111 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5112 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5113 processAllMessages(); 5114 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 5115 NetworkCapabilities.NET_CAPABILITY_MMTEL); 5116 5117 // Change the preference to cellular 5118 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5119 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 5120 5121 // Verify that handover is not performed. 5122 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 5123 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 5124 any(), any(), anyBoolean(), any(Message.class)); 5125 5126 // IMS network should be torn down. 5127 verifyAllDataDisconnected(); 5128 } 5129 5130 @Test testHandoverDataNetworkNonVopsAllowLingeringVoPS()5131 public void testHandoverDataNetworkNonVopsAllowLingeringVoPS() throws Exception { 5132 // Allow lingering IMS PDN when enter area VoPS -> no VoPS 5133 mCarrierConfig.putBoolean(CarrierConfigManager.Ims.KEY_KEEP_PDN_UP_IN_NO_VOPS_BOOL, true); 5134 carrierConfigChanged(); 5135 5136 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo.Builder(8) 5137 .setNrAvailable(true) 5138 .setEnDcAvailable(true) 5139 .setVopsSupportInfo(new LteVopsSupportInfo( 5140 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 5141 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)) 5142 .build(); 5143 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5144 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 5145 5146 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 5147 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 5148 5149 mDataNetworkControllerUT.obtainMessage(EVENT_SERVICE_STATE_CHANGED).sendToTarget(); 5150 processAllMessages(); 5151 5152 mDataNetworkControllerUT.addNetworkRequest( 5153 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5154 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5155 processAllMessages(); 5156 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 5157 NetworkCapabilities.NET_CAPABILITY_MMTEL); 5158 5159 // Change the preference to cellular 5160 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5161 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 5162 5163 // Verify that handover is not performed. 5164 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), 5165 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 5166 any(), any(), anyBoolean(), any(Message.class)); 5167 5168 // IMS network still alive. 5169 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 5170 NetworkCapabilities.NET_CAPABILITY_MMTEL); 5171 } 5172 5173 @Test testNonMmtelImsHandoverDataNetworkNonVops()5174 public void testNonMmtelImsHandoverDataNetworkNonVops() throws Exception { 5175 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo.Builder(8) 5176 .setNrAvailable(true) 5177 .setEnDcAvailable(true) 5178 .setVopsSupportInfo(new LteVopsSupportInfo( 5179 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 5180 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)) 5181 .build(); 5182 5183 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5184 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 5185 5186 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 5187 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 5188 5189 mDataNetworkControllerUT.obtainMessage(EVENT_SERVICE_STATE_CHANGED).sendToTarget(); 5190 processAllMessages(); 5191 5192 // Bring up the IMS network that does not require MMTEL 5193 mDataNetworkControllerUT.addNetworkRequest( 5194 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 5195 processAllMessages(); 5196 5197 // Even though the network request does not have MMTEL, the WLAN network support it, so 5198 // the network capabilities should still have MMTEL. 5199 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 5200 NetworkCapabilities.NET_CAPABILITY_MMTEL); 5201 5202 // Change the preference to cellular 5203 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5204 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 5205 5206 // Verify that handover is performed 5207 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), 5208 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 5209 any(), any(), anyBoolean(), any(Message.class)); 5210 5211 // The IMS network should still have IMS, but MMTEL is removed. 5212 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS); 5213 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL); 5214 } 5215 5216 @Test testMmtelImsDataNetworkMovingToNonVops()5217 public void testMmtelImsDataNetworkMovingToNonVops() throws Exception { 5218 // Allow lingering IMS PDN when enter area VoPS -> no VoPS 5219 mCarrierConfig.putBoolean(CarrierConfigManager.Ims.KEY_KEEP_PDN_UP_IN_NO_VOPS_BOOL, true); 5220 carrierConfigChanged(); 5221 5222 // VoPS network 5223 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo.Builder(8) 5224 .setNrAvailable(true) 5225 .setEnDcAvailable(true) 5226 .setVopsSupportInfo(new LteVopsSupportInfo( 5227 LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 5228 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)) 5229 .build(); 5230 5231 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5232 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 5233 5234 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 5235 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 5236 5237 mDataNetworkControllerUT.obtainMessage(EVENT_SERVICE_STATE_CHANGED).sendToTarget(); 5238 processAllMessages(); 5239 5240 // Bring up the IMS network that does require MMTEL 5241 mDataNetworkControllerUT.addNetworkRequest( 5242 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5243 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5244 processAllMessages(); 5245 5246 // the network capabilities should have IMS and MMTEL. 5247 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 5248 NetworkCapabilities.NET_CAPABILITY_MMTEL); 5249 5250 // Non VoPS network 5251 dsri = new DataSpecificRegistrationInfo.Builder(8) 5252 .setNrAvailable(true) 5253 .setEnDcAvailable(true) 5254 .setVopsSupportInfo(new LteVopsSupportInfo( 5255 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 5256 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)) 5257 .build(); 5258 5259 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5260 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 5261 5262 mDataNetworkControllerUT.obtainMessage(EVENT_SERVICE_STATE_CHANGED).sendToTarget(); 5263 processAllMessages(); 5264 5265 // The IMS network is alive due to KEY_KEEP_PDN_UP_IN_NO_VOPS_BOOL = true 5266 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 5267 NetworkCapabilities.NET_CAPABILITY_MMTEL); 5268 5269 mCarrierConfig.putBoolean(CarrierConfigManager.Ims.KEY_KEEP_PDN_UP_IN_NO_VOPS_BOOL, false); 5270 carrierConfigChanged(); 5271 mDataNetworkControllerUT.obtainMessage(EVENT_REEVALUATE_EXISTING_DATA_NETWORKS) 5272 .sendToTarget(); 5273 processAllMessages(); 5274 5275 // The IMS network should be torn down by data network controller. 5276 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 5277 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL); 5278 } 5279 5280 @Test testVoPStoNonVoPSDelayImsTearDown()5281 public void testVoPStoNonVoPSDelayImsTearDown() throws Exception { 5282 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL, 5283 true); 5284 carrierConfigChanged(); 5285 5286 // VoPS supported 5287 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo.Builder(8) 5288 .setNrAvailable(true) 5289 .setEnDcAvailable(true) 5290 .setVopsSupportInfo(new LteVopsSupportInfo( 5291 LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 5292 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)) 5293 .build(); 5294 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5295 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 5296 5297 mDataNetworkControllerUT.addNetworkRequest( 5298 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5299 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5300 processAllMessages(); 5301 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS); 5302 5303 doReturn(PhoneConstants.State.OFFHOOK).when(mCT).getState(); 5304 5305 dsri = new DataSpecificRegistrationInfo.Builder(8) 5306 .setNrAvailable(true) 5307 .setEnDcAvailable(true) 5308 .setVopsSupportInfo(new LteVopsSupportInfo( 5309 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 5310 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)) 5311 .build(); 5312 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5313 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 5314 5315 // Make sure IMS is still connected. 5316 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 5317 NetworkCapabilities.NET_CAPABILITY_MMTEL); 5318 5319 // Call ends 5320 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 5321 mDataNetworkControllerUT.obtainMessage(EVENT_VOICE_CALL_ENDED).sendToTarget(); 5322 processAllMessages(); 5323 5324 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 5325 } 5326 5327 @Test testDeactivateDataOnOldHal()5328 public void testDeactivateDataOnOldHal() throws Exception { 5329 doAnswer(invocation -> { 5330 // Only send the deactivation data response, no data call list changed event. 5331 Message msg = (Message) invocation.getArguments()[2]; 5332 msg.sendToTarget(); 5333 return null; 5334 }).when(mMockedWwanDataServiceManager).deactivateDataCall( 5335 anyInt(), anyInt(), any(Message.class)); 5336 // Simulate old devices 5337 doReturn(RIL.RADIO_HAL_VERSION_1_6).when(mPhone).getHalVersion(HAL_SERVICE_DATA); 5338 5339 testSetupDataNetwork(); 5340 5341 mDataNetworkControllerUT.obtainMessage(EVENT_SIM_STATE_CHANGED, 5342 TelephonyManager.SIM_STATE_ABSENT, 0).sendToTarget(); 5343 processAllMessages(); 5344 verifyAllDataDisconnected(); 5345 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 5346 verify(mMockedDataNetworkControllerCallback).onConnectedInternetDataNetworksChanged( 5347 eq(Collections.emptySet())); 5348 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 5349 eq(DataCallResponse.LINK_STATUS_INACTIVE)); 5350 } 5351 5352 @Test testHandoverWhileSetupDataCallInProgress()5353 public void testHandoverWhileSetupDataCallInProgress() throws Exception { 5354 // Long delay setup failure 5355 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 5356 DataCallResponse.RETRY_DURATION_UNDEFINED, false, 10000); 5357 5358 mDataNetworkControllerUT.addNetworkRequest( 5359 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5360 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5361 processAllMessages(); 5362 5363 // Change the preference to IWLAN while setup data is still ongoing. 5364 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5365 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 5366 5367 // Data should not be connected. 5368 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 5369 5370 // There shouldn't be any attempt to bring up IMS on IWLAN even though the preference 5371 // has already changed, because the previous setup is still ongoing. 5372 verify(mMockedWlanDataServiceManager, never()).setupDataCall(eq(AccessNetworkType.IWLAN), 5373 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 5374 any(), any(), anyBoolean(), any(Message.class)); 5375 5376 processAllFutureMessages(); 5377 5378 // Should setup a new one instead of handover. 5379 verify(mMockedWlanDataServiceManager).setupDataCall(eq(AccessNetworkType.IWLAN), 5380 any(DataProfile.class), anyBoolean(), anyBoolean(), 5381 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(), 5382 any(Message.class)); 5383 5384 // IMS should be connected. 5385 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 5386 NetworkCapabilities.NET_CAPABILITY_MMTEL); 5387 } 5388 5389 @Test testRemoveNetworkRequest()5390 public void testRemoveNetworkRequest() throws Exception { 5391 NetworkCapabilities netCaps = new NetworkCapabilities(); 5392 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 5393 5394 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 5395 ConnectivityManager.TYPE_MOBILE, 0, NetworkRequest.Type.REQUEST); 5396 TelephonyNetworkRequest request = new TelephonyNetworkRequest( 5397 nativeNetworkRequest, mPhone, mFeatureFlags); 5398 mDataNetworkControllerUT.addNetworkRequest(request); 5399 processAllMessages(); 5400 5401 mDataNetworkControllerUT.removeNetworkRequest(request); 5402 processAllFutureMessages(); 5403 5404 List<DataNetwork> dataNetworkList = getDataNetworks(); 5405 // The data network should not be torn down after network request removal. 5406 assertThat(dataNetworkList).hasSize(1); 5407 // But should be detached from the data network. 5408 assertThat(dataNetworkList.get(0).getAttachedNetworkRequestList()).isEmpty(); 5409 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 5410 } 5411 5412 @Test testTempDdsSwitchTearDown()5413 public void testTempDdsSwitchTearDown() throws Exception { 5414 TelephonyNetworkRequest request = createNetworkRequest( 5415 NetworkCapabilities.NET_CAPABILITY_INTERNET); 5416 mDataNetworkControllerUT.addNetworkRequest(request); 5417 processAllMessages(); 5418 5419 // this slot is 0, modem preferred on slot 1 5420 doReturn(1).when(mPhoneSwitcher).getPreferredDataPhoneId(); 5421 5422 // Simulate telephony network factory remove request due to switch. 5423 mDataNetworkControllerUT.removeNetworkRequest(request); 5424 processAllMessages(); 5425 5426 // Data should be torn down on this non-preferred sub. 5427 verifyAllDataDisconnected(); 5428 } 5429 5430 @Test testSetupDataOnNonDds()5431 public void testSetupDataOnNonDds() throws Exception { 5432 // this slot is 0, modem preferred on slot 1 5433 doReturn(1).when(mPhoneSwitcher).getPreferredDataPhoneId(); 5434 TelephonyNetworkRequest request = createNetworkRequest( 5435 NetworkCapabilities.NET_CAPABILITY_MMS); 5436 5437 // Test Don't allow setup if both data and voice OOS 5438 serviceStateChanged(TelephonyManager.NETWORK_TYPE_1xRTT, 5439 // data, voice, Iwlan reg state 5440 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, 5441 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, 5442 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, null); 5443 mDataNetworkControllerUT.addNetworkRequest(request); 5444 processAllMessages(); 5445 5446 verifyAllDataDisconnected(); 5447 5448 // Test Don't allow setup if CS is in service, but current RAT is already PS(e.g. LTE) 5449 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5450 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, 5451 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, 5452 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, null); 5453 5454 verifyAllDataDisconnected(); 5455 5456 // Test Allow if voice is in service if RAT is 2g/3g, use voice RAT to select data profile 5457 ServiceState ss = createSS(TelephonyManager.NETWORK_TYPE_UNKNOWN /* data RAT */, 5458 TelephonyManager.NETWORK_TYPE_1xRTT /* voice RAT */, 5459 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING , 5460 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, 5461 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, null, true); 5462 doReturn(ss).when(mSST).getServiceState(); 5463 mDataNetworkControllerUT.obtainMessage(EVENT_SERVICE_STATE_CHANGED).sendToTarget(); 5464 mDataNetworkControllerUT.removeNetworkRequest(request); 5465 mDataNetworkControllerUT.addNetworkRequest(request); 5466 processAllMessages(); 5467 5468 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 5469 } 5470 5471 @Test testTrafficDescriptionChangedDataRetry()5472 public void testTrafficDescriptionChangedDataRetry() throws Exception { 5473 List<TrafficDescriptor> tdList = List.of( 5474 new TrafficDescriptor.Builder() 5475 .setOsAppId(new OsAppId(OsAppId.ANDROID_OS_ID, "PRIORITIZE_LATENCY", 1) 5476 .getBytes()).build(), 5477 new TrafficDescriptor.Builder() 5478 .setOsAppId(new OsAppId(OsAppId.ANDROID_OS_ID, "ENTERPRISE", 1).getBytes()) 5479 .build() 5480 ); 5481 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 5482 createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE, tdList)); 5483 doReturn(mEnterpriseDataProfile).when(mDataProfileManager) 5484 .getDataProfileForNetworkRequest(any(TelephonyNetworkRequest.class), anyInt(), 5485 anyBoolean(), anyBoolean(), anyBoolean()); 5486 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 5487 new NetworkRequest.Builder() 5488 .addCapability(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE) 5489 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED) 5490 .build(), mPhone, mFeatureFlags)); 5491 processAllMessages(); 5492 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE, 5493 NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY); 5494 5495 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 5496 new NetworkRequest.Builder() 5497 .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY) 5498 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED) 5499 .build(), mPhone, mFeatureFlags)); 5500 processAllMessages(); 5501 List<DataNetwork> dataNetworkList = getDataNetworks(); 5502 assertThat(dataNetworkList).hasSize(1); 5503 5504 // Now remove low latency TD from the data call response. 5505 logd("Now remove PRIORITIZE_LATENCY"); 5506 tdList = List.of(new TrafficDescriptor.Builder() 5507 .setOsAppId(new OsAppId(OsAppId.ANDROID_OS_ID, "ENTERPRISE", 1).getBytes()) 5508 .build()); 5509 mDataCallResponses.get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).put(1, 5510 createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE, tdList)); 5511 mDataCallListChangedRegistrants.get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 5512 .notifyRegistrants(new AsyncResult(AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 5513 List.of(createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE, 5514 tdList)), null)); 5515 5516 tdList = List.of(new TrafficDescriptor.Builder() 5517 .setOsAppId(new OsAppId(OsAppId.ANDROID_OS_ID, "PRIORITIZE_LATENCY", 1).getBytes()) 5518 .build()); 5519 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 5520 createDataCallResponse(2, DataCallResponse.LINK_STATUS_ACTIVE, tdList)); 5521 doReturn(mLowLatencyDataProfile).when(mDataProfileManager) 5522 .getDataProfileForNetworkRequest(any(TelephonyNetworkRequest.class), anyInt(), 5523 anyBoolean(), anyBoolean(), anyBoolean()); 5524 processAllFutureMessages(); 5525 5526 dataNetworkList = getDataNetworks(); 5527 assertThat(dataNetworkList).hasSize(2); 5528 5529 assertThat(dataNetworkList.get(0).getNetworkCapabilities().hasCapability( 5530 NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)).isTrue(); 5531 assertThat(dataNetworkList.get(0).getNetworkCapabilities().hasCapability( 5532 NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)).isFalse(); 5533 assertThat(dataNetworkList.get(1).getNetworkCapabilities().hasCapability( 5534 NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)).isFalse(); 5535 assertThat(dataNetworkList.get(1).getNetworkCapabilities().hasCapability( 5536 NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)).isTrue(); 5537 } 5538 5539 @Test testNonTerrestrialNetwork()5540 public void testNonTerrestrialNetwork() throws Exception { 5541 TelephonyNetworkRequest request; 5542 mIsNonTerrestrialNetwork = true; 5543 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5544 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 5545 // By default, Test only support restricted network, regardless whether constrained. 5546 // Verify not_restricted network not supported. 5547 request = createNetworkRequest(false, NetworkCapabilities.NET_CAPABILITY_RCS); 5548 mDataNetworkControllerUT.addNetworkRequest(request); 5549 processAllMessages(); 5550 verifyAllDataDisconnected(); 5551 mDataNetworkControllerUT.removeNetworkRequest(request); 5552 5553 // Verify restricted network is supported. 5554 request = createNetworkRequest(true, NetworkCapabilities.NET_CAPABILITY_RCS); 5555 mDataNetworkControllerUT.addNetworkRequest(request); 5556 processAllMessages(); 5557 verifyConnectedNetworkHasDataProfile(mNtnDataProfile); 5558 mDataNetworkControllerUT.removeNetworkRequest(request); 5559 getDataNetworks().get(0).tearDown(DataNetwork 5560 .TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 5561 5562 // Test constrained network is supported, regardless whether it's restricted 5563 processAllFutureMessages(); 5564 verifyAllDataDisconnected(); 5565 mCarrierConfig.putInt(CarrierConfigManager.KEY_SATELLITE_DATA_SUPPORT_MODE_INT, 5566 CarrierConfigManager.SATELLITE_DATA_SUPPORT_BANDWIDTH_CONSTRAINED); 5567 carrierConfigChanged(); 5568 // Verify not_restricted, not_constrained network not supported. 5569 NetworkCapabilities netCaps = new NetworkCapabilities(); 5570 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_RCS); 5571 try { 5572 netCaps.addCapability(DataUtils.NET_CAPABILITY_NOT_BANDWIDTH_CONSTRAINED); 5573 } catch (Exception ignored) { } 5574 request = new TelephonyNetworkRequest(new NetworkRequest(netCaps, 5575 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 5576 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags); 5577 5578 mDataNetworkControllerUT.addNetworkRequest(request); 5579 processAllMessages(); 5580 verifyAllDataDisconnected(); 5581 mDataNetworkControllerUT.removeNetworkRequest(request); 5582 5583 // Verify restricted, not_constrained network is supported. 5584 netCaps = new NetworkCapabilities(); 5585 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_RCS); 5586 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 5587 try { 5588 netCaps.addCapability(DataUtils.NET_CAPABILITY_NOT_BANDWIDTH_CONSTRAINED); 5589 } catch (Exception ignored) { } 5590 request = new TelephonyNetworkRequest(new NetworkRequest(netCaps, 5591 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 5592 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags); 5593 mDataNetworkControllerUT.addNetworkRequest(request); 5594 processAllMessages(); 5595 verifyConnectedNetworkHasDataProfile(mNtnDataProfile); 5596 mDataNetworkControllerUT.removeNetworkRequest(request); 5597 getDataNetworks().get(0).tearDown(DataNetwork 5598 .TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 5599 5600 // TODO(enable after NET_CAPABILITY_NOT_BANDWIDTH_CONSTRAINED become a default cap) 5601 // Test not constrained network supported 5602 // processAllFutureMessages(); 5603 // verifyAllDataDisconnected(); 5604 // mCarrierConfig.putInt(CarrierConfigManager.KEY_SATELLITE_DATA_SUPPORT_MODE_INT, 5605 // CarrierConfigManager.SATELLITE_DATA_SUPPORT_ALL); 5606 // carrierConfigChanged(); 5607 // 5608 // netCaps = new NetworkCapabilities(); 5609 // netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_RCS); 5610 // try { 5611 // netCaps.addCapability(DataUtils.NET_CAPABILITY_NOT_BANDWIDTH_CONSTRAINED); 5612 // } catch (Exception ignored) {} 5613 // mDataNetworkControllerUT.addNetworkRequest( 5614 // new TelephonyNetworkRequest(new NetworkRequest(netCaps, 5615 // ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 5616 // NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 5617 // processAllMessages(); 5618 // verifyConnectedNetworkHasDataProfile(mNtnDataProfile); 5619 } 5620 5621 @Test testIsEsimBootStrapProvisioningActivatedWithFlagEnabledAndProvisioningClass()5622 public void testIsEsimBootStrapProvisioningActivatedWithFlagEnabledAndProvisioningClass() { 5623 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(true); 5624 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5625 .setProfileClass(SubscriptionManager.PROFILE_CLASS_PROVISIONING).build()) 5626 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5627 5628 assertThat(mDataNetworkControllerUT.isEsimBootStrapProvisioningActivated()).isTrue(); 5629 } 5630 5631 @Test testIsEsimBootStrapProvisioningActivatedWithFlagEnabledAndNoProvisioningClass()5632 public void testIsEsimBootStrapProvisioningActivatedWithFlagEnabledAndNoProvisioningClass() { 5633 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(true); 5634 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5635 .setProfileClass(SubscriptionManager.PROFILE_CLASS_UNSET).build()) 5636 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5637 5638 assertThat(mDataNetworkControllerUT.isEsimBootStrapProvisioningActivated()).isFalse(); 5639 } 5640 5641 @Test testIsEsimBootStrapProvisioningActivatedWithFlagDisabledAndNoProvisioningClass()5642 public void testIsEsimBootStrapProvisioningActivatedWithFlagDisabledAndNoProvisioningClass() { 5643 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(false); 5644 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5645 .setProfileClass(SubscriptionManager.PROFILE_CLASS_UNSET).build()) 5646 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5647 5648 assertThat(mDataNetworkControllerUT.isEsimBootStrapProvisioningActivated()).isFalse(); 5649 } 5650 5651 @Test testIsEsimBootStrapProvisioningActivatedWithFlagDisabledAndProvisioningClass()5652 public void testIsEsimBootStrapProvisioningActivatedWithFlagDisabledAndProvisioningClass() { 5653 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(false); 5654 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5655 .setProfileClass(SubscriptionManager.PROFILE_CLASS_PROVISIONING).build()) 5656 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5657 5658 assertThat(mDataNetworkControllerUT.isEsimBootStrapProvisioningActivated()).isFalse(); 5659 } 5660 5661 @Test testNetworkOnProvisioningProfileClass_WithFlagEnabled()5662 public void testNetworkOnProvisioningProfileClass_WithFlagEnabled() throws Exception { 5663 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(true); 5664 // Allowed data limit Unlimited 5665 mContextFixture.putIntResource(com.android.internal.R.integer 5666 .config_esim_bootstrap_data_limit_bytes, -1); 5667 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5668 .setProfileClass(SubscriptionManager.PROFILE_CLASS_PROVISIONING).build()) 5669 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5670 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5671 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 5672 mDataNetworkControllerUT.addNetworkRequest( 5673 createNetworkRequest(true/*restricted*/, 5674 NetworkCapabilities.NET_CAPABILITY_INTERNET)); 5675 processAllMessages(); 5676 verifyConnectedNetworkHasDataProfile(mEsimBootstrapDataProfile); 5677 5678 mDataNetworkControllerUT.addNetworkRequest( 5679 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5680 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5681 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 5682 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 5683 processAllMessages(); 5684 verifyConnectedNetworkHasDataProfile(mEsimBootstrapImsProfile); 5685 } 5686 5687 @Test testSetUpPdn_WithBootStrapDataLimit_Zero()5688 public void testSetUpPdn_WithBootStrapDataLimit_Zero() throws Exception { 5689 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(true); 5690 // Allowed data limit set as zero 5691 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5692 .setProfileClass(SubscriptionManager.PROFILE_CLASS_PROVISIONING).build()) 5693 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5694 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5695 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 5696 mDataNetworkControllerUT.addNetworkRequest( 5697 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 5698 processAllMessages(); 5699 // With current consumed bytes is zero, same as allowed limit, data_limit_reached 5700 // disallowed reason is met 5701 verifyConnectedNetworkHasNoDataProfile(mEsimBootstrapDataProfile); 5702 5703 mDataNetworkControllerUT.addNetworkRequest( 5704 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5705 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5706 processAllMessages(); 5707 // New network request also meets with data limit reached disallowed reason 5708 verifyConnectedNetworkHasNoDataProfile(mEsimBootstrapImsProfile); 5709 } 5710 5711 @Test testSetUpPdn_WithBootStrapDataLimit_Unlimited()5712 public void testSetUpPdn_WithBootStrapDataLimit_Unlimited() throws Exception { 5713 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(true); 5714 // Allowed data limit 5715 mContextFixture.putIntResource(com.android.internal.R.integer 5716 .config_esim_bootstrap_data_limit_bytes, -1/*unlimited*/); 5717 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5718 .setProfileClass(SubscriptionManager.PROFILE_CLASS_PROVISIONING).build()) 5719 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5720 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5721 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 5722 mDataNetworkControllerUT.addNetworkRequest( 5723 createNetworkRequest(true, NetworkCapabilities.NET_CAPABILITY_INTERNET)); 5724 processAllMessages(); 5725 // With allowed data limit unlimited, connection is allowed 5726 verifyConnectedNetworkHasDataProfile(mEsimBootstrapDataProfile); 5727 5728 mDataNetworkControllerUT.addNetworkRequest( 5729 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5730 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5731 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 5732 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 5733 processAllMessages(); 5734 // With allowed data limit unlimited, connection is allowed 5735 verifyConnectedNetworkHasDataProfile(mEsimBootstrapImsProfile); 5736 5737 // Both internet and IMS should be retained after network re-evaluation 5738 mDataNetworkControllerUT.obtainMessage(16 /*EVENT_REEVALUATE_EXISTING_DATA_NETWORKS*/, 5739 DataEvaluation.DataEvaluationReason.CHECK_DATA_USAGE).sendToTarget(); 5740 processAllMessages(); 5741 // With allowed data limit unlimited, connection is allowed 5742 verifyConnectedNetworkHasDataProfile(mEsimBootstrapDataProfile); 5743 verifyConnectedNetworkHasDataProfile(mEsimBootstrapImsProfile); 5744 } 5745 5746 @Test testNetworkOnNonProvisioningProfileClass_WithFlagEnabled()5747 public void testNetworkOnNonProvisioningProfileClass_WithFlagEnabled() throws Exception { 5748 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(true); 5749 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5750 .setProfileClass(SubscriptionManager.PROFILE_CLASS_UNSET).build()) 5751 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5752 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5753 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 5754 mDataNetworkControllerUT.addNetworkRequest( 5755 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 5756 processAllMessages(); 5757 verifyConnectedNetworkHasNoDataProfile(mEsimBootstrapDataProfile); 5758 5759 mDataNetworkControllerUT.addNetworkRequest( 5760 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5761 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5762 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 5763 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 5764 processAllMessages(); 5765 verifyConnectedNetworkHasNoDataProfile(mEsimBootstrapImsProfile); 5766 } 5767 5768 @Test testNtnNetworkOnProvisioningProfileClassWithFlagEnabled()5769 public void testNtnNetworkOnProvisioningProfileClassWithFlagEnabled() throws Exception { 5770 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(true); 5771 // Allowed data limit Unlimited 5772 mContextFixture.putIntResource(com.android.internal.R.integer 5773 .config_esim_bootstrap_data_limit_bytes, -1); 5774 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5775 .setProfileClass(SubscriptionManager.PROFILE_CLASS_PROVISIONING).build()) 5776 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5777 mIsNonTerrestrialNetwork = true; 5778 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5779 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 5780 mDataNetworkControllerUT.addNetworkRequest( 5781 createNetworkRequest(true, NetworkCapabilities.NET_CAPABILITY_RCS)); 5782 processAllMessages(); 5783 5784 assertThat(mDataNetworkControllerUT.isEsimBootStrapProvisioningActivated()).isTrue(); 5785 verifyConnectedNetworkHasNoDataProfile(mNtnDataProfile); 5786 verifyConnectedNetworkHasDataProfile(mEsimBootstrapRcsInfraStructureProfile); 5787 } 5788 5789 @Test testNonNtnNetworkOnProvisioningProfileClassWithFlagEnabled()5790 public void testNonNtnNetworkOnProvisioningProfileClassWithFlagEnabled() throws Exception { 5791 when(mFeatureFlags.esimBootstrapProvisioningFlag()).thenReturn(true); 5792 doReturn(new SubscriptionInfoInternal.Builder().setId(1) 5793 .setProfileClass(SubscriptionManager.PROFILE_CLASS_PROVISIONING).build()) 5794 .when(mSubscriptionManagerService).getSubscriptionInfoInternal(anyInt()); 5795 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5796 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 5797 mDataNetworkControllerUT.addNetworkRequest( 5798 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_RCS)); 5799 processAllMessages(); 5800 5801 assertThat(mDataNetworkControllerUT.isEsimBootStrapProvisioningActivated()).isTrue(); 5802 verifyConnectedNetworkHasNoDataProfile(mNtnDataProfile); 5803 verifyConnectedNetworkHasNoDataProfile(mEsimBootstrapRcsInfraStructureProfile); 5804 } 5805 5806 @Test testRequestNetworkValidationWithConnectedNetwork()5807 public void testRequestNetworkValidationWithConnectedNetwork() throws Exception { 5808 // IMS preferred on IWLAN. 5809 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 5810 .getPreferredTransportByNetworkCapability( 5811 eq(NetworkCapabilities.NET_CAPABILITY_IMS)); 5812 5813 // Request IMS 5814 mDataNetworkControllerUT.addNetworkRequest( 5815 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 5816 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 5817 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 5818 .get(AccessNetworkConstants.TRANSPORT_TYPE_WLAN), 3); 5819 processAllMessages(); 5820 5821 // Make sure IMS on IWLAN. 5822 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS); 5823 DataNetwork dataNetwork = getDataNetworks().get(0); 5824 assertThat(dataNetwork.getTransport()).isEqualTo( 5825 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 5826 5827 mDataNetworkControllerUT.requestNetworkValidation(NetworkCapabilities.NET_CAPABILITY_IMS, 5828 mIntegerConsumer); 5829 processAllMessages(); 5830 assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isFalse(); 5831 } 5832 5833 @Test testRequestNetworkValidationWithNoConnectedNetwork()5834 public void testRequestNetworkValidationWithNoConnectedNetwork() 5835 throws Exception { 5836 // IMS preferred on IWLAN. 5837 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 5838 .getPreferredTransportByNetworkCapability( 5839 eq(NetworkCapabilities.NET_CAPABILITY_IMS)); 5840 5841 // IMS On Wlan not connected 5842 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 5843 5844 //Connected List is Empty 5845 mDataNetworkControllerUT.requestNetworkValidation(NetworkCapabilities.NET_CAPABILITY_IMS, 5846 mIntegerConsumer); 5847 processAllMessages(); 5848 assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isTrue(); 5849 assertThat(mIntegerConsumerResult).isEqualTo(DataServiceCallback.RESULT_ERROR_INVALID_ARG); 5850 } 5851 5852 @Test testRequestNetworkValidationWithInvalidArg()5853 public void testRequestNetworkValidationWithInvalidArg() { 5854 mDataNetworkControllerUT.requestNetworkValidation( 5855 NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY, 5856 mIntegerConsumer); 5857 processAllMessages(); 5858 assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isTrue(); 5859 assertThat(mIntegerConsumerResult).isEqualTo(DataServiceCallback.RESULT_ERROR_INVALID_ARG); 5860 } 5861 5862 @Test testForceReconnectToPreferredTransportType()5863 public void testForceReconnectToPreferredTransportType() throws Exception { 5864 testSetupImsDataNetwork(); 5865 reconnectTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5866 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 5867 5868 // Verify IMS network was torn down on source first. 5869 verify(mMockedWwanDataServiceManager).deactivateDataCall(anyInt(), 5870 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 5871 5872 // Verify that IWLAN is brought up again on IWLAN. 5873 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), 5874 any(DataProfile.class), anyBoolean(), anyBoolean(), 5875 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(), 5876 any(Message.class)); 5877 5878 DataNetwork dataNetwork = getDataNetworks().get(0); 5879 assertThat(dataNetwork.getTransport()).isEqualTo( 5880 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 5881 } 5882 5883 @Test testForceReconnectIgnored()5884 public void testForceReconnectIgnored() throws Exception { 5885 mCarrierConfig.putStringArray( 5886 CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 5887 new String[]{ 5888 "source=EUTRAN|NGRAN|IWLAN|UNKNOWN, target=EUTRAN|NGRAN|IWLAN, " 5889 + "type=allowed, capabilities=IMS" 5890 }); 5891 carrierConfigChanged(); 5892 5893 testSetupImsDataNetwork(); 5894 reconnectTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5895 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 5896 5897 // request reconnection to current transport type, tear down should not happen. 5898 verify(mMockedWwanDataServiceManager, never()).deactivateDataCall(anyInt(), 5899 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 5900 5901 Mockito.reset(mMockedWlanDataServiceManager); 5902 5903 // Trigger Handover to IWLAN. 5904 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5905 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 5906 5907 // Capture the message for setup data call response. We want to delay it. 5908 ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class); 5909 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 5910 anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 5911 messageCaptor.capture()); 5912 5913 // Force reconnect to preferred transport type while handover is in progress. 5914 reconnectTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 5915 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 5916 5917 // Finally handover is completed. 5918 Message msg = messageCaptor.getValue(); 5919 DataCallResponse response = new DataCallResponse.Builder() 5920 .setCause(DataFailCause.NONE) 5921 .build(); 5922 msg.getData().putParcelable("data_call_response", response); 5923 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 5924 msg.sendToTarget(); 5925 processAllMessages(); 5926 5927 verify(mMockedWwanDataServiceManager, never()).deactivateDataCall(anyInt(), 5928 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 5929 } 5930 5931 @Test testRadioOffTearDown()5932 public void testRadioOffTearDown() throws Exception { 5933 testSetupDataNetwork(); 5934 doReturn(true).when(mSST).isPendingRadioPowerOffAfterDataOff(); 5935 mDataNetworkControllerUT.tearDownAllDataNetworks( 5936 DataNetwork.TEAR_DOWN_REASON_AIRPLANE_MODE_ON); 5937 processAllMessages(); 5938 verifyAllDataDisconnected(); 5939 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 5940 5941 clearInvocations(mMockedDataNetworkControllerCallback); 5942 mDataNetworkControllerUT.addNetworkRequest( 5943 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 5944 processAllMessages(); 5945 verifyAllDataDisconnected(); 5946 verify(mMockedDataNetworkControllerCallback, never()).onAnyDataNetworkExistingChanged( 5947 anyBoolean()); 5948 } 5949 5950 @Test testGetInternetEvaluation()5951 public void testGetInternetEvaluation() throws Exception { 5952 testSetupDataNetwork(); 5953 doReturn(true).when(mSST).isPendingRadioPowerOffAfterDataOff(); 5954 assertThat(mDataNetworkControllerUT.getInternetEvaluation(false/*ignoreExistingNetworks*/) 5955 .containsDisallowedReasons()).isFalse(); 5956 assertThat(mDataNetworkControllerUT.getInternetEvaluation(true/*ignoreExistingNetworks*/) 5957 .containsDisallowedReasons()).isTrue(); 5958 } 5959 5960 @Test testRemoveNetworkRequestClearState()5961 public void testRemoveNetworkRequestClearState() throws Exception { 5962 TelephonyNetworkRequest request = createNetworkRequest( 5963 NetworkCapabilities.NET_CAPABILITY_INTERNET); 5964 mDataNetworkControllerUT.addNetworkRequest(request); 5965 processAllMessages(); 5966 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 5967 assertThat(request.getState()).isEqualTo(TelephonyNetworkRequest.REQUEST_STATE_SATISFIED); 5968 5969 mDataNetworkControllerUT.removeNetworkRequest(request); 5970 processAllMessages(); 5971 assertThat(request.getState()).isEqualTo(TelephonyNetworkRequest.REQUEST_STATE_UNSATISFIED); 5972 } 5973 5974 @Test testNotRestrictedDataConnectionRequest_WithoutDataServiceSupport()5975 public void testNotRestrictedDataConnectionRequest_WithoutDataServiceSupport() 5976 throws Exception { 5977 mCarrierSupportedServices.clear(); 5978 mCarrierSupportedServices.add(NetworkRegistrationInfo.SERVICE_TYPE_VOICE); 5979 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5980 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 5981 5982 // Set network request transport with Internet capability + Not Restricted 5983 mDataNetworkControllerUT.addNetworkRequest( 5984 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 5985 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 5986 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 5987 processAllMessages(); 5988 5989 // Verify internet is not connected 5990 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 5991 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 5992 5993 // reset satellite network and roaming registration 5994 mCarrierSupportedServices.clear(); 5995 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 5996 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 5997 } 5998 5999 @Test testConnection_WithDataServiceCheckFlagDisabled_WithoutDataServiceSupport()6000 public void testConnection_WithDataServiceCheckFlagDisabled_WithoutDataServiceSupport() 6001 throws Exception { 6002 doReturn(false).when(mFeatureFlags).dataServiceCheck(); 6003 mCarrierSupportedServices.clear(); 6004 mCarrierSupportedServices.add(NetworkRegistrationInfo.SERVICE_TYPE_VOICE); 6005 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6006 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6007 6008 // Set network request transport with Internet capability + Not Restricted 6009 mDataNetworkControllerUT.addNetworkRequest( 6010 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 6011 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 6012 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 6013 processAllMessages(); 6014 6015 // Verify internet is connected 6016 verifyInternetConnected(); 6017 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 6018 6019 // reset satellite network and roaming registration 6020 mCarrierSupportedServices.clear(); 6021 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6022 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6023 } 6024 6025 @Test testRestrictedDataConnectionRequest_WithoutDataServiceSupport()6026 public void testRestrictedDataConnectionRequest_WithoutDataServiceSupport() 6027 throws Exception { 6028 mCarrierSupportedServices.clear(); 6029 mCarrierSupportedServices.add(NetworkRegistrationInfo.SERVICE_TYPE_VOICE); 6030 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6031 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6032 6033 // Set network request transport with Internet capability + Restricted 6034 NetworkCapabilities netCaps = new NetworkCapabilities(); 6035 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 6036 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 6037 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 6038 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 6039 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 6040 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 6041 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 6042 processAllMessages(); 6043 6044 // Verify internet is not connected 6045 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 6046 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 6047 6048 // reset satellite network and roaming registration 6049 mCarrierSupportedServices.clear(); 6050 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6051 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6052 } 6053 6054 @Test testNotRestrictedNetworkRequest_WithRestrictedDataPolicySupportMode()6055 public void testNotRestrictedNetworkRequest_WithRestrictedDataPolicySupportMode() 6056 throws Exception { 6057 // set up satellite network and register data roaming 6058 mIsNonTerrestrialNetwork = true; 6059 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6060 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6061 6062 // Set network request transport with Internet capability + Not Restricted 6063 doReturn(CarrierConfigManager.SATELLITE_DATA_SUPPORT_ONLY_RESTRICTED) 6064 .when(mSatelliteController) 6065 .getSatelliteDataServicePolicyForPlmn(anyInt(), any()); 6066 mDataNetworkControllerUT.addNetworkRequest( 6067 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 6068 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 6069 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 6070 processAllMessages(); 6071 6072 // Verify internet is not connected 6073 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 6074 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 6075 6076 // reset satellite network and roaming registration 6077 mIsNonTerrestrialNetwork = false; 6078 mCarrierSupportedServices.clear(); 6079 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6080 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6081 } 6082 6083 @Test testBandwidthConstrainedNetworkRequest_WithConstrainedDataPolicySupportMode()6084 public void testBandwidthConstrainedNetworkRequest_WithConstrainedDataPolicySupportMode() 6085 throws Exception { 6086 // set up satellite network and register data roaming 6087 mIsNonTerrestrialNetwork = true; 6088 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6089 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6090 6091 // Set network request transport with Internet capability + Not Restricted 6092 doReturn(CarrierConfigManager.SATELLITE_DATA_SUPPORT_BANDWIDTH_CONSTRAINED) 6093 .when(mSatelliteController) 6094 .getSatelliteDataServicePolicyForPlmn(anyInt(), any()); 6095 // Set network request transport as satellite in satellite network 6096 NetworkCapabilities netCaps = new NetworkCapabilities(); 6097 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE); 6098 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 6099 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_BANDWIDTH_CONSTRAINED); 6100 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 6101 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 6102 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 6103 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 6104 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 6105 processAllMessages(); 6106 6107 // Verify internet is connected 6108 verifyInternetConnected(); 6109 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 6110 6111 // reset satellite network and roaming registration 6112 mIsNonTerrestrialNetwork = false; 6113 mCarrierSupportedServices.clear(); 6114 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6115 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6116 } 6117 6118 @Test testBandwidthNotConstrainedNetworkRequest_WithConstrainedDataPolicySupportMode()6119 public void testBandwidthNotConstrainedNetworkRequest_WithConstrainedDataPolicySupportMode() 6120 throws Exception { 6121 // set up satellite network 6122 mIsNonTerrestrialNetwork = true; 6123 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6124 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6125 6126 // Set network request transport with Internet capability + Not Restricted 6127 doReturn(CarrierConfigManager.SATELLITE_DATA_SUPPORT_BANDWIDTH_CONSTRAINED) 6128 .when(mSatelliteController) 6129 .getSatelliteDataServicePolicyForPlmn(anyInt(), any()); 6130 // Set network request transport as satellite in satellite network 6131 NetworkCapabilities netCaps = new NetworkCapabilities(); 6132 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE); 6133 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 6134 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_BANDWIDTH_CONSTRAINED); 6135 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 6136 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 6137 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 6138 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 6139 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 6140 processAllMessages(); 6141 6142 // Verify internet is not connected 6143 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 6144 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 6145 6146 // reset satellite network and roaming registration 6147 mIsNonTerrestrialNetwork = false; 6148 mCarrierSupportedServices.clear(); 6149 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6150 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6151 } 6152 6153 @Test testWithDataServiceCheckFlagDisabled_DataPolicySupportMode()6154 public void testWithDataServiceCheckFlagDisabled_DataPolicySupportMode() 6155 throws Exception { 6156 doReturn(false).when(mFeatureFlags).dataServiceCheck(); 6157 // set up satellite network and register data roaming 6158 mIsNonTerrestrialNetwork = true; 6159 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6160 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6161 6162 // Set network request transport with Internet capability + Not Restricted 6163 mCarrierConfig.putInt(CarrierConfigManager.KEY_SATELLITE_DATA_SUPPORT_MODE_INT, 6164 CarrierConfigManager.SATELLITE_DATA_SUPPORT_BANDWIDTH_CONSTRAINED); 6165 carrierConfigChanged(); 6166 // Set network request transport as satellite in satellite network 6167 NetworkCapabilities netCaps = new NetworkCapabilities(); 6168 netCaps.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE); 6169 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 6170 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_BANDWIDTH_CONSTRAINED); 6171 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 6172 new NetworkRequest(netCaps, ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, 6173 NetworkRequest.Type.REQUEST), mPhone, mFeatureFlags)); 6174 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 6175 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 6176 processAllMessages(); 6177 6178 // Verify internet is connected 6179 verifyInternetConnected(); 6180 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 6181 6182 // reset satellite network and roaming registration 6183 mIsNonTerrestrialNetwork = false; 6184 mCarrierSupportedServices.clear(); 6185 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 6186 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 6187 } 6188 } 6189