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 com.android.internal.telephony.data.DataNetworkController.DataNetworkControllerCallback; 20 import static com.android.internal.telephony.data.DataNetworkController.NetworkRequestList; 21 22 import static com.google.common.truth.Truth.assertThat; 23 import static com.google.common.truth.Truth.assertWithMessage; 24 25 import static org.junit.Assert.assertEquals; 26 import static org.junit.Assert.assertFalse; 27 import static org.junit.Assert.assertSame; 28 import static org.junit.Assert.assertThrows; 29 import static org.junit.Assert.assertTrue; 30 import static org.junit.Assert.fail; 31 import static org.mockito.ArgumentMatchers.any; 32 import static org.mockito.ArgumentMatchers.anyBoolean; 33 import static org.mockito.ArgumentMatchers.anyInt; 34 import static org.mockito.ArgumentMatchers.anyString; 35 import static org.mockito.ArgumentMatchers.eq; 36 import static org.mockito.Mockito.doAnswer; 37 import static org.mockito.Mockito.doReturn; 38 import static org.mockito.Mockito.never; 39 import static org.mockito.Mockito.times; 40 import static org.mockito.Mockito.verify; 41 import static org.mockito.Mockito.when; 42 43 import android.annotation.NonNull; 44 import android.content.Intent; 45 import android.net.ConnectivityManager; 46 import android.net.InetAddresses; 47 import android.net.LinkAddress; 48 import android.net.LinkProperties; 49 import android.net.NetworkCapabilities; 50 import android.net.NetworkPolicyManager; 51 import android.net.NetworkRequest; 52 import android.net.vcn.VcnManager.VcnNetworkPolicyChangeListener; 53 import android.net.vcn.VcnNetworkPolicyResult; 54 import android.os.AsyncResult; 55 import android.os.Handler; 56 import android.os.Looper; 57 import android.os.Message; 58 import android.os.PersistableBundle; 59 import android.os.RegistrantList; 60 import android.provider.Telephony; 61 import android.telephony.AccessNetworkConstants; 62 import android.telephony.AccessNetworkConstants.AccessNetworkType; 63 import android.telephony.AccessNetworkConstants.TransportType; 64 import android.telephony.Annotation.DataFailureCause; 65 import android.telephony.Annotation.NetCapability; 66 import android.telephony.Annotation.NetworkType; 67 import android.telephony.CarrierConfigManager; 68 import android.telephony.DataFailCause; 69 import android.telephony.DataSpecificRegistrationInfo; 70 import android.telephony.LteVopsSupportInfo; 71 import android.telephony.NetworkRegistrationInfo; 72 import android.telephony.NetworkRegistrationInfo.RegistrationState; 73 import android.telephony.PreciseDataConnectionState; 74 import android.telephony.ServiceState; 75 import android.telephony.SubscriptionInfo; 76 import android.telephony.SubscriptionPlan; 77 import android.telephony.TelephonyDisplayInfo; 78 import android.telephony.TelephonyManager; 79 import android.telephony.TelephonyProtoEnums; 80 import android.telephony.data.ApnSetting; 81 import android.telephony.data.DataCallResponse; 82 import android.telephony.data.DataCallResponse.LinkStatus; 83 import android.telephony.data.DataProfile; 84 import android.telephony.data.DataService; 85 import android.telephony.data.DataServiceCallback; 86 import android.telephony.data.ThrottleStatus; 87 import android.telephony.data.TrafficDescriptor; 88 import android.telephony.data.TrafficDescriptor.OsAppId; 89 import android.telephony.ims.ImsManager; 90 import android.telephony.ims.ImsMmTelManager; 91 import android.telephony.ims.ImsRcsManager; 92 import android.telephony.ims.ImsReasonInfo; 93 import android.telephony.ims.ImsRegistrationAttributes; 94 import android.telephony.ims.ImsStateCallback; 95 import android.telephony.ims.RegistrationManager.RegistrationCallback; 96 import android.telephony.ims.feature.ImsFeature; 97 import android.telephony.ims.stub.ImsRegistrationImplBase; 98 import android.testing.AndroidTestingRunner; 99 import android.testing.TestableLooper; 100 import android.util.ArraySet; 101 import android.util.SparseArray; 102 103 import com.android.internal.telephony.ISub; 104 import com.android.internal.telephony.MultiSimSettingController; 105 import com.android.internal.telephony.Phone; 106 import com.android.internal.telephony.PhoneConstants; 107 import com.android.internal.telephony.RIL; 108 import com.android.internal.telephony.TelephonyTest; 109 import com.android.internal.telephony.data.AccessNetworksManager.AccessNetworksManagerCallback; 110 import com.android.internal.telephony.data.DataEvaluation.DataDisallowedReason; 111 import com.android.internal.telephony.data.DataNetworkController.HandoverRule; 112 import com.android.internal.telephony.data.DataRetryManager.DataRetryManagerCallback; 113 import com.android.internal.telephony.data.LinkBandwidthEstimator.LinkBandwidthEstimatorCallback; 114 import com.android.internal.telephony.ims.ImsResolver; 115 116 import org.junit.After; 117 import org.junit.Before; 118 import org.junit.Test; 119 import org.junit.runner.RunWith; 120 import org.mockito.ArgumentCaptor; 121 import org.mockito.Mockito; 122 123 import java.lang.reflect.Field; 124 import java.time.Period; 125 import java.time.ZonedDateTime; 126 import java.util.ArrayList; 127 import java.util.Arrays; 128 import java.util.Collections; 129 import java.util.HashMap; 130 import java.util.List; 131 import java.util.Map; 132 import java.util.Set; 133 import java.util.concurrent.Executor; 134 135 @RunWith(AndroidTestingRunner.class) 136 @TestableLooper.RunWithLooper 137 public class DataNetworkControllerTest extends TelephonyTest { 138 private static final String IPV4_ADDRESS = "10.0.2.15"; 139 private static final String IPV6_ADDRESS = "2607:fb90:a620:651d:eabe:f8da:c107:44be"; 140 141 private static final String FAKE_MMTEL_PACKAGE = "fake.mmtel.package"; 142 private static final String FAKE_RCS_PACKAGE = "fake.rcs.package"; 143 144 // Mocked classes 145 private PhoneSwitcher mMockedPhoneSwitcher; 146 protected ISub mMockedIsub; 147 private DataNetworkControllerCallback mMockedDataNetworkControllerCallback; 148 private DataRetryManagerCallback mMockedDataRetryManagerCallback; 149 private ImsResolver mMockedImsResolver; 150 151 private ImsManager mMockedImsManager; 152 private ImsMmTelManager mMockedImsMmTelManager; 153 private ImsRcsManager mMockedImsRcsManager; 154 private ImsStateCallback mMmtelStateCallback; 155 private ImsStateCallback mRcsStateCallback; 156 private RegistrationCallback mMmtelRegCallback; 157 private RegistrationCallback mRcsRegCallback; 158 private SubscriptionInfo mMockSubInfo; 159 160 private int mNetworkRequestId = 0; 161 162 private final SparseArray<DataServiceManager> mMockedDataServiceManagers = new SparseArray<>(); 163 private final SparseArray<RegistrantList> mDataCallListChangedRegistrants = new SparseArray<>(); 164 private DataNetworkController mDataNetworkControllerUT; 165 private PersistableBundle mCarrierConfig; 166 167 private AccessNetworksManagerCallback mAccessNetworksManagerCallback; 168 private LinkBandwidthEstimatorCallback mLinkBandwidthEstimatorCallback; 169 170 private final DataProfile mGeneralPurposeDataProfile = new DataProfile.Builder() 171 .setApnSetting(new ApnSetting.Builder() 172 .setId(2163) 173 .setOperatorNumeric("12345") 174 .setEntryName("internet_supl_mms_apn") 175 .setApnName("internet_supl_mms_apn") 176 .setUser("user") 177 .setPassword("passwd") 178 .setApnTypeBitmask(ApnSetting.TYPE_DEFAULT | ApnSetting.TYPE_SUPL 179 | ApnSetting.TYPE_MMS) 180 .setProtocol(ApnSetting.PROTOCOL_IPV6) 181 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 182 .setCarrierEnabled(true) 183 .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 184 | TelephonyManager.NETWORK_TYPE_BITMASK_NR 185 | TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN 186 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT)) 187 .setLingeringNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 188 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT 189 | TelephonyManager.NETWORK_TYPE_BITMASK_UMTS 190 | TelephonyManager.NETWORK_TYPE_BITMASK_NR)) 191 .setProfileId(1234) 192 .setMaxConns(321) 193 .setWaitTime(456) 194 .setMaxConnsTime(789) 195 .build()) 196 .setPreferred(false) 197 .build(); 198 199 // The same data profile but with different auto generated ID, should be considered the same as 200 // mGeneralPurposeDataProfile 201 private final DataProfile mDuplicatedGeneralPurposeDataProfile = new DataProfile.Builder() 202 .setApnSetting(new ApnSetting.Builder() 203 .setId(3612) 204 .setOperatorNumeric("12345") 205 .setEntryName("internet_supl_mms_apn") 206 .setApnName("internet_supl_mms_apn") 207 .setUser("user") 208 .setPassword("passwd") 209 .setApnTypeBitmask(ApnSetting.TYPE_DEFAULT | ApnSetting.TYPE_SUPL 210 | ApnSetting.TYPE_MMS) 211 .setProtocol(ApnSetting.PROTOCOL_IPV6) 212 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 213 .setCarrierEnabled(true) 214 .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 215 | TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN 216 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT)) 217 .setLingeringNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 218 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT 219 | TelephonyManager.NETWORK_TYPE_BITMASK_UMTS 220 | TelephonyManager.NETWORK_TYPE_BITMASK_NR)) 221 .setProfileId(1234) 222 .setMaxConns(321) 223 .setWaitTime(456) 224 .setMaxConnsTime(789) 225 .build()) 226 .setPreferred(false) 227 .build(); 228 229 private final DataProfile mImsCellularDataProfile = new DataProfile.Builder() 230 .setApnSetting(new ApnSetting.Builder() 231 .setId(2164) 232 .setOperatorNumeric("12345") 233 .setEntryName("ims_apn") 234 .setApnName("ims_apn") 235 .setUser("user") 236 .setPassword("passwd") 237 .setApnTypeBitmask(ApnSetting.TYPE_IMS) 238 .setProtocol(ApnSetting.PROTOCOL_IPV6) 239 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 240 .setCarrierEnabled(true) 241 .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 242 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT)) 243 .setLingeringNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_LTE 244 | TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT 245 | TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN 246 | TelephonyManager.NETWORK_TYPE_BITMASK_UMTS 247 | TelephonyManager.NETWORK_TYPE_BITMASK_NR)) 248 .setProfileId(1235) 249 .setMaxConns(321) 250 .setWaitTime(456) 251 .setMaxConnsTime(789) 252 .build()) 253 .setPreferred(false) 254 .build(); 255 256 private final DataProfile mImsIwlanDataProfile = new DataProfile.Builder() 257 .setApnSetting(new ApnSetting.Builder() 258 .setId(2164) 259 .setOperatorNumeric("12345") 260 .setEntryName("ims_apn") 261 .setApnName("ims_apn") 262 .setUser("user") 263 .setPassword("passwd") 264 .setApnTypeBitmask(ApnSetting.TYPE_IMS) 265 .setProtocol(ApnSetting.PROTOCOL_IPV6) 266 .setRoamingProtocol(ApnSetting.PROTOCOL_IPV6) 267 .setCarrierEnabled(true) 268 .setNetworkTypeBitmask((int) (TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN)) 269 .setProfileId(1235) 270 .setMaxConns(321) 271 .setWaitTime(456) 272 .setMaxConnsTime(789) 273 .build()) 274 .setPreferred(false) 275 .build(); 276 277 private final DataProfile mEmergencyDataProfile = new DataProfile.Builder() 278 .setApnSetting(new ApnSetting.Builder() 279 .setEntryName("DEFAULT EIMS") 280 .setId(2165) 281 .setProtocol(ApnSetting.PROTOCOL_IPV4V6) 282 .setRoamingProtocol(ApnSetting.PROTOCOL_IPV4V6) 283 .setApnName("sos") 284 .setApnTypeBitmask(ApnSetting.TYPE_EMERGENCY) 285 .setCarrierEnabled(true) 286 .setApnSetId(Telephony.Carriers.MATCH_ALL_APN_SET_ID) 287 .build()) 288 .build(); 289 290 private final DataProfile mFotaDataProfile = new DataProfile.Builder() 291 .setApnSetting(new ApnSetting.Builder() 292 .setId(2166) 293 .setOperatorNumeric("12345") 294 .setEntryName("fota_apn") 295 .setApnName("fota_apn") 296 .setUser("user") 297 .setPassword("passwd") 298 .setApnTypeBitmask(ApnSetting.TYPE_FOTA) 299 .setProtocol(ApnSetting.PROTOCOL_IPV6) 300 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 301 .setCarrierEnabled(true) 302 .setNetworkTypeBitmask((int) TelephonyManager.NETWORK_TYPE_BITMASK_LTE 303 | (int) TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT) 304 .setProfileId(1236) 305 .setMaxConns(321) 306 .setWaitTime(456) 307 .setMaxConnsTime(789) 308 .build()) 309 .setPreferred(false) 310 .build(); 311 312 private final DataProfile mTetheringDataProfile = new DataProfile.Builder() 313 .setApnSetting(new ApnSetting.Builder() 314 .setId(2167) 315 .setOperatorNumeric("12345") 316 .setEntryName("dun_apn") 317 .setApnName("dun_apn") 318 .setUser("user") 319 .setPassword("passwd") 320 .setApnTypeBitmask(ApnSetting.TYPE_DUN) 321 .setProtocol(ApnSetting.PROTOCOL_IPV6) 322 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 323 .setCarrierEnabled(true) 324 .setNetworkTypeBitmask((int) TelephonyManager.NETWORK_TYPE_BITMASK_LTE 325 | (int) TelephonyManager.NETWORK_TYPE_BITMASK_1xRTT) 326 .setProfileId(1236) 327 .setMaxConns(321) 328 .setWaitTime(456) 329 .setMaxConnsTime(789) 330 .build()) 331 .setPreferred(false) 332 .build(); 333 334 private final DataProfile mEnterpriseDataProfile = new DataProfile.Builder() 335 .setTrafficDescriptor(new TrafficDescriptor(null, 336 new TrafficDescriptor.OsAppId(TrafficDescriptor.OsAppId.ANDROID_OS_ID, 337 "ENTERPRISE", 1).getBytes())) 338 .build(); 339 340 /** Data call response map. The first key is the transport type, the second key is the cid. */ 341 private final Map<Integer, Map<Integer, DataCallResponse>> mDataCallResponses = new HashMap<>(); 342 createDataCallResponse(int cid, @LinkStatus int linkStatus)343 private @NonNull DataCallResponse createDataCallResponse(int cid, @LinkStatus int linkStatus) { 344 return createDataCallResponse(cid, linkStatus, Collections.emptyList()); 345 } 346 createDataCallResponse(int cid, @LinkStatus int linkStatus, @NonNull List<TrafficDescriptor> tdList)347 private @NonNull DataCallResponse createDataCallResponse(int cid, @LinkStatus int linkStatus, 348 @NonNull List<TrafficDescriptor> tdList) { 349 return new DataCallResponse.Builder() 350 .setCause(0) 351 .setRetryDurationMillis(-1L) 352 .setId(cid) 353 .setLinkStatus(linkStatus) 354 .setProtocolType(ApnSetting.PROTOCOL_IPV4V6) 355 .setInterfaceName("ifname" + cid) 356 .setAddresses(Arrays.asList( 357 new LinkAddress(InetAddresses.parseNumericAddress(IPV4_ADDRESS), 32), 358 new LinkAddress(IPV6_ADDRESS + "/64"))) 359 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress("10.0.2.3"), 360 InetAddresses.parseNumericAddress("fd00:976a::9"))) 361 .setGatewayAddresses(Arrays.asList( 362 InetAddresses.parseNumericAddress("10.0.2.15"), 363 InetAddresses.parseNumericAddress("fe80::2"))) 364 .setPcscfAddresses(Arrays.asList( 365 InetAddresses.parseNumericAddress("fd00:976a:c305:1d::8"), 366 InetAddresses.parseNumericAddress("fd00:976a:c202:1d::7"), 367 InetAddresses.parseNumericAddress("fd00:976a:c305:1d::5"))) 368 .setMtu(1500) 369 .setMtuV4(1500) 370 .setMtuV6(1500) 371 .setPduSessionId(1) 372 .setQosBearerSessions(new ArrayList<>()) 373 .setTrafficDescriptors(tdList) 374 .build(); 375 } 376 setFailedSetupDataResponse(DataServiceManager dsm, @DataFailureCause int cause, long retryMillis, boolean forHandover)377 private void setFailedSetupDataResponse(DataServiceManager dsm, @DataFailureCause int cause, 378 long retryMillis, boolean forHandover) { 379 setFailedSetupDataResponse(dsm, cause, retryMillis, forHandover, 0); 380 } 381 setFailedSetupDataResponse(DataServiceManager dsm, @DataFailureCause int cause, long retryMillis, boolean forHandover, long delay)382 private void setFailedSetupDataResponse(DataServiceManager dsm, @DataFailureCause int cause, 383 long retryMillis, boolean forHandover, long delay) { 384 doAnswer(invocation -> { 385 final Message msg = (Message) invocation.getArguments()[10]; 386 387 DataCallResponse response = new DataCallResponse.Builder() 388 .setCause(cause) 389 .setRetryDurationMillis(retryMillis) 390 .setHandoverFailureMode( 391 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_HANDOVER) 392 .build(); 393 msg.getData().putParcelable("data_call_response", response); 394 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 395 msg.getTarget().sendMessageDelayed(msg, delay); 396 return null; 397 }).when(dsm).setupDataCall(anyInt(), any(DataProfile.class), anyBoolean(), 398 anyBoolean(), forHandover ? eq(DataService.REQUEST_REASON_HANDOVER) 399 : eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), 400 anyBoolean(), any(Message.class)); 401 } 402 setSuccessfulSetupDataResponse(DataServiceManager dsm, DataCallResponse response)403 private void setSuccessfulSetupDataResponse(DataServiceManager dsm, DataCallResponse response) { 404 doAnswer(invocation -> { 405 final Message msg = (Message) invocation.getArguments()[10]; 406 407 int transport = AccessNetworkConstants.TRANSPORT_TYPE_INVALID; 408 if (dsm == mMockedWwanDataServiceManager) { 409 transport = AccessNetworkConstants.TRANSPORT_TYPE_WWAN; 410 } else if (dsm == mMockedWlanDataServiceManager) { 411 transport = AccessNetworkConstants.TRANSPORT_TYPE_WLAN; 412 } 413 mDataCallResponses.computeIfAbsent(transport, v -> new HashMap<>()); 414 mDataCallResponses.get(transport).put(response.getId(), response); 415 msg.getData().putParcelable("data_call_response", response); 416 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 417 msg.sendToTarget(); 418 419 mDataCallListChangedRegistrants.get(transport).notifyRegistrants( 420 new AsyncResult(transport, new ArrayList<>(mDataCallResponses.get( 421 transport).values()), null)); 422 return null; 423 }).when(dsm).setupDataCall(anyInt(), any(DataProfile.class), anyBoolean(), 424 anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 425 any(Message.class)); 426 } 427 setSuccessfulSetupDataResponse(DataServiceManager dsm, int cid)428 private void setSuccessfulSetupDataResponse(DataServiceManager dsm, int cid) { 429 setSuccessfulSetupDataResponse(dsm, cid, 0L); 430 } 431 setSuccessfulSetupDataResponse(DataServiceManager dsm, int cid, long delay)432 private void setSuccessfulSetupDataResponse(DataServiceManager dsm, int cid, long delay) { 433 doAnswer(invocation -> { 434 final Message msg = (Message) invocation.getArguments()[10]; 435 436 DataCallResponse response = createDataCallResponse(cid, 437 DataCallResponse.LINK_STATUS_ACTIVE); 438 int transport = AccessNetworkConstants.TRANSPORT_TYPE_INVALID; 439 if (dsm == mMockedWwanDataServiceManager) { 440 transport = AccessNetworkConstants.TRANSPORT_TYPE_WWAN; 441 } else if (dsm == mMockedWlanDataServiceManager) { 442 transport = AccessNetworkConstants.TRANSPORT_TYPE_WLAN; 443 } 444 mDataCallResponses.computeIfAbsent(transport, v -> new HashMap<>()); 445 mDataCallResponses.get(transport).put(cid, response); 446 msg.getData().putParcelable("data_call_response", response); 447 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 448 msg.getTarget().sendMessageDelayed(msg, delay); 449 450 final int t = transport; 451 msg.getTarget().postDelayed(() -> { 452 mDataCallListChangedRegistrants.get(t).notifyRegistrants( 453 new AsyncResult(t, new ArrayList<>(mDataCallResponses.get( 454 t).values()), null)); 455 456 }, delay + 100); 457 return null; 458 }).when(dsm).setupDataCall(anyInt(), any(DataProfile.class), anyBoolean(), 459 anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 460 any(Message.class)); 461 } 462 clearCallbacks()463 private void clearCallbacks() throws Exception { 464 Field field = DataNetworkController.class 465 .getDeclaredField("mDataNetworkControllerCallbacks"); 466 field.setAccessible(true); 467 ((Set<DataNetworkControllerCallback>) field.get(mDataNetworkControllerUT)).clear(); 468 } 469 carrierConfigChanged()470 private void carrierConfigChanged() { 471 // Trigger carrier config reloading 472 Intent intent = new Intent(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED); 473 intent.putExtra(CarrierConfigManager.EXTRA_SLOT_INDEX, 0); 474 mContext.sendBroadcast(intent); 475 processAllMessages(); 476 } 477 setImsRegistered(boolean registered)478 private void setImsRegistered(boolean registered) { 479 if (registered) { 480 final ArraySet<String> features = new ArraySet<>(); 481 features.add("feature1"); 482 features.add("feature2"); 483 ImsRegistrationAttributes attr = new ImsRegistrationAttributes.Builder( 484 ImsRegistrationImplBase.REGISTRATION_TECH_LTE).setFeatureTags(features).build(); 485 486 mMmtelRegCallback.onRegistered(attr); 487 } else { 488 ImsReasonInfo info = new ImsReasonInfo(ImsReasonInfo.CODE_LOCAL_ILLEGAL_STATE, -1, ""); 489 mMmtelRegCallback.onUnregistered(info); 490 } 491 } 492 setRcsRegistered(boolean registered)493 private void setRcsRegistered(boolean registered) { 494 if (registered) { 495 final ArraySet<String> features = new ArraySet<>(); 496 features.add("feature1"); 497 features.add("feature2"); 498 ImsRegistrationAttributes attr = new ImsRegistrationAttributes.Builder( 499 ImsRegistrationImplBase.REGISTRATION_TECH_LTE).setFeatureTags(features).build(); 500 501 mRcsRegCallback.onRegistered(attr); 502 } else { 503 ImsReasonInfo info = new ImsReasonInfo(ImsReasonInfo.CODE_LOCAL_ILLEGAL_STATE, -1, ""); 504 mRcsRegCallback.onUnregistered(info); 505 } 506 } 507 serviceStateChanged(@etworkType int networkType, @RegistrationState int regState)508 private void serviceStateChanged(@NetworkType int networkType, 509 @RegistrationState int regState) { 510 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo(8, false, true, true, 511 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 512 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)); 513 514 serviceStateChanged(networkType, regState, regState, 515 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 516 } 517 serviceStateChanged(@etworkType int networkType, @RegistrationState int regState, DataSpecificRegistrationInfo dsri)518 private void serviceStateChanged(@NetworkType int networkType, 519 @RegistrationState int regState, DataSpecificRegistrationInfo dsri) { 520 serviceStateChanged(networkType, regState, regState, 521 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 522 } 523 serviceStateChanged(@etworkType int networkType, @RegistrationState int dataRegState, @RegistrationState int voiceRegState, @RegistrationState int iwlanRegState, DataSpecificRegistrationInfo dsri)524 private void serviceStateChanged(@NetworkType int networkType, 525 @RegistrationState int dataRegState, @RegistrationState int voiceRegState, 526 @RegistrationState int iwlanRegState, DataSpecificRegistrationInfo dsri) { 527 if (dsri == null) { 528 dsri = new DataSpecificRegistrationInfo(8, false, true, true, 529 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 530 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)); 531 } 532 533 ServiceState ss = new ServiceState(); 534 535 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 536 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 537 .setAccessNetworkTechnology(networkType) 538 .setRegistrationState(dataRegState) 539 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 540 .setDataSpecificInfo(dsri) 541 .build()); 542 543 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 544 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 545 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN) 546 .setRegistrationState(iwlanRegState) 547 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 548 .build()); 549 550 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 551 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 552 .setAccessNetworkTechnology(networkType) 553 .setRegistrationState(voiceRegState) 554 .setDomain(NetworkRegistrationInfo.DOMAIN_CS) 555 .build()); 556 ss.setDataRoamingFromRegistration(dataRegState 557 == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 558 processServiceStateRegStateForTest(ss); 559 560 doReturn(ss).when(mSST).getServiceState(); 561 doReturn(ss).when(mPhone).getServiceState(); 562 563 mDataNetworkControllerUT.obtainMessage(17/*EVENT_SERVICE_STATE_CHANGED*/).sendToTarget(); 564 processAllMessages(); 565 } 566 567 // set SS reg state base on SST impl, where WLAN overrides WWAN's data reg. processServiceStateRegStateForTest(ServiceState ss)568 private void processServiceStateRegStateForTest(ServiceState ss) { 569 int wlanRegState = ss.getNetworkRegistrationInfo(NetworkRegistrationInfo.DOMAIN_PS, 570 AccessNetworkConstants.TRANSPORT_TYPE_WLAN).getRegistrationState(); 571 if (wlanRegState == NetworkRegistrationInfo.REGISTRATION_STATE_HOME) { 572 ss.setDataRegState(ServiceState.STATE_IN_SERVICE); 573 } else { 574 int cellularRegState = ss.getNetworkRegistrationInfo(NetworkRegistrationInfo.DOMAIN_PS, 575 AccessNetworkConstants.TRANSPORT_TYPE_WWAN).getRegistrationState(); 576 int dataState = (cellularRegState == NetworkRegistrationInfo.REGISTRATION_STATE_HOME 577 || cellularRegState == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING) 578 ? ServiceState.STATE_IN_SERVICE : ServiceState.STATE_OUT_OF_SERVICE; 579 ss.setDataRegState(dataState); 580 } 581 int voiceRegState = ss.getNetworkRegistrationInfo(NetworkRegistrationInfo.DOMAIN_CS, 582 AccessNetworkConstants.TRANSPORT_TYPE_WWAN).getRegistrationState(); 583 int voiceState = (voiceRegState == NetworkRegistrationInfo.REGISTRATION_STATE_HOME 584 || voiceRegState == NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING) 585 ? ServiceState.STATE_IN_SERVICE : ServiceState.STATE_OUT_OF_SERVICE; 586 ss.setVoiceRegState(voiceState); 587 } 588 updateTransport(@etCapability int capability, @TransportType int transport)589 private void updateTransport(@NetCapability int capability, @TransportType int transport) { 590 doReturn(transport).when(mAccessNetworksManager) 591 .getPreferredTransportByNetworkCapability(capability); 592 mAccessNetworksManagerCallback.onPreferredTransportChanged(capability); 593 processAllMessages(); 594 } 595 setVcnManagerPolicy(boolean vcnManaged, boolean shouldTearDown)596 private void setVcnManagerPolicy(boolean vcnManaged, boolean shouldTearDown) { 597 doAnswer(invocation -> { 598 final NetworkCapabilities networkCapabilities = 599 (NetworkCapabilities) invocation.getArguments()[0]; 600 if (vcnManaged) { 601 networkCapabilities.removeCapability( 602 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED); 603 } else { 604 networkCapabilities.addCapability( 605 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED); 606 } 607 return new VcnNetworkPolicyResult( 608 shouldTearDown, networkCapabilities); 609 }).when(mVcnManager).applyVcnNetworkPolicy(any(NetworkCapabilities.class), 610 any(LinkProperties.class)); 611 } 612 initializeConfig()613 private void initializeConfig() { 614 mCarrierConfig = mContextFixture.getCarrierConfigBundle(); 615 mCarrierConfig.putStringArray( 616 CarrierConfigManager.KEY_TELEPHONY_NETWORK_CAPABILITY_PRIORITIES_STRING_ARRAY, 617 new String[]{ 618 "eims:90", "supl:80", "mms:70", "xcap:70", "cbs:50", "mcx:50", "fota:50", 619 "ims:40", "dun:30", "enterprise:20", "internet:20" 620 }); 621 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CONFIG_APPLIED_BOOL, true); 622 mCarrierConfig.putStringArray( 623 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 624 new String[]{"default", "mms", "dun", "supl"}); 625 mCarrierConfig.putStringArray( 626 CarrierConfigManager.KEY_CARRIER_METERED_ROAMING_APN_TYPES_STRINGS, 627 new String[]{"default", "mms", "dun", "supl"}); 628 629 mCarrierConfig.putStringArray( 630 CarrierConfigManager.KEY_TELEPHONY_DATA_SETUP_RETRY_RULES_STRING_ARRAY, 631 new String[]{ 632 "capabilities=eims, retry_interval=1000, maximum_retries=20", 633 "permanent_fail_causes=8|27|28|29|30|32|33|35|50|51|111|-5|-6|65537|65538|" 634 + "-3|65543|65547|2252|2253|2254, retry_interval=2500", 635 "capabilities=mms|supl|cbs, retry_interval=2000", 636 "capabilities=internet|enterprise|dun|ims|fota, retry_interval=2500|3000|" 637 + "5000|10000|15000|20000|40000|60000|120000|240000|" 638 + "600000|1200000|1800000, maximum_retries=20" 639 }); 640 mCarrierConfig.putStringArray( 641 CarrierConfigManager.KEY_TELEPHONY_DATA_HANDOVER_RETRY_RULES_STRING_ARRAY, 642 new String[] {"retry_interval=1000|2000|4000|8000|16000, maximum_retries=5" 643 }); 644 645 mCarrierConfig.putInt(CarrierConfigManager.KEY_NR_ADVANCED_CAPABLE_PCO_ID_INT, 1234); 646 647 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_NETWORK_TEMP_NOT_METERED_SUPPORTED_BOOL, 648 true); 649 650 mCarrierConfig.putIntArray(CarrierConfigManager.KEY_ONLY_SINGLE_DC_ALLOWED_INT_ARRAY, 651 new int[]{TelephonyManager.NETWORK_TYPE_CDMA, TelephonyManager.NETWORK_TYPE_1xRTT, 652 TelephonyManager.NETWORK_TYPE_EVDO_0, TelephonyManager.NETWORK_TYPE_EVDO_A, 653 TelephonyManager.NETWORK_TYPE_EVDO_B}); 654 655 mCarrierConfig.putIntArray(CarrierConfigManager 656 .KEY_CAPABILITIES_EXEMPT_FROM_SINGLE_DC_CHECK_INT_ARRAY, 657 new int[]{NetworkCapabilities.NET_CAPABILITY_IMS}); 658 659 mContextFixture.putResource(com.android.internal.R.string.config_bandwidthEstimateSource, 660 "bandwidth_estimator"); 661 662 mContextFixture.putIntResource(com.android.internal.R.integer 663 .config_delay_for_ims_dereg_millis, 3000); 664 mContextFixture.putBooleanResource(com.android.internal.R.bool 665 .config_enable_iwlan_handover_policy, true); 666 mContextFixture.putBooleanResource(com.android.internal.R.bool 667 .config_enhanced_iwlan_handover_check, true); 668 } 669 670 @Before setUp()671 public void setUp() throws Exception { 672 logd("DataNetworkControllerTest +Setup!"); 673 super.setUp(getClass().getSimpleName()); 674 mMockedPhoneSwitcher = Mockito.mock(PhoneSwitcher.class); 675 mMockedIsub = Mockito.mock(ISub.class); 676 mMockedImsManager = mContext.getSystemService(ImsManager.class); 677 mMockedImsMmTelManager = Mockito.mock(ImsMmTelManager.class); 678 mMockedImsRcsManager = Mockito.mock(ImsRcsManager.class); 679 mMockedImsResolver = Mockito.mock(ImsResolver.class); 680 mMockedDataNetworkControllerCallback = Mockito.mock(DataNetworkControllerCallback.class); 681 mMockedDataRetryManagerCallback = Mockito.mock(DataRetryManagerCallback.class); 682 mMockSubInfo = Mockito.mock(SubscriptionInfo.class); 683 when(mTelephonyComponentFactory.makeDataSettingsManager(any(Phone.class), 684 any(DataNetworkController.class), any(Looper.class), 685 any(DataSettingsManager.DataSettingsManagerCallback.class))).thenCallRealMethod(); 686 doReturn(mMockedImsMmTelManager).when(mMockedImsManager).getImsMmTelManager(anyInt()); 687 doReturn(mMockedImsRcsManager).when(mMockedImsManager).getImsRcsManager(anyInt()); 688 689 initializeConfig(); 690 mMockedDataServiceManagers.put(AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 691 mMockedWwanDataServiceManager); 692 mMockedDataServiceManagers.put(AccessNetworkConstants.TRANSPORT_TYPE_WLAN, 693 mMockedWlanDataServiceManager); 694 695 replaceInstance(PhoneSwitcher.class, "sPhoneSwitcher", null, mMockedPhoneSwitcher); 696 doReturn(1).when(mMockedIsub).getDefaultDataSubId(); 697 doReturn(mMockedIsub).when(mIBinder).queryLocalInterface(anyString()); 698 doReturn(mPhone).when(mPhone).getImsPhone(); 699 mServiceManagerMockedServices.put("isub", mIBinder); 700 doReturn(new SubscriptionPlan[]{}).when(mNetworkPolicyManager) 701 .getSubscriptionPlans(anyInt(), any()); 702 doReturn(true).when(mSST).getDesiredPowerState(); 703 doReturn(true).when(mSST).getPowerStateFromCarrier(); 704 doReturn(true).when(mSST).isConcurrentVoiceAndDataAllowed(); 705 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 706 doReturn("").when(mSubscriptionController).getDataEnabledOverrideRules(anyInt()); 707 doReturn(true).when(mSubscriptionController).setDataEnabledOverrideRules( 708 anyInt(), anyString()); 709 710 List<SubscriptionInfo> infoList = new ArrayList<>(); 711 infoList.add(mMockSubInfo); 712 doReturn(infoList).when(mSubscriptionController).getSubscriptionsInGroup( 713 any(), any(), any()); 714 doReturn(true).when(mSubscriptionController).isActiveSubId(anyInt()); 715 doReturn(0).when(mSubscriptionController).getPhoneId(anyInt()); 716 717 for (int transport : new int[]{AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 718 AccessNetworkConstants.TRANSPORT_TYPE_WLAN}) { 719 mDataCallListChangedRegistrants.put(transport, new RegistrantList()); 720 setSuccessfulSetupDataResponse(mMockedDataServiceManagers.get(transport), 1); 721 doAnswer(invocation -> { 722 int cid = (int) invocation.getArguments()[0]; 723 Message msg = (Message) invocation.getArguments()[2]; 724 msg.sendToTarget(); 725 mDataCallResponses.get(transport).remove(cid); 726 mDataCallListChangedRegistrants.get(transport).notifyRegistrants( 727 new AsyncResult(transport, new ArrayList<>(mDataCallResponses.get( 728 transport).values()), null)); 729 return null; 730 }).when(mMockedDataServiceManagers.get(transport)).deactivateDataCall( 731 anyInt(), anyInt(), any(Message.class)); 732 733 doAnswer(invocation -> { 734 Handler h = (Handler) invocation.getArguments()[0]; 735 int what = (int) invocation.getArguments()[1]; 736 mDataCallListChangedRegistrants.get(transport).addUnique(h, what, transport); 737 return null; 738 }).when(mMockedDataServiceManagers.get(transport)).registerForDataCallListChanged(any( 739 Handler.class), anyInt()); 740 741 doAnswer(invocation -> { 742 Message msg = (Message) invocation.getArguments()[1]; 743 msg.sendToTarget(); 744 return null; 745 }).when(mMockedDataServiceManagers.get(transport)).startHandover(anyInt(), 746 any(Message.class)); 747 748 doAnswer(invocation -> { 749 Message msg = (Message) invocation.getArguments()[1]; 750 msg.sendToTarget(); 751 return null; 752 }).when(mMockedDataServiceManagers.get(transport)).cancelHandover(anyInt(), 753 any(Message.class)); 754 } 755 756 doReturn(-1).when(mPhone).getSubId(); 757 758 // Note that creating a "real" data network controller will also result in creating 759 // real DataRetryManager, DataConfigManager, etc...Normally in unit test we should isolate 760 // other modules and make them mocked, but only focusing on testing the unit we would like 761 // to test, in this case, DataNetworkController. But since there are too many interactions 762 // between DataNetworkController and its sub-modules, we intend to make those modules "real" 763 // as well, except some modules below we replaced with mocks. 764 mDataNetworkControllerUT = new DataNetworkController(mPhone, Looper.myLooper()); 765 doReturn(mDataNetworkControllerUT).when(mPhone).getDataNetworkController(); 766 767 doReturn(1).when(mPhone).getSubId(); 768 mDataNetworkControllerUT.obtainMessage(15/*EVENT_SUBSCRIPTION_CHANGED*/).sendToTarget(); 769 770 processAllMessages(); 771 // Clear the callbacks created by the real sub-modules created by DataNetworkController. 772 clearCallbacks(); 773 SparseArray<DataServiceManager> dataServiceManagers = new SparseArray<>(); 774 dataServiceManagers.put(AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 775 mMockedWwanDataServiceManager); 776 dataServiceManagers.put(AccessNetworkConstants.TRANSPORT_TYPE_WLAN, 777 mMockedWlanDataServiceManager); 778 replaceInstance(DataNetworkController.class, "mDataServiceManagers", 779 mDataNetworkControllerUT, dataServiceManagers); 780 replaceInstance(DataNetworkController.class, "mDataProfileManager", 781 mDataNetworkControllerUT, mDataProfileManager); 782 replaceInstance(DataNetworkController.class, "mAccessNetworksManager", 783 mDataNetworkControllerUT, mAccessNetworksManager); 784 replaceInstance(ImsResolver.class, "sInstance", null, mMockedImsResolver); 785 786 ArgumentCaptor<AccessNetworksManagerCallback> callbackCaptor = 787 ArgumentCaptor.forClass(AccessNetworksManagerCallback.class); 788 verify(mAccessNetworksManager).registerCallback(callbackCaptor.capture()); 789 mAccessNetworksManagerCallback = callbackCaptor.getValue(); 790 791 ArgumentCaptor<LinkBandwidthEstimatorCallback> linkBandwidthEstimatorCallbackCaptor = 792 ArgumentCaptor.forClass(LinkBandwidthEstimatorCallback.class); 793 verify(mLinkBandwidthEstimator).registerCallback( 794 linkBandwidthEstimatorCallbackCaptor.capture()); 795 mLinkBandwidthEstimatorCallback = linkBandwidthEstimatorCallbackCaptor.getValue(); 796 797 List<DataProfile> profiles = List.of(mGeneralPurposeDataProfile, mImsCellularDataProfile, 798 mImsIwlanDataProfile, mEmergencyDataProfile, mFotaDataProfile, 799 mTetheringDataProfile); 800 801 doAnswer(invocation -> { 802 DataProfile dp = (DataProfile) invocation.getArguments()[0]; 803 804 if (dp.getApnSetting() == null) return true; 805 806 for (DataProfile dataProfile : profiles) { 807 if (dataProfile.getApnSetting() != null 808 && dataProfile.getApnSetting().equals(dp.getApnSetting(), false)) { 809 return true; 810 } 811 } 812 return null; 813 }).when(mDataProfileManager).isDataProfileCompatible(any(DataProfile.class)); 814 815 doAnswer(invocation -> { 816 DataProfile a = (DataProfile) invocation.getArguments()[0]; 817 DataProfile b = (DataProfile) invocation.getArguments()[1]; 818 return a != null 819 && b != null 820 && a.getApnSetting() != null 821 && a.getApnSetting().equals(b.getApnSetting(), 822 mPhone.getServiceState().getDataRoamingFromRegistration()); 823 }).when(mDataProfileManager).areDataProfilesSharingApn(any(DataProfile.class), 824 any(DataProfile.class)); 825 826 doAnswer(invocation -> { 827 TelephonyNetworkRequest networkRequest = 828 (TelephonyNetworkRequest) invocation.getArguments()[0]; 829 int networkType = (int) invocation.getArguments()[1]; 830 boolean ignorePermanentFailure = (boolean) invocation.getArguments()[2]; 831 832 for (DataProfile dataProfile : profiles) { 833 if (dataProfile.canSatisfy(networkRequest.getCapabilities()) 834 && (dataProfile.getApnSetting().getNetworkTypeBitmask() == 0 835 || (dataProfile.getApnSetting().getNetworkTypeBitmask() 836 & ServiceState.getBitmaskForTech(networkType)) != 0) 837 && (ignorePermanentFailure || (dataProfile.getApnSetting() != null 838 && !dataProfile.getApnSetting().getPermanentFailed()))) { 839 return dataProfile; 840 } 841 } 842 logd("Cannot find data profile to satisfy " + networkRequest + ", network type=" 843 + TelephonyManager.getNetworkTypeName(networkType)); 844 return null; 845 }).when(mDataProfileManager).getDataProfileForNetworkRequest( 846 any(TelephonyNetworkRequest.class), anyInt(), anyBoolean()); 847 848 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 849 .getPreferredTransportByNetworkCapability(anyInt()); 850 doReturn(true).when(mDataProfileManager).isDataProfilePreferred(any(DataProfile.class)); 851 852 doAnswer(invocation -> { 853 ((Runnable) invocation.getArguments()[0]).run(); 854 return null; 855 }).when(mMockedDataNetworkControllerCallback).invokeFromExecutor(any(Runnable.class)); 856 doAnswer(invocation -> { 857 ((Runnable) invocation.getArguments()[0]).run(); 858 return null; 859 }).when(mMockedDataRetryManagerCallback).invokeFromExecutor(any(Runnable.class)); 860 861 mDataNetworkControllerUT.registerDataNetworkControllerCallback( 862 mMockedDataNetworkControllerCallback); 863 864 mDataNetworkControllerUT.obtainMessage(9/*EVENT_SIM_STATE_CHANGED*/, 865 10/*SIM_STATE_LOADED*/, 0).sendToTarget(); 866 mDataNetworkControllerUT.obtainMessage(8/*EVENT_DATA_SERVICE_BINDING_CHANGED*/, 867 new AsyncResult(AccessNetworkConstants.TRANSPORT_TYPE_WWAN, true, null)) 868 .sendToTarget(); 869 mDataNetworkControllerUT.obtainMessage(8/*EVENT_DATA_SERVICE_BINDING_CHANGED*/, 870 new AsyncResult(AccessNetworkConstants.TRANSPORT_TYPE_WLAN, true, null)) 871 .sendToTarget(); 872 873 ArgumentCaptor<ImsStateCallback> imsCallbackCaptor = 874 ArgumentCaptor.forClass(ImsStateCallback.class); 875 verify(mMockedImsMmTelManager).registerImsStateCallback(any(Executor.class), 876 imsCallbackCaptor.capture()); 877 mMmtelStateCallback = imsCallbackCaptor.getValue(); 878 879 verify(mMockedImsRcsManager).registerImsStateCallback(any(Executor.class), 880 imsCallbackCaptor.capture()); 881 mRcsStateCallback = imsCallbackCaptor.getValue(); 882 883 carrierConfigChanged(); 884 885 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 886 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 887 888 // IMS registration 889 doReturn(FAKE_MMTEL_PACKAGE).when(mMockedImsResolver).getConfiguredImsServicePackageName( 890 anyInt(), eq(ImsFeature.FEATURE_MMTEL)); 891 doReturn(FAKE_RCS_PACKAGE).when(mMockedImsResolver).getConfiguredImsServicePackageName( 892 anyInt(), eq(ImsFeature.FEATURE_RCS)); 893 894 mMmtelStateCallback.onAvailable(); 895 mRcsStateCallback.onAvailable(); 896 897 ArgumentCaptor<RegistrationCallback> regCallbackCaptor = 898 ArgumentCaptor.forClass(RegistrationCallback.class); 899 900 verify(mMockedImsMmTelManager).registerImsRegistrationCallback(any(Executor.class), 901 regCallbackCaptor.capture()); 902 mMmtelRegCallback = regCallbackCaptor.getValue(); 903 904 verify(mMockedImsRcsManager).registerImsRegistrationCallback(any(Executor.class), 905 regCallbackCaptor.capture()); 906 mRcsRegCallback = regCallbackCaptor.getValue(); 907 908 processAllMessages(); 909 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 910 911 logd("DataNetworkControllerTest -Setup!"); 912 } 913 914 @After tearDown()915 public void tearDown() throws Exception { 916 logd("tearDown"); 917 mMockedDataServiceManagers.clear(); 918 mDataCallListChangedRegistrants.clear(); 919 mDataNetworkControllerUT = null; 920 mCarrierConfig = null; 921 super.tearDown(); 922 } 923 createNetworkRequest(Integer... capabilities)924 private @NonNull TelephonyNetworkRequest createNetworkRequest(Integer... capabilities) { 925 NetworkCapabilities netCaps = new NetworkCapabilities(); 926 for (int networkCapability : capabilities) { 927 netCaps.addCapability(networkCapability); 928 } 929 930 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 931 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 932 933 return new TelephonyNetworkRequest(nativeNetworkRequest, mPhone); 934 } 935 936 // The purpose of this test is to make sure the network request insertion/removal works as 937 // expected, and make sure it is always sorted. 938 @Test testNetworkRequestList()939 public void testNetworkRequestList() { 940 NetworkRequestList networkRequestList = new NetworkRequestList(); 941 942 TelephonyNetworkRequest internetNetworkRequest = createNetworkRequest( 943 NetworkCapabilities.NET_CAPABILITY_INTERNET); 944 TelephonyNetworkRequest eimsNetworkRequest = createNetworkRequest( 945 NetworkCapabilities.NET_CAPABILITY_EIMS); 946 TelephonyNetworkRequest mmsNetworkRequest = createNetworkRequest( 947 NetworkCapabilities.NET_CAPABILITY_MMS); 948 networkRequestList.add(internetNetworkRequest); 949 networkRequestList.add(eimsNetworkRequest); 950 networkRequestList.add(mmsNetworkRequest); 951 952 // Check if emergency has the highest priority, then mms, then internet. 953 assertThat(networkRequestList.get(0).getCapabilities()[0]) 954 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_EIMS); 955 assertThat(networkRequestList.get(1).getCapabilities()[0]) 956 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_MMS); 957 assertThat(networkRequestList.get(2).getCapabilities()[0]) 958 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_INTERNET); 959 960 // Add IMS 961 TelephonyNetworkRequest imsNetworkRequest = createNetworkRequest( 962 NetworkCapabilities.NET_CAPABILITY_IMS); 963 assertThat(networkRequestList.add(imsNetworkRequest)).isTrue(); 964 965 assertThat(networkRequestList.get(0).getCapabilities()[0]) 966 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_EIMS); 967 assertThat(networkRequestList.get(1).getCapabilities()[0]) 968 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_MMS); 969 assertThat(networkRequestList.get(2).getCapabilities()[0]) 970 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 971 assertThat(networkRequestList.get(3).getCapabilities()[0]) 972 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_INTERNET); 973 974 // Add IMS again 975 assertThat(networkRequestList.add(imsNetworkRequest)).isFalse(); 976 assertThat(networkRequestList.size()).isEqualTo(4); 977 978 // Remove MMS 979 assertThat(networkRequestList.remove(mmsNetworkRequest)).isTrue(); 980 assertThat(networkRequestList.get(0).getCapabilities()[0]) 981 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_EIMS); 982 assertThat(networkRequestList.get(1).getCapabilities()[0]) 983 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 984 assertThat(networkRequestList.get(2).getCapabilities()[0]) 985 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_INTERNET); 986 987 // Remove EIMS 988 assertThat(networkRequestList.remove(eimsNetworkRequest)).isTrue(); 989 assertThat(networkRequestList.get(0).getCapabilities()[0]) 990 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 991 assertThat(networkRequestList.get(1).getCapabilities()[0]) 992 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_INTERNET); 993 994 // Remove Internet 995 assertThat(networkRequestList.remove(internetNetworkRequest)).isTrue(); 996 assertThat(networkRequestList.get(0).getCapabilities()[0]) 997 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 998 999 // Remove XCAP (which does not exist) 1000 assertThat(networkRequestList.remove( 1001 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_XCAP))).isFalse(); 1002 assertThat(networkRequestList.get(0).getCapabilities()[0]) 1003 .isEqualTo(NetworkCapabilities.NET_CAPABILITY_IMS); 1004 1005 // Remove IMS 1006 assertThat(networkRequestList.remove(imsNetworkRequest)).isTrue(); 1007 assertThat(networkRequestList).isEmpty(); 1008 } 1009 getDataNetworks()1010 private @NonNull List<DataNetwork> getDataNetworks() throws Exception { 1011 Field field = DataNetworkController.class.getDeclaredField("mDataNetworkList"); 1012 field.setAccessible(true); 1013 return (List<DataNetwork>) field.get(mDataNetworkControllerUT); 1014 } 1015 verifyInternetConnected()1016 private void verifyInternetConnected() throws Exception { 1017 verify(mMockedDataNetworkControllerCallback).onInternetDataNetworkConnected(any()); 1018 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1019 } 1020 verifyConnectedNetworkHasCapabilities(@etCapability int... networkCapabilities)1021 private void verifyConnectedNetworkHasCapabilities(@NetCapability int... networkCapabilities) 1022 throws Exception { 1023 List<DataNetwork> dataNetworkList = getDataNetworks(); 1024 for (DataNetwork dataNetwork : getDataNetworks()) { 1025 if (dataNetwork.isConnected() && Arrays.stream(networkCapabilities).boxed() 1026 .allMatch(dataNetwork.getNetworkCapabilities()::hasCapability)) { 1027 return; 1028 } 1029 } 1030 fail("No network with " + DataUtils.networkCapabilitiesToString(networkCapabilities) 1031 + " is connected. dataNetworkList=" + dataNetworkList); 1032 } 1033 verifyNoConnectedNetworkHasCapability(@etCapability int networkCapability)1034 private void verifyNoConnectedNetworkHasCapability(@NetCapability int networkCapability) 1035 throws Exception { 1036 for (DataNetwork dataNetwork : getDataNetworks()) { 1037 assertWithMessage("Network " + dataNetwork + " should not be connected.") 1038 .that(dataNetwork.isConnected() && dataNetwork.getNetworkCapabilities() 1039 .hasCapability(networkCapability)).isFalse(); 1040 } 1041 } 1042 verifyConnectedNetworkHasDataProfile(@onNull DataProfile dataProfile)1043 private void verifyConnectedNetworkHasDataProfile(@NonNull DataProfile dataProfile) 1044 throws Exception { 1045 List<DataNetwork> dataNetworkList = getDataNetworks(); 1046 for (DataNetwork dataNetwork : getDataNetworks()) { 1047 if (dataNetwork.isConnected() && dataNetwork.getDataProfile().equals(dataProfile)) { 1048 return; 1049 } 1050 } 1051 fail("No network with " + dataProfile + " is connected. dataNetworkList=" 1052 + dataNetworkList); 1053 } 1054 verifyAllDataDisconnected()1055 private void verifyAllDataDisconnected() throws Exception { 1056 List<DataNetwork> dataNetworkList = getDataNetworks(); 1057 assertWithMessage("All data should be disconnected but it's not. " + dataNetworkList) 1058 .that(dataNetworkList).isEmpty(); 1059 } 1060 1061 // To test the basic data setup. Copy this as example for other tests. 1062 @Test testSetupDataNetwork()1063 public void testSetupDataNetwork() throws Exception { 1064 mDataNetworkControllerUT.addNetworkRequest( 1065 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1066 processAllMessages(); 1067 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1068 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 1069 1070 List<DataNetwork> dataNetworkList = getDataNetworks(); 1071 assertThat(dataNetworkList).hasSize(1); 1072 DataNetwork dataNetwork = dataNetworkList.get(0); 1073 assertThat(dataNetworkList.get(0).getLinkProperties().getAddresses()).containsExactly( 1074 InetAddresses.parseNumericAddress(IPV4_ADDRESS), 1075 InetAddresses.parseNumericAddress(IPV6_ADDRESS)); 1076 1077 verify(mMockedDataNetworkControllerCallback).onInternetDataNetworkConnected(any()); 1078 } 1079 1080 @Test testSetupDataNetworkWithSimilarDataProfile()1081 public void testSetupDataNetworkWithSimilarDataProfile() throws Exception { 1082 mDataNetworkControllerUT.addNetworkRequest( 1083 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1084 processAllMessages(); 1085 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1086 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 1087 1088 List<DataNetwork> dataNetworkList = getDataNetworks(); 1089 assertThat(dataNetworkList).hasSize(1); 1090 DataNetwork dataNetwork = dataNetworkList.get(0); 1091 assertThat(dataNetworkList.get(0).getLinkProperties().getAddresses()).containsExactly( 1092 InetAddresses.parseNumericAddress(IPV4_ADDRESS), 1093 InetAddresses.parseNumericAddress(IPV6_ADDRESS)); 1094 1095 verify(mMockedDataNetworkControllerCallback).onInternetDataNetworkConnected(any()); 1096 1097 // database updated/reloaded, causing data profile id change 1098 List<DataProfile> profiles = List.of(mDuplicatedGeneralPurposeDataProfile); 1099 doAnswer(invocation -> { 1100 DataProfile dp = (DataProfile) invocation.getArguments()[0]; 1101 1102 if (dp.getApnSetting() == null) return true; 1103 1104 for (DataProfile dataProfile : profiles) { 1105 if (dataProfile.getApnSetting() != null 1106 && dataProfile.getApnSetting().equals(dp.getApnSetting(), false)) { 1107 return true; 1108 } 1109 } 1110 return null; 1111 }).when(mDataProfileManager).isDataProfileCompatible(any(DataProfile.class)); 1112 doAnswer(invocation -> { 1113 TelephonyNetworkRequest networkRequest = 1114 (TelephonyNetworkRequest) invocation.getArguments()[0]; 1115 int networkType = (int) invocation.getArguments()[1]; 1116 1117 for (DataProfile dataProfile : profiles) { 1118 if (dataProfile.canSatisfy(networkRequest.getCapabilities()) 1119 && (dataProfile.getApnSetting().getNetworkTypeBitmask() == 0 1120 || (dataProfile.getApnSetting().getNetworkTypeBitmask() 1121 & ServiceState.getBitmaskForTech(networkType)) != 0)) { 1122 return dataProfile; 1123 } 1124 } 1125 logd("Cannot find data profile to satisfy " + networkRequest + ", network type=" 1126 + TelephonyManager.getNetworkTypeName(networkType)); 1127 return null; 1128 }).when(mDataProfileManager).getDataProfileForNetworkRequest( 1129 any(TelephonyNetworkRequest.class), anyInt(), anyBoolean()); 1130 1131 // verify the network still connects 1132 verify(mMockedDataNetworkControllerCallback).onInternetDataNetworkConnected(any()); 1133 1134 // A NOT_VCN_MANAGED request cannot be satisfied by the existing network, but will adopt the 1135 // same data profile 1136 mDataNetworkControllerUT.addNetworkRequest( 1137 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET, 1138 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)); 1139 1140 processAllMessages(); 1141 1142 // verify the network still connects 1143 verify(mMockedDataNetworkControllerCallback).onInternetDataNetworkConnected(any()); 1144 // verify we don't try to setup a separate network for the not_vcn_managed request 1145 dataNetworkList = getDataNetworks(); 1146 assertThat(dataNetworkList).hasSize(1); 1147 } 1148 1149 @Test testSetupImsDataNetwork()1150 public void testSetupImsDataNetwork() throws Exception { 1151 mDataNetworkControllerUT.addNetworkRequest( 1152 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 1153 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 1154 processAllMessages(); 1155 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 1156 NetworkCapabilities.NET_CAPABILITY_MMTEL); 1157 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 1158 List<DataNetwork> dataNetworkList = getDataNetworks(); 1159 assertThat(dataNetworkList.get(0).getLinkProperties().getAddresses()).containsExactly( 1160 InetAddresses.parseNumericAddress(IPV4_ADDRESS), 1161 InetAddresses.parseNumericAddress(IPV6_ADDRESS)); 1162 } 1163 1164 @Test testSetupEnterpriseDataNetwork()1165 public void testSetupEnterpriseDataNetwork() throws Exception { 1166 List<TrafficDescriptor> tdList = new ArrayList<>(); 1167 tdList.add(new TrafficDescriptor.Builder() 1168 .setOsAppId(new OsAppId(OsAppId.ANDROID_OS_ID, "ENTERPRISE", 1).getBytes()) 1169 .build()); 1170 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 1171 createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE, tdList)); 1172 doReturn(mEnterpriseDataProfile).when(mDataProfileManager) 1173 .getDataProfileForNetworkRequest(any(TelephonyNetworkRequest.class), anyInt(), 1174 anyBoolean()); 1175 1176 mDataNetworkControllerUT.addNetworkRequest( 1177 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 1178 processAllMessages(); 1179 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE); 1180 List<DataNetwork> dataNetworkList = getDataNetworks(); 1181 assertThat(dataNetworkList.get(0).getLinkProperties().getAddresses()).containsExactly( 1182 InetAddresses.parseNumericAddress(IPV4_ADDRESS), 1183 InetAddresses.parseNumericAddress(IPV6_ADDRESS)); 1184 } 1185 1186 @Test testDataNetworkControllerCallback()1187 public void testDataNetworkControllerCallback() throws Exception { 1188 Field field = DataNetworkController.class.getDeclaredField( 1189 "mDataNetworkControllerCallbacks"); 1190 field.setAccessible(true); 1191 Set<DataNetworkControllerCallback> dataNetworkControllerCallbacks = 1192 (Set<DataNetworkControllerCallback>) field.get(mDataNetworkControllerUT); 1193 1194 // Verify register callback 1195 mDataNetworkControllerUT.registerDataNetworkControllerCallback( 1196 mMockedDataNetworkControllerCallback); 1197 TelephonyNetworkRequest request = createNetworkRequest( 1198 NetworkCapabilities.NET_CAPABILITY_INTERNET); 1199 mDataNetworkControllerUT.addNetworkRequest(request); 1200 processAllMessages(); 1201 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(true)); 1202 verify(mMockedDataNetworkControllerCallback).onInternetDataNetworkConnected(any()); 1203 1204 int countOfCallbacks = dataNetworkControllerCallbacks.size(); 1205 1206 // Verify unregister callback 1207 mDataNetworkControllerUT.removeNetworkRequest(request); 1208 processAllMessages(); 1209 getDataNetworks().get(0).tearDown(DataNetwork 1210 .TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 1211 processAllFutureMessages(); 1212 1213 assertEquals(countOfCallbacks - 1, dataNetworkControllerCallbacks.size()); 1214 } 1215 1216 @Test testSimRemovalDataTearDown()1217 public void testSimRemovalDataTearDown() throws Exception { 1218 testSetupDataNetwork(); 1219 1220 mDataNetworkControllerUT.obtainMessage(9/*EVENT_SIM_STATE_CHANGED*/, 1221 TelephonyManager.SIM_STATE_ABSENT, 0).sendToTarget(); 1222 processAllMessages(); 1223 verifyAllDataDisconnected(); 1224 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 1225 verify(mMockedDataNetworkControllerCallback).onInternetDataNetworkDisconnected(); 1226 } 1227 1228 @Test testSimRemovalAndThenInserted()1229 public void testSimRemovalAndThenInserted() throws Exception { 1230 testSimRemovalDataTearDown(); 1231 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1232 1233 // Insert the SIM again. 1234 mDataNetworkControllerUT.obtainMessage(9/*EVENT_SIM_STATE_CHANGED*/, 1235 TelephonyManager.SIM_STATE_LOADED, 0).sendToTarget(); 1236 processAllMessages(); 1237 1238 verifyInternetConnected(); 1239 } 1240 1241 @Test testDuplicateInterface()1242 public void testDuplicateInterface() throws Exception { 1243 mDataNetworkControllerUT.addNetworkRequest( 1244 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1245 processAllMessages(); 1246 1247 // The fota network request would result in duplicate interface. 1248 mDataNetworkControllerUT.addNetworkRequest( 1249 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_FOTA)); 1250 processAllFutureMessages(); 1251 1252 // There should be only one network. 1253 List<DataNetwork> dataNetworkList = getDataNetworks(); 1254 assertThat(dataNetworkList).hasSize(1); 1255 assertThat(dataNetworkList.get(0).getDataProfile()).isEqualTo(mGeneralPurposeDataProfile); 1256 verifyInternetConnected(); 1257 // Fota should not be connected. 1258 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA); 1259 1260 // There should be exactly 2 setup data call requests. 1261 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 1262 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 1263 any(), any(), anyBoolean(), any(Message.class)); 1264 } 1265 1266 @Test testMovingFromNoServiceToInService()1267 public void testMovingFromNoServiceToInService() throws Exception { 1268 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1269 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 1270 1271 mDataNetworkControllerUT.addNetworkRequest( 1272 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1273 processAllMessages(); 1274 1275 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1276 1277 // Network becomes in-service. 1278 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1279 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1280 1281 verifyInternetConnected(); 1282 } 1283 1284 @Test testMovingFromInServiceToNoService()1285 public void testMovingFromInServiceToNoService() throws Exception { 1286 testSetupDataNetwork(); 1287 1288 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1289 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 1290 // Verify we don't tear down the data network. 1291 verifyInternetConnected(); 1292 1293 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 1294 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 1295 // Verify we don't tear down the data network. 1296 verifyInternetConnected(); 1297 } 1298 1299 @Test testPsRestrictedAndLifted()1300 public void testPsRestrictedAndLifted() throws Exception { 1301 testSetupDataNetwork(); 1302 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1303 1304 // PS restricted, existing PDN should stay. 1305 mDataNetworkControllerUT.obtainMessage(6/*EVENT_PS_RESTRICT_ENABLED*/).sendToTarget(); 1306 processAllMessages(); 1307 1308 List<DataNetwork> dataNetworkList = getDataNetworks(); 1309 assertThat(dataNetworkList).hasSize(1); 1310 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1311 1312 // PS restricted, new setup NOT allowed 1313 mDataNetworkControllerUT.addNetworkRequest( 1314 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 1315 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 1316 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 1317 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 1318 processAllMessages(); 1319 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 1320 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1321 1322 1323 // PS unrestricted, new setup is allowed 1324 mDataNetworkControllerUT.obtainMessage(7/*EVENT_PS_RESTRICT_DISABLED*/).sendToTarget(); 1325 processAllMessages(); 1326 1327 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 1328 NetworkCapabilities.NET_CAPABILITY_MMTEL); 1329 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1330 } 1331 1332 @Test testPsRestrictedAllowIwlan()1333 public void testPsRestrictedAllowIwlan() throws Exception { 1334 // IMS preferred on IWLAN. 1335 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 1336 .getPreferredTransportByNetworkCapability( 1337 eq(NetworkCapabilities.NET_CAPABILITY_IMS)); 1338 1339 // PS restricted 1340 mDataNetworkControllerUT.obtainMessage(6/*EVENT_PS_RESTRICT_ENABLED*/).sendToTarget(); 1341 processAllMessages(); 1342 1343 // PS restricted, new setup NOT allowed 1344 mDataNetworkControllerUT.addNetworkRequest( 1345 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1346 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 1347 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 1348 processAllMessages(); 1349 verifyAllDataDisconnected(); 1350 1351 // Request IMS 1352 mDataNetworkControllerUT.addNetworkRequest( 1353 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 1354 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 1355 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 1356 .get(AccessNetworkConstants.TRANSPORT_TYPE_WLAN), 3); 1357 processAllMessages(); 1358 1359 // Make sure IMS on IWLAN. 1360 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS); 1361 assertThat(getDataNetworks()).hasSize(1); 1362 DataNetwork dataNetwork = getDataNetworks().get(0); 1363 assertThat(dataNetwork.getTransport()).isEqualTo( 1364 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 1365 } 1366 1367 @Test testRatChanges()1368 public void testRatChanges() throws Exception { 1369 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1370 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1371 1372 testSetupDataNetwork(); 1373 1374 // Now RAT changes from LTE to UMTS, make sure the network is lingered. 1375 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UMTS, 1376 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1377 verifyInternetConnected(); 1378 1379 // Now RAT changes from UMTS to GSM 1380 doReturn(null).when(mDataProfileManager).getDataProfileForNetworkRequest( 1381 any(TelephonyNetworkRequest.class), eq(TelephonyManager.NETWORK_TYPE_GSM), 1382 anyBoolean()); 1383 serviceStateChanged(TelephonyManager.NETWORK_TYPE_GSM, 1384 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1385 verifyAllDataDisconnected(); 1386 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 1387 verify(mMockedDataNetworkControllerCallback).onInternetDataNetworkDisconnected(); 1388 1389 1390 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1391 // Now RAT changes from GSM to UMTS 1392 doReturn(null).when(mDataProfileManager).getDataProfileForNetworkRequest( 1393 any(TelephonyNetworkRequest.class), eq(TelephonyManager.NETWORK_TYPE_UMTS), 1394 anyBoolean()); 1395 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UMTS, 1396 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1397 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1398 1399 doReturn(mGeneralPurposeDataProfile).when(mDataProfileManager) 1400 .getDataProfileForNetworkRequest(any(TelephonyNetworkRequest.class), anyInt(), 1401 anyBoolean()); 1402 // Now RAT changes from UMTS to LTE 1403 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1404 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1405 verifyInternetConnected(); 1406 } 1407 1408 @Test testRatChangesLingeringNotSet()1409 public void testRatChangesLingeringNotSet() throws Exception { 1410 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1411 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1412 TelephonyNetworkRequest fotaRequest = createNetworkRequest( 1413 NetworkCapabilities.NET_CAPABILITY_FOTA); 1414 mDataNetworkControllerUT.addNetworkRequest(fotaRequest); 1415 processAllMessages(); 1416 1417 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_FOTA); 1418 1419 // Now RAT changes from LTE to UMTS, since FOTA APN does not have lingering set, only 1420 // network type bitmask should be used. Fota network should be torn down. 1421 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UMTS, 1422 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1423 processAllMessages(); 1424 1425 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA); 1426 verifyAllDataDisconnected(); 1427 } 1428 1429 @Test testVoiceCallEndedOnVoiceDataNonConcurrentNetwork()1430 public void testVoiceCallEndedOnVoiceDataNonConcurrentNetwork() throws Exception { 1431 doReturn(false).when(mSST).isConcurrentVoiceAndDataAllowed(); 1432 doReturn(PhoneConstants.State.OFFHOOK).when(mCT).getState(); 1433 1434 mDataNetworkControllerUT.addNetworkRequest( 1435 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1436 processAllMessages(); 1437 1438 // Data should not be allowed when voice/data concurrent is not supported. 1439 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1440 1441 // Call ended. 1442 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 1443 mDataNetworkControllerUT.obtainMessage(18/*EVENT_VOICE_CALL_ENDED*/).sendToTarget(); 1444 processAllMessages(); 1445 1446 // It should have no internet setup at the beginning. 1447 verifyAllDataDisconnected(); 1448 1449 // But after some delays data should be restored. 1450 moveTimeForward(500); 1451 processAllMessages(); 1452 verifyInternetConnected(); 1453 } 1454 1455 @Test testEcbmChanged()1456 public void testEcbmChanged() throws Exception { 1457 doReturn(true).when(mPhone).isInCdmaEcm(); 1458 mDataNetworkControllerUT.addNetworkRequest( 1459 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1460 processAllMessages(); 1461 1462 // Data should not be allowed when the device is in ECBM. 1463 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1464 1465 // Exit ECBM 1466 doReturn(false).when(mPhone).isInCdmaEcm(); 1467 mDataNetworkControllerUT.obtainMessage(20/*EVENT_EMERGENCY_CALL_CHANGED*/).sendToTarget(); 1468 processAllMessages(); 1469 1470 // Verify data is restored. 1471 verifyInternetConnected(); 1472 } 1473 1474 @Test testRoamingDataChanged()1475 public void testRoamingDataChanged() throws Exception { 1476 doReturn(true).when(mServiceState).getDataRoaming(); 1477 1478 // Roaming data disabled 1479 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 1480 processAllMessages(); 1481 1482 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1483 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 1484 mDataNetworkControllerUT.addNetworkRequest( 1485 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1486 processAllMessages(); 1487 1488 // Data should not be allowed when roaming data is disabled. 1489 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1490 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1491 1492 // Roaming data enabled 1493 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(true); 1494 processAllMessages(); 1495 1496 // Verify data is restored. 1497 verifyInternetConnected(); 1498 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1499 1500 // Roaming data disabled 1501 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 1502 processAllMessages(); 1503 1504 // Verify data is torn down. 1505 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1506 } 1507 1508 @Test testDataEnabledChanged()1509 public void testDataEnabledChanged() throws Exception { 1510 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1511 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 1512 mDataNetworkControllerUT.addNetworkRequest( 1513 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1514 processAllMessages(); 1515 1516 // Data should not be allowed when user data is disabled. 1517 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1518 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1519 1520 // User data enabled 1521 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1522 TelephonyManager.DATA_ENABLED_REASON_USER, true, mContext.getOpPackageName()); 1523 processAllMessages(); 1524 1525 // Verify data is restored. 1526 verifyInternetConnected(); 1527 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 1528 1529 // User data disabled 1530 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1531 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 1532 processAllMessages(); 1533 1534 // Verify data is torn down. 1535 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1536 } 1537 1538 @Test testNotifyWhenSetDataEnabled()1539 public void testNotifyWhenSetDataEnabled() throws Exception { 1540 // Set a valid sub id, DEFAULT_SUBSCRIPTION_ID 1541 int subId = Integer.MAX_VALUE; 1542 Field field = DataSettingsManager.class.getDeclaredField("mSubId"); 1543 field.setAccessible(true); 1544 field.setInt(mDataNetworkControllerUT.getDataSettingsManager(), subId); 1545 boolean isDataEnabled = mDataNetworkControllerUT.getDataSettingsManager().isDataEnabled(); 1546 doReturn(mDataNetworkControllerUT.getDataSettingsManager()) 1547 .when(mPhone).getDataSettingsManager(); 1548 MultiSimSettingController instance = MultiSimSettingController.getInstance(); 1549 MultiSimSettingController controller = Mockito.spy( 1550 new MultiSimSettingController(mContext, mSubscriptionController)); 1551 doReturn(true).when(controller).isCarrierConfigLoadedForAllSub(); 1552 replaceInstance(MultiSimSettingController.class, "sInstance", null, controller); 1553 1554 controller.notifyAllSubscriptionLoaded(); 1555 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1556 TelephonyManager.DATA_ENABLED_REASON_USER, !isDataEnabled, 1557 mContext.getOpPackageName()); 1558 processAllMessages(); 1559 1560 // Verify not to notify MultiSimSettingController 1561 verify(controller, never()).notifyUserDataEnabled(anyInt(), anyBoolean()); 1562 1563 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1564 TelephonyManager.DATA_ENABLED_REASON_USER, isDataEnabled, 1565 mContext.getOpPackageName()); 1566 processAllMessages(); 1567 1568 // Verify not to notify MultiSimSettingController 1569 verify(controller, never()).notifyUserDataEnabled(anyInt(), anyBoolean()); 1570 1571 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1572 TelephonyManager.DATA_ENABLED_REASON_USER, !isDataEnabled, "com.android.settings"); 1573 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1574 TelephonyManager.DATA_ENABLED_REASON_USER, isDataEnabled, "com.android.settings"); 1575 processAllMessages(); 1576 1577 // Verify to notify MultiSimSettingController exactly 2 times 1578 verify(controller, times(2)).notifyUserDataEnabled(anyInt(), anyBoolean()); 1579 } 1580 1581 @Test testMmsAlwaysAllowedDataDisabled()1582 public void testMmsAlwaysAllowedDataDisabled() throws Exception { 1583 // Data disabled 1584 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1585 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 1586 // Always allow MMS 1587 mDataNetworkControllerUT.getDataSettingsManager().setAlwaysAllowMmsData(true); 1588 processAllMessages(); 1589 mDataNetworkControllerUT.addNetworkRequest( 1590 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 1591 processAllMessages(); 1592 1593 // Make sure MMS is the only capability advertised, but not internet or SUPL. 1594 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 1595 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 1596 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1597 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL); 1598 1599 // Remove MMS data enabled override 1600 mDataNetworkControllerUT.getDataSettingsManager().setAlwaysAllowMmsData(false); 1601 processAllMessages(); 1602 1603 // Make sure MMS is torn down when the override is disabled. 1604 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 1605 } 1606 1607 @Test testMmsAlwaysAllowedRoamingDisabled()1608 public void testMmsAlwaysAllowedRoamingDisabled() throws Exception { 1609 // Data roaming disabled 1610 doReturn(true).when(mServiceState).getDataRoaming(); 1611 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 1612 processAllMessages(); 1613 1614 // Device is roaming 1615 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1616 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 1617 // Always allow MMS 1618 mDataNetworkControllerUT.getDataSettingsManager().setAlwaysAllowMmsData(true); 1619 processAllMessages(); 1620 1621 mDataNetworkControllerUT.addNetworkRequest( 1622 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 1623 processAllMessages(); 1624 1625 // Make sure MMS is not allowed. MMS always allowed should be only applicable to data 1626 // disabled case. 1627 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 1628 } 1629 1630 @Test testUnmeteredRequestPreferredOnIwlan()1631 public void testUnmeteredRequestPreferredOnIwlan() throws Exception { 1632 // Preferred on cellular 1633 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 1634 .getPreferredTransportByNetworkCapability(anyInt()); 1635 // Data disabled 1636 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1637 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 1638 mDataNetworkControllerUT.addNetworkRequest( 1639 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1640 processAllMessages(); 1641 1642 // Data should not be allowed when roaming + user data are disabled (soft failure reasons) 1643 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1644 1645 // Set transport to WLAN (unmetered) 1646 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 1647 .getPreferredTransportByNetworkCapability( 1648 eq(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1649 // Data remain disabled, but trigger the preference evaluation. 1650 mDataNetworkControllerUT.obtainMessage(21 /*EVENT_EVALUATE_PREFERRED_TRANSPORT*/, 1651 NetworkCapabilities.NET_CAPABILITY_INTERNET, 0).sendToTarget(); 1652 mDataNetworkControllerUT.obtainMessage(5 /*EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS*/, 1653 DataEvaluation.DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED).sendToTarget(); 1654 processAllMessages(); 1655 1656 // Verify data is allowed even if data is disabled. 1657 verifyInternetConnected(); 1658 } 1659 1660 @Test testUnmeteredRequestDataRoamingDisabled()1661 public void testUnmeteredRequestDataRoamingDisabled() throws Exception { 1662 // Data roaming disabled 1663 doReturn(true).when(mServiceState).getDataRoaming(); 1664 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 1665 processAllMessages(); 1666 1667 // MMS is unmetered 1668 mCarrierConfig.putStringArray( 1669 CarrierConfigManager.KEY_CARRIER_METERED_ROAMING_APN_TYPES_STRINGS, 1670 new String[]{"default", "dun", "supl"}); 1671 carrierConfigChanged(); 1672 // Manually set data roaming to false in case ro.com.android.dataroaming is true. 1673 // TODO(b/232575718): Figure out a way to mock ro.com.android.dataroaming for tests. 1674 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 1675 // Device is roaming 1676 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 1677 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 1678 1679 mDataNetworkControllerUT.addNetworkRequest( 1680 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 1681 processAllMessages(); 1682 1683 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 1684 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1685 } 1686 1687 @Test testUnmeteredRequestDataDisabled()1688 public void testUnmeteredRequestDataDisabled() throws Exception { 1689 // MMS is unmetered 1690 mCarrierConfig.putStringArray( 1691 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 1692 new String[]{"default", "dun", "supl"}); 1693 carrierConfigChanged(); 1694 1695 // Data disabled 1696 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1697 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 1698 1699 mDataNetworkControllerUT.addNetworkRequest( 1700 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 1701 1702 processAllMessages(); 1703 1704 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 1705 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1706 } 1707 1708 @Test testEmergencyRequest()1709 public void testEmergencyRequest() throws Exception { 1710 // Data disabled 1711 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 1712 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 1713 mDataNetworkControllerUT.addNetworkRequest( 1714 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_EIMS)); 1715 processAllMessages(); 1716 1717 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_EIMS); 1718 verifyConnectedNetworkHasDataProfile(mEmergencyDataProfile); 1719 } 1720 1721 @Test testHandoverRuleFromString()1722 public void testHandoverRuleFromString() { 1723 HandoverRule handoverRule = new HandoverRule("source=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN, " 1724 + "target=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN, type=allowed"); 1725 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.GERAN, 1726 AccessNetworkType.UTRAN, AccessNetworkType.EUTRAN, AccessNetworkType.NGRAN, 1727 AccessNetworkType.IWLAN); 1728 assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.GERAN, 1729 AccessNetworkType.UTRAN, AccessNetworkType.EUTRAN, AccessNetworkType.NGRAN, 1730 AccessNetworkType.IWLAN); 1731 assertThat(handoverRule.type).isEqualTo(HandoverRule.RULE_TYPE_ALLOWED); 1732 assertThat(handoverRule.isOnlyForRoaming).isFalse(); 1733 assertThat(handoverRule.networkCapabilities).isEmpty(); 1734 1735 handoverRule = new HandoverRule("source= NGRAN| IWLAN, " 1736 + "target = EUTRAN, type = disallowed "); 1737 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.NGRAN, 1738 AccessNetworkType.IWLAN); 1739 assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.EUTRAN); 1740 assertThat(handoverRule.type).isEqualTo(HandoverRule.RULE_TYPE_DISALLOWED); 1741 assertThat(handoverRule.isOnlyForRoaming).isFalse(); 1742 assertThat(handoverRule.networkCapabilities).isEmpty(); 1743 1744 handoverRule = new HandoverRule("source= IWLAN, " 1745 + "target = EUTRAN, type = disallowed, roaming = true," 1746 + " capabilities = IMS | EIMS "); 1747 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.IWLAN); 1748 assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.EUTRAN); 1749 assertThat(handoverRule.type).isEqualTo(HandoverRule.RULE_TYPE_DISALLOWED); 1750 assertThat(handoverRule.networkCapabilities).containsExactly( 1751 NetworkCapabilities.NET_CAPABILITY_IMS, NetworkCapabilities.NET_CAPABILITY_EIMS); 1752 assertThat(handoverRule.isOnlyForRoaming).isTrue(); 1753 1754 handoverRule = new HandoverRule("source=EUTRAN|NGRAN|IWLAN|UNKNOWN, " 1755 + "target=EUTRAN|NGRAN|IWLAN, type=disallowed, capabilities = IMS|EIMS"); 1756 assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.EUTRAN, 1757 AccessNetworkType.NGRAN, AccessNetworkType.IWLAN, AccessNetworkType.UNKNOWN); 1758 assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.EUTRAN, 1759 AccessNetworkType.NGRAN, AccessNetworkType.IWLAN); 1760 assertThat(handoverRule.type).isEqualTo(HandoverRule.RULE_TYPE_DISALLOWED); 1761 assertThat(handoverRule.networkCapabilities).containsExactly( 1762 NetworkCapabilities.NET_CAPABILITY_IMS, NetworkCapabilities.NET_CAPABILITY_EIMS); 1763 1764 assertThrows(IllegalArgumentException.class, 1765 () -> new HandoverRule("V2hhdCBUaGUgRnVjayBpcyB0aGlzIQ==")); 1766 1767 assertThrows(IllegalArgumentException.class, 1768 () -> new HandoverRule("target=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN, type=allowed")); 1769 1770 assertThrows(IllegalArgumentException.class, 1771 () -> new HandoverRule("source=GERAN|UTRAN|EUTRAN|NGRAN|IWLAN, type=allowed")); 1772 1773 assertThrows(IllegalArgumentException.class, 1774 () -> new HandoverRule("source=GERAN, target=UNKNOWN, type=disallowed, " 1775 + "capabilities=IMS")); 1776 1777 assertThrows(IllegalArgumentException.class, 1778 () -> new HandoverRule("source=UNKNOWN, target=IWLAN, type=allowed, " 1779 + "capabilities=IMS")); 1780 1781 assertThrows(IllegalArgumentException.class, 1782 () -> new HandoverRule("source=GERAN, target=IWLAN, type=wtf")); 1783 1784 assertThrows(IllegalArgumentException.class, 1785 () -> new HandoverRule("source=GERAN, target=NGRAN, type=allowed")); 1786 1787 assertThrows(IllegalArgumentException.class, 1788 () -> new HandoverRule("source=IWLAN, target=WTFRAN, type=allowed")); 1789 1790 assertThrows(IllegalArgumentException.class, 1791 () -> new HandoverRule("source=IWLAN, target=|, type=allowed")); 1792 1793 assertThrows(IllegalArgumentException.class, 1794 () -> new HandoverRule("source=GERAN, target=IWLAN, type=allowed, capabilities=|")); 1795 1796 assertThrows(IllegalArgumentException.class, 1797 () -> new HandoverRule("source=GERAN, target=IWLAN, type=allowed, capabilities=")); 1798 1799 assertThrows(IllegalArgumentException.class, 1800 () -> new HandoverRule("source=GERAN, target=IWLAN, type=allowed, " 1801 + "capabilities=wtf")); 1802 } 1803 1804 @Test testIsNetworkTypeCongested()1805 public void testIsNetworkTypeCongested() throws Exception { 1806 Set<Integer> congestedNetworkTypes = new ArraySet<>(); 1807 doReturn(congestedNetworkTypes).when(mDataNetworkController) 1808 .getCongestedOverrideNetworkTypes(); 1809 testSetupDataNetwork(); 1810 DataNetwork dataNetwork = getDataNetworks().get(0); 1811 1812 // Set 5G unmetered 1813 congestedNetworkTypes.add(TelephonyManager.NETWORK_TYPE_NR); 1814 mDataNetworkControllerUT.obtainMessage(23/*EVENT_SUBSCRIPTION_OVERRIDE*/, 1815 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_CONGESTED, 1816 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_CONGESTED, 1817 new int[]{TelephonyManager.NETWORK_TYPE_NR}).sendToTarget(); 1818 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 1819 processAllMessages(); 1820 assertEquals(congestedNetworkTypes, 1821 mDataNetworkControllerUT.getCongestedOverrideNetworkTypes()); 1822 assertTrue(dataNetwork.getNetworkCapabilities().hasCapability( 1823 NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED)); 1824 1825 // Change data network type to NR 1826 doReturn(new TelephonyDisplayInfo(TelephonyManager.NETWORK_TYPE_NR, 1827 TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NONE)) 1828 .when(mDisplayInfoController).getTelephonyDisplayInfo(); 1829 dataNetwork.sendMessage(13/*EVENT_DISPLAY_INFO_CHANGED*/); 1830 processAllMessages(); 1831 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 1832 NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED)); 1833 1834 // Set all network types metered 1835 congestedNetworkTypes.clear(); 1836 mDataNetworkControllerUT.obtainMessage(23/*EVENT_SUBSCRIPTION_OVERRIDE*/, 1837 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_CONGESTED, 0, 1838 TelephonyManager.getAllNetworkTypes()).sendToTarget(); 1839 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 1840 processAllMessages(); 1841 assertTrue(mDataNetworkControllerUT.getCongestedOverrideNetworkTypes().isEmpty()); 1842 assertTrue(dataNetwork.getNetworkCapabilities().hasCapability( 1843 NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED)); 1844 } 1845 1846 @Test testIsNetworkTypeUnmeteredViaSubscriptionOverride()1847 public void testIsNetworkTypeUnmeteredViaSubscriptionOverride() throws Exception { 1848 Set<Integer> unmeteredNetworkTypes = new ArraySet<>(); 1849 doReturn(unmeteredNetworkTypes).when(mDataNetworkController) 1850 .getUnmeteredOverrideNetworkTypes(); 1851 testSetupDataNetwork(); 1852 DataNetwork dataNetwork = getDataNetworks().get(0); 1853 1854 // Set 5G unmetered 1855 unmeteredNetworkTypes.add(TelephonyManager.NETWORK_TYPE_NR); 1856 mDataNetworkControllerUT.obtainMessage(23/*EVENT_SUBSCRIPTION_OVERRIDE*/, 1857 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_UNMETERED, 1858 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_UNMETERED, 1859 new int[]{TelephonyManager.NETWORK_TYPE_NR}).sendToTarget(); 1860 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 1861 processAllMessages(); 1862 assertEquals(unmeteredNetworkTypes, 1863 mDataNetworkControllerUT.getUnmeteredOverrideNetworkTypes()); 1864 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 1865 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 1866 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isFalse(); 1867 1868 // Change data network type to NR 1869 doReturn(new TelephonyDisplayInfo(TelephonyManager.NETWORK_TYPE_NR, 1870 TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NONE)) 1871 .when(mDisplayInfoController).getTelephonyDisplayInfo(); 1872 dataNetwork.sendMessage(13/*EVENT_DISPLAY_INFO_CHANGED*/); 1873 processAllMessages(); 1874 assertTrue(dataNetwork.getNetworkCapabilities().hasCapability( 1875 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 1876 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isTrue(); 1877 1878 // Set all network types metered 1879 unmeteredNetworkTypes.clear(); 1880 mDataNetworkControllerUT.obtainMessage(23/*EVENT_SUBSCRIPTION_OVERRIDE*/, 1881 NetworkPolicyManager.SUBSCRIPTION_OVERRIDE_UNMETERED, 0, 1882 TelephonyManager.getAllNetworkTypes()).sendToTarget(); 1883 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 1884 processAllMessages(); 1885 assertTrue(mDataNetworkControllerUT.getUnmeteredOverrideNetworkTypes().isEmpty()); 1886 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 1887 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 1888 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isFalse(); 1889 } 1890 1891 @Test testIsNetworkTypeUnmeteredViaSubscriptionPlans()1892 public void testIsNetworkTypeUnmeteredViaSubscriptionPlans() throws Exception { 1893 List<SubscriptionPlan> subscriptionPlans = new ArrayList<>(); 1894 doReturn(subscriptionPlans).when(mDataNetworkController).getSubscriptionPlans(); 1895 testSetupDataNetwork(); 1896 DataNetwork dataNetwork = getDataNetworks().get(0); 1897 1898 // Set 5G unmetered 1899 SubscriptionPlan unmetered5GPlan = SubscriptionPlan.Builder 1900 .createRecurring(ZonedDateTime.parse("2007-03-14T00:00:00.000Z"), 1901 Period.ofMonths(1)) 1902 .setDataLimit(SubscriptionPlan.BYTES_UNLIMITED, 1903 SubscriptionPlan.LIMIT_BEHAVIOR_THROTTLED) 1904 .setNetworkTypes(new int[]{TelephonyManager.NETWORK_TYPE_NR}) 1905 .build(); 1906 SubscriptionPlan generalMeteredPlan = SubscriptionPlan.Builder 1907 .createRecurring(ZonedDateTime.parse("2007-03-14T00:00:00.000Z"), 1908 Period.ofMonths(1)) 1909 .setDataLimit(1_000_000_000, SubscriptionPlan.LIMIT_BEHAVIOR_DISABLED) 1910 .setDataUsage(500_000_000, System.currentTimeMillis()) 1911 .build(); 1912 subscriptionPlans.add(generalMeteredPlan); 1913 subscriptionPlans.add(unmetered5GPlan); 1914 mDataNetworkControllerUT.obtainMessage(22/*EVENT_SUBSCRIPTION_PLANS_CHANGED*/, 1915 new SubscriptionPlan[]{generalMeteredPlan, unmetered5GPlan}).sendToTarget(); 1916 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 1917 processAllMessages(); 1918 assertEquals(subscriptionPlans, mDataNetworkControllerUT.getSubscriptionPlans()); 1919 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 1920 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 1921 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isFalse(); 1922 1923 1924 // Change data network type to NR 1925 doReturn(new TelephonyDisplayInfo(TelephonyManager.NETWORK_TYPE_NR, 1926 TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NONE)) 1927 .when(mDisplayInfoController).getTelephonyDisplayInfo(); 1928 dataNetwork.sendMessage(13/*EVENT_DISPLAY_INFO_CHANGED*/); 1929 processAllMessages(); 1930 assertTrue(dataNetwork.getNetworkCapabilities().hasCapability( 1931 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 1932 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isTrue(); 1933 1934 // Set all network types metered 1935 subscriptionPlans.clear(); 1936 mDataNetworkControllerUT.obtainMessage(22/*EVENT_SUBSCRIPTION_PLANS_CHANGED*/, 1937 new SubscriptionPlan[]{}).sendToTarget(); 1938 dataNetwork.sendMessage(16/*EVENT_SUBSCRIPTION_PLAN_OVERRIDE*/); 1939 processAllMessages(); 1940 assertTrue(mDataNetworkControllerUT.getSubscriptionPlans().isEmpty()); 1941 assertFalse(dataNetwork.getNetworkCapabilities().hasCapability( 1942 NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 1943 assertThat(mDataNetworkControllerUT.isInternetUnmetered()).isFalse(); 1944 } 1945 1946 @Test testOnSinglePdnArbitrationExemptIms()1947 public void testOnSinglePdnArbitrationExemptIms() throws Exception { 1948 // On CDMA network, only one data network is allowed. 1949 serviceStateChanged(TelephonyManager.NETWORK_TYPE_1xRTT, 1950 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 1951 // Preferred on cellular 1952 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 1953 .getPreferredTransportByNetworkCapability(anyInt()); 1954 // Add IMS 1955 TelephonyNetworkRequest ims = createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 1956 NetworkCapabilities.NET_CAPABILITY_MMTEL); 1957 mDataNetworkControllerUT.addNetworkRequest(ims); 1958 processAllMessages(); 1959 1960 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 1961 NetworkCapabilities.NET_CAPABILITY_MMTEL); 1962 1963 // Add internet, should be compatible 1964 mDataNetworkControllerUT.addNetworkRequest( 1965 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 1966 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 1967 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 1968 processAllMessages(); 1969 1970 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1971 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 1972 NetworkCapabilities.NET_CAPABILITY_MMTEL); 1973 1974 // Both internet and IMS should be retained after network re-evaluation 1975 mDataNetworkControllerUT.obtainMessage(16/*EVENT_REEVALUATE_EXISTING_DATA_NETWORKS*/) 1976 .sendToTarget(); 1977 processAllMessages(); 1978 1979 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 1980 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 1981 NetworkCapabilities.NET_CAPABILITY_MMTEL); 1982 1983 // Add MMS, whose priority > internet, internet should be town down, IMS left untouched 1984 mDataNetworkControllerUT.addNetworkRequest( 1985 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 1986 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 1987 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 3); 1988 processAllMessages(); 1989 1990 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 1991 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 1992 NetworkCapabilities.NET_CAPABILITY_MMTEL); 1993 1994 // Both internet and IMS should be retained after network re-evaluation 1995 mDataNetworkControllerUT.obtainMessage(16/*EVENT_REEVALUATE_EXISTING_DATA_NETWORKS*/) 1996 .sendToTarget(); 1997 processAllMessages(); 1998 1999 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 2000 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2001 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2002 2003 // Temporarily remove IMS 2004 mDataNetworkControllerUT.removeNetworkRequest(ims); 2005 processAllMessages(); 2006 List<DataNetwork> dataNetworks = getDataNetworks(); 2007 dataNetworks.get(0).tearDown(DataNetwork.TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 2008 processAllMessages(); 2009 2010 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 2011 2012 // Add IMS, should be compatible with the existing internet 2013 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 2014 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 4); 2015 mDataNetworkControllerUT.addNetworkRequest( 2016 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 2017 processAllMessages(); 2018 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET); 2019 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2020 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2021 } 2022 2023 @Test testLinkStatusChanged()2024 public void testLinkStatusChanged() throws Exception { 2025 testSetupDataNetwork(); 2026 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 2027 eq(DataCallResponse.LINK_STATUS_ACTIVE)); 2028 2029 DataNetwork dataNetwork = getDataNetworks().get(0); 2030 2031 DataCallResponse response = createDataCallResponse(1, DataCallResponse.LINK_STATUS_DORMANT); 2032 dataNetwork.obtainMessage(8 /*EVENT_DATA_STATE_CHANGED */, 2033 new AsyncResult(AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 2034 List.of(response), null)).sendToTarget(); 2035 2036 processAllMessages(); 2037 verify(mMockedDataNetworkControllerCallback).onPhysicalLinkStatusChanged( 2038 eq(DataCallResponse.LINK_STATUS_DORMANT)); 2039 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 2040 TelephonyManager.DATA_ACTIVITY_DORMANT); 2041 } 2042 2043 @Test testHandoverDataNetwork()2044 public void testHandoverDataNetwork() throws Exception { 2045 testSetupImsDataNetwork(); 2046 2047 DataNetwork dataNetwork = getDataNetworks().get(0); 2048 // Before handover the data profile is the cellular IMS data profile 2049 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 2050 2051 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2052 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2053 2054 // Verify that IWLAN handover succeeded. 2055 assertThat(dataNetwork.getTransport()).isEqualTo( 2056 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2057 2058 // After handover the data profile is the IWLAN IMS data profile 2059 verifyConnectedNetworkHasDataProfile(mImsIwlanDataProfile); 2060 } 2061 2062 @Test testHandoverDataNetworkBackToBackPreferenceChanged()2063 public void testHandoverDataNetworkBackToBackPreferenceChanged() throws Exception { 2064 testSetupImsDataNetwork(); 2065 2066 Mockito.reset(mMockedWlanDataServiceManager); 2067 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2068 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2069 2070 // Capture the message for setup data call response. We want to delay it. 2071 ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class); 2072 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 2073 anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 2074 messageCaptor.capture()); 2075 2076 // Before setup data call response, change the preference back to cellular. 2077 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2078 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2079 2080 // Before setup data call response, change the preference back to IWLAN. 2081 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2082 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2083 2084 // Finally handover is completed. 2085 Message msg = messageCaptor.getValue(); 2086 DataCallResponse response = new DataCallResponse.Builder() 2087 .setCause(DataFailCause.NONE) 2088 .build(); 2089 msg.getData().putParcelable("data_call_response", response); 2090 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 2091 msg.sendToTarget(); 2092 processAllMessages(); 2093 2094 // Make sure handover request is only sent once. 2095 verify(mMockedWlanDataServiceManager, times(1)).setupDataCall(anyInt(), 2096 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2097 any(), any(), anyBoolean(), messageCaptor.capture()); 2098 } 2099 2100 @Test testHandoverDataNetworkBackToBackPreferenceChangedHandoverFail()2101 public void testHandoverDataNetworkBackToBackPreferenceChangedHandoverFail() throws Exception { 2102 testSetupImsDataNetwork(); 2103 DataNetwork dataNetwork = getDataNetworks().get(0); 2104 2105 Mockito.reset(mMockedWlanDataServiceManager); 2106 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2107 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2108 2109 // Capture the message for setup data call response. We want to delay it. 2110 ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class); 2111 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 2112 anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 2113 messageCaptor.capture()); 2114 2115 // Before setup data call response, change the preference back to cellular. 2116 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2117 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2118 2119 // Finally handover is completed. 2120 Message msg = messageCaptor.getValue(); 2121 DataCallResponse response = new DataCallResponse.Builder() 2122 .setCause(DataFailCause.ERROR_UNSPECIFIED) 2123 .setRetryDurationMillis(123) 2124 .setHandoverFailureMode( 2125 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_SETUP_NORMAL) 2126 .build(); 2127 msg.getData().putParcelable("data_call_response", response); 2128 msg.arg1 = DataServiceCallback.RESULT_ERROR_UNSUPPORTED; 2129 msg.sendToTarget(); 2130 processAllMessages(); 2131 2132 // Make sure handover request is only sent once. 2133 verify(mMockedWlanDataServiceManager, times(1)).setupDataCall(anyInt(), 2134 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2135 any(), any(), anyBoolean(), messageCaptor.capture()); 2136 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS); 2137 assertSame(dataNetwork, getDataNetworks().get(0)); 2138 } 2139 2140 @Test testHandoverDataNetworkNotAllowedByPolicy()2141 public void testHandoverDataNetworkNotAllowedByPolicy() throws Exception { 2142 mCarrierConfig.putStringArray(CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 2143 new String[]{"source=EUTRAN, target=IWLAN, type=disallowed, capabilities=MMS|IMS", 2144 "source=IWLAN, target=EUTRAN, type=disallowed, capabilities=MMS"}); 2145 // Force data config manager to reload the carrier config. 2146 mDataNetworkControllerUT.getDataConfigManager().obtainMessage( 2147 1/*EVENT_CARRIER_CONFIG_CHANGED*/).sendToTarget(); 2148 processAllMessages(); 2149 2150 testSetupImsDataNetwork(); 2151 2152 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2153 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2154 // After this, IMS data network should be disconnected, and DNC should attempt to 2155 // establish a new one on IWLAN 2156 2157 // Verify all data disconnected. 2158 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 2159 2160 // A new data network should be connected on IWLAN 2161 List<DataNetwork> dataNetworkList = getDataNetworks(); 2162 assertThat(dataNetworkList).hasSize(1); 2163 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 2164 assertThat(dataNetworkList.get(0).getNetworkCapabilities().hasCapability( 2165 NetworkCapabilities.NET_CAPABILITY_IMS)).isTrue(); 2166 assertThat(dataNetworkList.get(0).getTransport()) 2167 .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2168 2169 // test IWLAN -> EUTRAN no need to tear down because the disallowed rule only applies to MMS 2170 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 2171 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 2172 mDataNetworkControllerUT.obtainMessage(21/*EVENT_PREFERRED_TRANSPORT_CHANGED*/, 2173 NetworkCapabilities.NET_CAPABILITY_IMS, 0).sendToTarget(); 2174 Mockito.clearInvocations(mMockedWwanDataServiceManager); 2175 processAllMessages(); 2176 // Verify that IWWAN handover succeeded. 2177 assertThat(getDataNetworks().get(0).getTransport()).isEqualTo( 2178 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2179 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall( 2180 anyInt(), any(), anyBoolean(), anyBoolean(), 2181 eq(DataService.REQUEST_REASON_HANDOVER), any(), anyInt(), any(), any(), eq(true), 2182 any()); 2183 } 2184 2185 @Test testHandoverDataNetworkNotAllowedByRoamingPolicy()2186 public void testHandoverDataNetworkNotAllowedByRoamingPolicy() throws Exception { 2187 mCarrierConfig.putStringArray(CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 2188 new String[]{"source=EUTRAN|NGRAN|IWLAN, target=EUTRAN|NGRAN|IWLAN, roaming=true, " 2189 + "type=disallowed, capabilities=IMS"}); 2190 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 2191 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 2192 // Force data config manager to reload the carrier config. 2193 mDataNetworkControllerUT.getDataConfigManager().obtainMessage( 2194 1/*EVENT_CARRIER_CONFIG_CHANGED*/).sendToTarget(); 2195 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 2196 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 2197 2198 processAllMessages(); 2199 2200 // Bring up IMS PDN on IWLAN 2201 mDataNetworkControllerUT.addNetworkRequest( 2202 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 2203 processAllMessages(); 2204 verifyConnectedNetworkHasDataProfile(mImsIwlanDataProfile); 2205 2206 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2207 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2208 2209 // Verify IMS PDN is connected. 2210 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2211 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2212 2213 // After this, IMS data network should be disconnected, and DNC should attempt to 2214 // establish a new one on cellular 2215 processAllMessages(); 2216 2217 // Verify all data disconnected. 2218 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 2219 2220 // Should setup a new one instead of handover. 2221 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 2222 anyBoolean(), anyBoolean(), eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), 2223 any(), any(), anyBoolean(), any(Message.class)); 2224 2225 2226 // A new data network should be connected on IWLAN 2227 List<DataNetwork> dataNetworkList = getDataNetworks(); 2228 assertThat(dataNetworkList).hasSize(1); 2229 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 2230 assertThat(dataNetworkList.get(0).getNetworkCapabilities().hasCapability( 2231 NetworkCapabilities.NET_CAPABILITY_IMS)).isTrue(); 2232 assertThat(dataNetworkList.get(0).getTransport()) 2233 .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2234 } 2235 2236 @Test testHandoverDataNetworkRetry()2237 public void testHandoverDataNetworkRetry() throws Exception { 2238 testSetupImsDataNetwork(); 2239 2240 setFailedSetupDataResponse(mMockedWlanDataServiceManager, 2241 DataFailCause.HANDOVER_FAILED, -1, true); 2242 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2243 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2244 2245 DataNetwork dataNetwork = getDataNetworks().get(0); 2246 // Verify that data network is still on cellular 2247 assertThat(dataNetwork.getTransport()).isEqualTo( 2248 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2249 2250 // Set target transport OOS 2251 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 2252 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* data */ 2253 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* voice */ 2254 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, /* iwlan */ 2255 null); 2256 setSuccessfulSetupDataResponse(mMockedWlanDataServiceManager, 1); 2257 2258 processAllFutureMessages(); 2259 // Verify that data network is still on cellular 2260 assertThat(dataNetwork.getTransport()).isEqualTo( 2261 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2262 2263 // Set target transport back to service 2264 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 2265 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* data */ 2266 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* voice */ 2267 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, /* iwlan */ 2268 null); 2269 processAllFutureMessages(); 2270 2271 dataNetwork = getDataNetworks().get(0); 2272 // Verify that data network is handovered to IWLAN 2273 assertThat(dataNetwork.getTransport()).isEqualTo( 2274 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2275 } 2276 2277 @Test testHandoverDataNetworkDuplicateRetry()2278 public void testHandoverDataNetworkDuplicateRetry() throws Exception { 2279 testSetupImsDataNetwork(); 2280 DataNetwork dataNetwork = getDataNetworks().get(0); 2281 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 2282 .when(mAccessNetworksManager).getPreferredTransportByNetworkCapability(anyInt()); 2283 2284 DataRetryManager.DataHandoverRetryEntry retry1 = 2285 new DataRetryManager.DataHandoverRetryEntry.Builder<>() 2286 .setDataNetwork(dataNetwork) 2287 .build(); 2288 DataRetryManager.DataHandoverRetryEntry retry2 = 2289 new DataRetryManager.DataHandoverRetryEntry.Builder<>() 2290 .setDataNetwork(dataNetwork) 2291 .build(); 2292 final Message msg1 = new Message(); 2293 msg1.what = 4 /*EVENT_DATA_HANDOVER_RETRY*/; 2294 msg1.obj = retry1; 2295 2296 final Message msg2 = new Message(); 2297 msg2.what = 4 /*EVENT_DATA_HANDOVER_RETRY*/; 2298 msg2.obj = retry2; 2299 2300 Field field = DataRetryManager.class.getDeclaredField("mDataRetryEntries"); 2301 field.setAccessible(true); 2302 List<DataRetryManager.DataRetryEntry> dataRetryEntries = 2303 (List<DataRetryManager.DataRetryEntry>) 2304 field.get(mDataNetworkControllerUT.getDataRetryManager()); 2305 dataRetryEntries.add(retry1); 2306 dataRetryEntries.add(retry2); 2307 2308 mDataNetworkControllerUT.getDataRetryManager().sendMessageDelayed(msg1, 0); 2309 mDataNetworkControllerUT.getDataRetryManager().sendMessageDelayed(msg2, 0); 2310 2311 processAllFutureMessages(); 2312 2313 setSuccessfulSetupDataResponse(mMockedWlanDataServiceManager, 1); 2314 processAllMessages(); 2315 2316 dataNetwork = getDataNetworks().get(0); 2317 assertThat(dataNetwork.getTransport()).isEqualTo( 2318 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2319 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 2320 anyBoolean(), anyBoolean(), eq(DataService.REQUEST_REASON_HANDOVER), any(), 2321 anyInt(), any(), any(), anyBoolean(), any(Message.class)); 2322 assertThat(mDataNetworkControllerUT.getDataRetryManager() 2323 .isAnyHandoverRetryScheduled(dataNetwork)).isFalse(); 2324 } 2325 2326 @Test testHandoverDataNetworkRetryReachedMaximum()2327 public void testHandoverDataNetworkRetryReachedMaximum() throws Exception { 2328 testSetupImsDataNetwork(); 2329 2330 setFailedSetupDataResponse(mMockedWlanDataServiceManager, 2331 DataFailCause.HANDOVER_FAILED, -1, true); 2332 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2333 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2334 processAllFutureMessages(); 2335 2336 // Should retried 5 times, which is the maximum based on the retry config rules. 2337 verify(mMockedWlanDataServiceManager, times(6)).setupDataCall(anyInt(), 2338 any(DataProfile.class), anyBoolean(), anyBoolean(), 2339 eq(DataService.REQUEST_REASON_HANDOVER), any(), anyInt(), any(), any(), 2340 anyBoolean(), any(Message.class)); 2341 2342 DataNetwork dataNetwork = getDataNetworks().get(0); 2343 // Verify that data network is finally setup on IWLAN. 2344 assertThat(dataNetwork.getTransport()).isEqualTo( 2345 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2346 2347 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 2348 anyBoolean(), anyBoolean(), eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), 2349 any(), any(), anyBoolean(), any(Message.class)); 2350 } 2351 2352 @Test testHandoverDataNetworkRetryReachedMaximumNetworkRequestRemoved()2353 public void testHandoverDataNetworkRetryReachedMaximumNetworkRequestRemoved() throws Exception { 2354 TelephonyNetworkRequest networkRequest = createNetworkRequest( 2355 NetworkCapabilities.NET_CAPABILITY_IMS); 2356 mDataNetworkControllerUT.addNetworkRequest(networkRequest); 2357 processAllMessages(); 2358 2359 setFailedSetupDataResponse(mMockedWlanDataServiceManager, 2360 DataFailCause.HANDOVER_FAILED, -1, true); 2361 mDataNetworkControllerUT.removeNetworkRequest(networkRequest); 2362 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2363 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2364 processAllMessages(); 2365 2366 DataNetwork dataNetwork = getDataNetworks().get(0); 2367 // Verify that data network should remain on cellular. 2368 assertThat(dataNetwork.getTransport()).isEqualTo( 2369 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2370 2371 // There shouldn't be any attempt to retry handover on IWLAN. 2372 verify(mMockedWlanDataServiceManager, times(1)).setupDataCall(anyInt(), 2373 any(DataProfile.class), anyBoolean(), anyBoolean(), 2374 eq(DataService.REQUEST_REASON_HANDOVER), any(), anyInt(), any(), any(), 2375 anyBoolean(), any(Message.class)); 2376 2377 // There shouldn't be any attempt to bring up a new one on IWLAN as well. 2378 verify(mMockedWlanDataServiceManager, never()).setupDataCall(anyInt(), 2379 any(DataProfile.class), anyBoolean(), anyBoolean(), 2380 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), 2381 anyBoolean(), any(Message.class)); 2382 } 2383 2384 @Test testHandoverDataNetworkRetryReachedMaximumDelayImsTearDown()2385 public void testHandoverDataNetworkRetryReachedMaximumDelayImsTearDown() throws Exception { 2386 // Voice call is ongoing 2387 doReturn(PhoneConstants.State.OFFHOOK).when(mCT).getState(); 2388 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL, 2389 true); 2390 carrierConfigChanged(); 2391 2392 testSetupImsDataNetwork(); 2393 2394 setFailedSetupDataResponse(mMockedWlanDataServiceManager, 2395 DataFailCause.HANDOVER_FAILED, -1, true); 2396 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2397 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2398 processAllFutureMessages(); 2399 2400 // Should retried 5 times, which is the maximum based on the retry config rules. 2401 verify(mMockedWlanDataServiceManager, times(6)).setupDataCall(anyInt(), 2402 any(DataProfile.class), anyBoolean(), anyBoolean(), 2403 eq(DataService.REQUEST_REASON_HANDOVER), any(), anyInt(), any(), any(), 2404 anyBoolean(), any(Message.class)); 2405 2406 DataNetwork dataNetwork = getDataNetworks().get(0); 2407 // Verify that data network is still on WWAN because voice call is still ongoing. 2408 assertThat(dataNetwork.getTransport()).isEqualTo( 2409 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2410 2411 } 2412 2413 // Test the device enters from 4G to 3G, and QNS switches the pref just before that happens. 2414 // Make sure we don't tear down the network and let it handover to IWLAN successfully. 2415 @Test testHandoverDataNetworkWhileSwitchTo3G()2416 public void testHandoverDataNetworkWhileSwitchTo3G() throws Exception { 2417 testSetupImsDataNetwork(); 2418 2419 // Before handover the data profile is the cellular IMS data profile 2420 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 2421 2422 // Long delay handover 2423 setSuccessfulSetupDataResponse(mMockedWlanDataServiceManager, 1, 3000); 2424 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 2425 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 2426 mAccessNetworksManagerCallback.onPreferredTransportChanged( 2427 NetworkCapabilities.NET_CAPABILITY_IMS); 2428 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UMTS, 2429 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2430 processAllMessages(); 2431 2432 // Move the time a little bit, handover still not responded. 2433 moveTimeForward(500); 2434 processAllMessages(); 2435 DataNetwork dataNetwork = getDataNetworks().get(0); 2436 // Verify the network is still on cellular, waiting for handover, although already on 3G. 2437 assertThat(dataNetwork.getTransport()).isEqualTo( 2438 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2439 2440 // Now handover should complete. 2441 moveTimeForward(5000); 2442 processAllMessages(); 2443 2444 dataNetwork = getDataNetworks().get(0); 2445 // Verify that IWLAN handover succeeded. 2446 assertThat(dataNetwork.getTransport()).isEqualTo( 2447 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2448 2449 // After handover the data profile is the IWLAN IMS data profile 2450 verifyConnectedNetworkHasDataProfile(mImsIwlanDataProfile); 2451 } 2452 2453 @Test testHandoverDataNetworkFailedNullResponse()2454 public void testHandoverDataNetworkFailedNullResponse() throws Exception { 2455 testSetupImsDataNetwork(); 2456 DataNetwork dataNetwork = getDataNetworks().get(0); 2457 2458 // Set failed null response 2459 doAnswer(invocation -> { 2460 final Message msg = (Message) invocation.getArguments()[10]; 2461 msg.getData().putParcelable("data_call_response", null); 2462 msg.arg1 = DataServiceCallback.RESULT_ERROR_TEMPORARILY_UNAVAILABLE; 2463 msg.getTarget().sendMessageDelayed(msg, 0); 2464 return null; 2465 }).when(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 2466 anyBoolean(), anyBoolean(), eq(DataService.REQUEST_REASON_HANDOVER), any(), 2467 anyInt(), any(), any(), anyBoolean(), any(Message.class)); 2468 2469 // Attempt handover 2470 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 2471 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2472 processAllMessages(); 2473 2474 // Verify that data network is still on cellular and data network was not torn down 2475 assertThat(dataNetwork.getTransport()).isEqualTo( 2476 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2477 assertThat(dataNetwork.isConnected()).isTrue(); 2478 2479 // Process all handover retries and failures 2480 processAllFutureMessages(); 2481 2482 // Verify that original data network was torn down and new connection set up on cellular 2483 assertThat(dataNetwork.getTransport()).isEqualTo( 2484 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2485 assertThat(dataNetwork.isConnected()).isFalse(); 2486 dataNetwork = getDataNetworks().get(0); 2487 assertThat(dataNetwork.getTransport()).isEqualTo( 2488 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 2489 assertThat(dataNetwork.isConnected()).isTrue(); 2490 } 2491 2492 @Test testSetupDataNetworkRetrySuggestedByNetwork()2493 public void testSetupDataNetworkRetrySuggestedByNetwork() { 2494 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 2495 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 2496 mDataNetworkControllerUT.addNetworkRequest( 2497 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2498 processAllFutureMessages(); 2499 2500 // Should retried 20 times, which is the maximum based on the retry config rules. 2501 verify(mMockedWwanDataServiceManager, times(21)).setupDataCall(anyInt(), 2502 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2503 any(), any(), anyBoolean(), any(Message.class)); 2504 } 2505 2506 @Test testSetupDataNetworkRetryFailed()2507 public void testSetupDataNetworkRetryFailed() { 2508 mDataNetworkControllerUT.getDataRetryManager() 2509 .registerCallback(mMockedDataRetryManagerCallback); 2510 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 2511 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 2512 mDataNetworkControllerUT.addNetworkRequest( 2513 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2514 processAllMessages(); 2515 2516 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 2517 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2518 any(), any(), anyBoolean(), any(Message.class)); 2519 2520 // Process first retry 2521 moveTimeForward(2500); 2522 processAllMessages(); 2523 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 2524 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2525 any(), any(), anyBoolean(), any(Message.class)); 2526 ArgumentCaptor<DataRetryManager.DataSetupRetryEntry> retryEntry = 2527 ArgumentCaptor.forClass(DataRetryManager.DataSetupRetryEntry.class); 2528 verify(mMockedDataRetryManagerCallback, times(1)) 2529 .onDataNetworkSetupRetry(retryEntry.capture()); 2530 assertThat(retryEntry.getValue().getState()).isEqualTo( 2531 DataRetryManager.DataRetryEntry.RETRY_STATE_FAILED); 2532 2533 // Cause data network setup failed due to RADIO_DISABLED_BY_CARRIER 2534 doReturn(false).when(mSST).getPowerStateFromCarrier(); 2535 2536 // Process second retry and ensure data network setup failed 2537 moveTimeForward(3000); 2538 processAllMessages(); 2539 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 2540 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2541 any(), any(), anyBoolean(), any(Message.class)); 2542 verify(mMockedDataRetryManagerCallback, times(2)) 2543 .onDataNetworkSetupRetry(retryEntry.capture()); 2544 assertThat(retryEntry.getValue().getState()).isEqualTo( 2545 DataRetryManager.DataRetryEntry.RETRY_STATE_FAILED); 2546 2547 // Data network setup allowed again 2548 doReturn(true).when(mSST).getPowerStateFromCarrier(); 2549 2550 // Should not retry again after retry failure 2551 processAllFutureMessages(); 2552 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 2553 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2554 any(), any(), anyBoolean(), any(Message.class)); 2555 } 2556 2557 @Test testSetupDataNetworkRetryFailedNetworkRequestRemoved()2558 public void testSetupDataNetworkRetryFailedNetworkRequestRemoved() { 2559 mDataNetworkControllerUT.getDataRetryManager() 2560 .registerCallback(mMockedDataRetryManagerCallback); 2561 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 2562 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 2563 TelephonyNetworkRequest tnr = createNetworkRequest( 2564 NetworkCapabilities.NET_CAPABILITY_INTERNET); 2565 mDataNetworkControllerUT.addNetworkRequest(tnr); 2566 2567 processAllMessages(); 2568 2569 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 2570 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2571 any(), any(), anyBoolean(), any(Message.class)); 2572 Mockito.clearInvocations(mMockedWwanDataServiceManager); 2573 2574 logd("Remove internet network request"); 2575 mDataNetworkControllerUT.removeNetworkRequest(tnr); 2576 2577 moveTimeForward(2500); 2578 processAllMessages(); 2579 2580 // There should be no retry since request has been removed. 2581 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 2582 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2583 any(), any(), anyBoolean(), any(Message.class)); 2584 Mockito.clearInvocations(mMockedWwanDataServiceManager); 2585 2586 // Now send another IMS request 2587 tnr = createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS); 2588 mDataNetworkControllerUT.addNetworkRequest(tnr); 2589 processAllMessages(); 2590 2591 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 2592 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2593 any(), any(), anyBoolean(), any(Message.class)); 2594 Mockito.clearInvocations(mMockedWwanDataServiceManager); 2595 2596 logd("Remove IMS network request"); 2597 mDataNetworkControllerUT.removeNetworkRequest(tnr); 2598 2599 // There should be no retry since request has been removed. 2600 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 2601 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2602 any(), any(), anyBoolean(), any(Message.class)); 2603 } 2604 2605 @Test testSetupDataNetworkRetryFailedNetworkRequestRemovedAndAdded()2606 public void testSetupDataNetworkRetryFailedNetworkRequestRemovedAndAdded() throws Exception { 2607 mDataNetworkControllerUT.getDataRetryManager() 2608 .registerCallback(mMockedDataRetryManagerCallback); 2609 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 2610 10000, false); 2611 2612 TelephonyNetworkRequest firstTnr = createNetworkRequest( 2613 NetworkCapabilities.NET_CAPABILITY_IMS); 2614 TelephonyNetworkRequest secondTnr = createNetworkRequest( 2615 NetworkCapabilities.NET_CAPABILITY_IMS); 2616 2617 mDataNetworkControllerUT.addNetworkRequest(firstTnr); 2618 processAllMessages(); 2619 2620 mDataNetworkControllerUT.removeNetworkRequest(firstTnr); 2621 mDataNetworkControllerUT.addNetworkRequest(secondTnr); 2622 processAllFutureMessages(); 2623 2624 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 2625 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2626 any(), any(), anyBoolean(), any(Message.class)); 2627 2628 ArgumentCaptor<DataRetryManager.DataSetupRetryEntry> retryEntry = 2629 ArgumentCaptor.forClass(DataRetryManager.DataSetupRetryEntry.class); 2630 verify(mMockedDataRetryManagerCallback, times(1)) 2631 .onDataNetworkSetupRetry(retryEntry.capture()); 2632 assertThat(retryEntry.getValue().getState()).isEqualTo( 2633 DataRetryManager.DataRetryEntry.RETRY_STATE_FAILED); 2634 assertThat(retryEntry.getValue().networkRequestList.size()).isEqualTo(1); 2635 assertThat(retryEntry.getValue().networkRequestList.get(0)).isEqualTo(firstTnr); 2636 2637 DataRetryManager.DataSetupRetryEntry dataSetupRetryEntry = retryEntry.getValue(); 2638 logd("DataSetupRetryEntry:" + dataSetupRetryEntry); 2639 2640 processAllMessages(); 2641 processAllFutureMessages(); 2642 2643 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 1); 2644 logd("Sending TAC_CHANGED event"); 2645 mDataNetworkControllerUT.obtainMessage(25/*EVENT_TAC_CHANGED*/).sendToTarget(); 2646 mDataNetworkControllerUT.getDataRetryManager().obtainMessage(10/*EVENT_TAC_CHANGED*/) 2647 .sendToTarget(); 2648 processAllFutureMessages(); 2649 2650 // TAC changes should clear the already-scheduled retry and throttling. 2651 assertThat(mDataNetworkControllerUT.getDataRetryManager().isAnySetupRetryScheduled( 2652 mImsCellularDataProfile, AccessNetworkConstants.TRANSPORT_TYPE_WWAN)).isFalse(); 2653 2654 // But DNC should re-evaluate unsatisfied request and setup IMS again. 2655 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2656 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2657 2658 verify(mMockedWwanDataServiceManager, times(2)).setupDataCall(anyInt(), 2659 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2660 any(), any(), anyBoolean(), any(Message.class)); 2661 } 2662 2663 @Test testSetupDataNetworkPermanentFailure()2664 public void testSetupDataNetworkPermanentFailure() { 2665 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.PROTOCOL_ERRORS, 2666 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 2667 mDataNetworkControllerUT.addNetworkRequest( 2668 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2669 processAllFutureMessages(); 2670 2671 // There should be only one attempt, and no retry should happen because it's a permanent 2672 // failure. 2673 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 2674 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2675 any(), any(), anyBoolean(), any(Message.class)); 2676 2677 Mockito.clearInvocations(mMockedWwanDataServiceManager); 2678 mDataNetworkControllerUT.addNetworkRequest( 2679 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2680 processAllFutureMessages(); 2681 2682 // Even receiving a new network request, setup data call should not be sent. 2683 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 2684 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2685 any(), any(), anyBoolean(), any(Message.class)); 2686 // APN should be marked as permanent failure. 2687 assertThat(mGeneralPurposeDataProfile.getApnSetting().getPermanentFailed()).isTrue(); 2688 } 2689 2690 @Test testSetupDataNetworkConditionChangesAfterPermanentFailure()2691 public void testSetupDataNetworkConditionChangesAfterPermanentFailure() throws Exception { 2692 testSetupDataNetworkPermanentFailure(); 2693 2694 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 2695 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 1); 2696 2697 // From LTE to NR 2698 serviceStateChanged(TelephonyManager.NETWORK_TYPE_NR, 2699 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 2700 2701 // condition change should trigger setup data, even though previously the APN has been 2702 // marked as permanent failure. 2703 verifyInternetConnected(); 2704 } 2705 2706 @Test testSetupDataNetworkNetworkSuggestedNeverRetry()2707 public void testSetupDataNetworkNetworkSuggestedNeverRetry() { 2708 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.PROTOCOL_ERRORS, 2709 Long.MAX_VALUE, false); 2710 mDataNetworkControllerUT.addNetworkRequest( 2711 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2712 processAllFutureMessages(); 2713 2714 // There should be only one attempt, and no retry should happen because it's a permanent 2715 // failure. 2716 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 2717 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2718 any(), any(), anyBoolean(), any(Message.class)); 2719 } 2720 2721 @Test testSetupDataNetworkNetworkSuggestedRetryTimerDataThrottled()2722 public void testSetupDataNetworkNetworkSuggestedRetryTimerDataThrottled() { 2723 mDataNetworkControllerUT.getDataRetryManager() 2724 .registerCallback(mMockedDataRetryManagerCallback); 2725 2726 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.PROTOCOL_ERRORS, 2727 10000, false); 2728 mDataNetworkControllerUT.addNetworkRequest( 2729 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 2730 processAllMessages(); 2731 2732 mDataNetworkControllerUT.addNetworkRequest( 2733 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 2734 processAllMessages(); 2735 2736 // There should be only one attempt, and no retry should happen because the second one 2737 // was throttled. 2738 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 2739 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 2740 any(), any(), anyBoolean(), any(Message.class)); 2741 2742 ArgumentCaptor<List<ThrottleStatus>> throttleStatusCaptor = 2743 ArgumentCaptor.forClass(List.class); 2744 verify(mMockedDataRetryManagerCallback) 2745 .onThrottleStatusChanged(throttleStatusCaptor.capture()); 2746 assertThat(throttleStatusCaptor.getValue()).hasSize(1); 2747 ThrottleStatus throttleStatus = throttleStatusCaptor.getValue().get(0); 2748 assertThat(throttleStatus.getApnType()).isEqualTo(ApnSetting.TYPE_IMS); 2749 assertThat(throttleStatus.getRetryType()) 2750 .isEqualTo(ThrottleStatus.RETRY_TYPE_NEW_CONNECTION); 2751 assertThat(throttleStatus.getTransportType()) 2752 .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 2753 } 2754 2755 @Test testTacChangesClearThrottlingAndRetryHappens()2756 public void testTacChangesClearThrottlingAndRetryHappens() throws Exception { 2757 testSetupDataNetworkNetworkSuggestedRetryTimerDataThrottled(); 2758 processAllFutureMessages(); 2759 2760 setSuccessfulSetupDataResponse(mMockedWwanDataServiceManager, 1); 2761 logd("Sending TAC_CHANGED event"); 2762 mDataNetworkControllerUT.obtainMessage(25/*EVENT_TAC_CHANGED*/).sendToTarget(); 2763 mDataNetworkControllerUT.getDataRetryManager().obtainMessage(10/*EVENT_TAC_CHANGED*/) 2764 .sendToTarget(); 2765 processAllFutureMessages(); 2766 2767 // TAC changes should clear the already-scheduled retry and throttling. 2768 assertThat(mDataNetworkControllerUT.getDataRetryManager().isAnySetupRetryScheduled( 2769 mImsCellularDataProfile, AccessNetworkConstants.TRANSPORT_TYPE_WWAN)).isFalse(); 2770 2771 // But DNC should re-evaluate unsatisfied request and setup IMS again. 2772 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 2773 NetworkCapabilities.NET_CAPABILITY_MMTEL); 2774 } 2775 2776 @Test testNrAdvancedByPco()2777 public void testNrAdvancedByPco() throws Exception { 2778 testSetupDataNetwork(); 2779 verify(mMockedDataNetworkControllerCallback, never()) 2780 .onNrAdvancedCapableByPcoChanged(anyBoolean()); 2781 mSimulatedCommands.triggerPcoData(1, "IPV6", 1234, new byte[]{1}); 2782 processAllMessages(); 2783 verify(mMockedDataNetworkControllerCallback).onNrAdvancedCapableByPcoChanged(eq(true)); 2784 2785 mSimulatedCommands.triggerPcoData(1, "IPV6", 1234, new byte[]{0}); 2786 processAllMessages(); 2787 verify(mMockedDataNetworkControllerCallback).onNrAdvancedCapableByPcoChanged(eq(false)); 2788 } 2789 2790 @Test testNrAdvancedByEarlyPco()2791 public void testNrAdvancedByEarlyPco() { 2792 Mockito.reset(mMockedWwanDataServiceManager); 2793 mDataNetworkControllerUT.addNetworkRequest( 2794 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2795 processAllMessages(); 2796 2797 // PCO data arrives before data network entering connected state. 2798 mSimulatedCommands.triggerPcoData(1, "IPV6", 1234, new byte[]{1}); 2799 processAllMessages(); 2800 2801 ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class); 2802 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 2803 anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 2804 messageCaptor.capture()); 2805 2806 // Send setup data call complete message. 2807 Message msg = messageCaptor.getValue(); 2808 msg.getData().putParcelable("data_call_response", 2809 createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE)); 2810 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 2811 msg.sendToTarget(); 2812 processAllMessages(); 2813 2814 verify(mMockedDataNetworkControllerCallback).onNrAdvancedCapableByPcoChanged(eq(true)); 2815 } 2816 2817 @Test testNrAdvancedByPcoMultipleNetworks()2818 public void testNrAdvancedByPcoMultipleNetworks() throws Exception { 2819 testSetupDataNetwork(); 2820 setSuccessfulSetupDataResponse(mMockedDataServiceManagers 2821 .get(AccessNetworkConstants.TRANSPORT_TYPE_WWAN), 2); 2822 testSetupImsDataNetwork(); 2823 2824 verify(mMockedDataNetworkControllerCallback, never()) 2825 .onNrAdvancedCapableByPcoChanged(anyBoolean()); 2826 mSimulatedCommands.triggerPcoData(2, "IPV6", 1234, new byte[]{1}); 2827 processAllMessages(); 2828 verify(mMockedDataNetworkControllerCallback).onNrAdvancedCapableByPcoChanged(eq(true)); 2829 } 2830 2831 @Test testNrAdvancedByEarlyUnrelatedPco()2832 public void testNrAdvancedByEarlyUnrelatedPco() { 2833 Mockito.reset(mMockedWwanDataServiceManager); 2834 mDataNetworkControllerUT.addNetworkRequest( 2835 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 2836 processAllMessages(); 2837 2838 // Unrelated PCO data arrives before data network entering connected state. 2839 mSimulatedCommands.triggerPcoData(2, "IPV6", 1234, new byte[]{1}); 2840 processAllMessages(); 2841 2842 ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class); 2843 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), 2844 anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 2845 messageCaptor.capture()); 2846 2847 // Send setup data call complete message. 2848 Message msg = messageCaptor.getValue(); 2849 msg.getData().putParcelable("data_call_response", 2850 createDataCallResponse(1, DataCallResponse.LINK_STATUS_ACTIVE)); 2851 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 2852 msg.sendToTarget(); 2853 processAllMessages(); 2854 2855 verify(mMockedDataNetworkControllerCallback, never()).onNrAdvancedCapableByPcoChanged( 2856 anyBoolean()); 2857 } 2858 2859 2860 @Test testSetupDataNetworkVcnManaged()2861 public void testSetupDataNetworkVcnManaged() throws Exception { 2862 // VCN managed 2863 setVcnManagerPolicy(true, false); 2864 NetworkRequest request = new NetworkRequest.Builder() 2865 .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) 2866 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED) 2867 .build(); 2868 TelephonyNetworkRequest tnr = new TelephonyNetworkRequest(request, mPhone); 2869 2870 mDataNetworkControllerUT.addNetworkRequest(tnr); 2871 processAllMessages(); 2872 2873 verify(mMockedDataNetworkControllerCallback) 2874 .onInternetDataNetworkConnected(any()); 2875 List<DataNetwork> dataNetworks = getDataNetworks(); 2876 assertThat(dataNetworks).hasSize(1); 2877 assertThat(dataNetworks.get(0).getNetworkCapabilities().hasCapability( 2878 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)).isFalse(); 2879 assertThat(dataNetworks.get(0).isInternetSupported()).isTrue(); 2880 assertThat(dataNetworks.get(0).getNetworkCapabilities().hasCapability( 2881 NetworkCapabilities.NET_CAPABILITY_INTERNET)).isTrue(); 2882 } 2883 2884 @Test testSetupDataNetworkVcnRequestedTeardown()2885 public void testSetupDataNetworkVcnRequestedTeardown() throws Exception { 2886 // VCN managed, tear down on setup. 2887 setVcnManagerPolicy(true, true); 2888 NetworkRequest request = new NetworkRequest.Builder() 2889 .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) 2890 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED) 2891 .build(); 2892 TelephonyNetworkRequest tnr = new TelephonyNetworkRequest(request, mPhone); 2893 2894 mDataNetworkControllerUT.addNetworkRequest(tnr); 2895 processAllMessages(); 2896 2897 // Should not be any data network created. 2898 List<DataNetwork> dataNetworks = getDataNetworks(); 2899 assertThat(dataNetworks).hasSize(0); 2900 } 2901 2902 @Test testVcnManagedNetworkPolicyChanged()2903 public void testVcnManagedNetworkPolicyChanged() throws Exception { 2904 testSetupDataNetworkVcnManaged(); 2905 2906 setVcnManagerPolicy(true, true); 2907 ArgumentCaptor<VcnNetworkPolicyChangeListener> listenerCaptor = 2908 ArgumentCaptor.forClass(VcnNetworkPolicyChangeListener.class); 2909 verify(mVcnManager).addVcnNetworkPolicyChangeListener(any(Executor.class), 2910 listenerCaptor.capture()); 2911 2912 // Trigger policy changed event 2913 VcnNetworkPolicyChangeListener listener = listenerCaptor.getValue(); 2914 listener.onPolicyChanged(); 2915 processAllMessages(); 2916 2917 List<DataNetwork> dataNetworks = getDataNetworks(); 2918 assertThat(dataNetworks).hasSize(0); 2919 } 2920 2921 @Test testDataDisableNotTearingDownUnmetered()2922 public void testDataDisableNotTearingDownUnmetered() throws Exception { 2923 // User data enabled 2924 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2925 TelephonyManager.DATA_ENABLED_REASON_USER, true, mContext.getOpPackageName()); 2926 processAllMessages(); 2927 2928 testSetupImsDataNetwork(); 2929 Mockito.clearInvocations(mMockedDataNetworkControllerCallback); 2930 2931 // User data disabled 2932 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2933 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2934 processAllMessages(); 2935 2936 // There shouldn't be all data disconnected event. 2937 verify(mMockedDataNetworkControllerCallback, never()) 2938 .onAnyDataNetworkExistingChanged(anyBoolean()); 2939 2940 // Verify IMS is still alive. 2941 List<DataNetwork> dataNetworkList = getDataNetworks(); 2942 assertThat(dataNetworkList).hasSize(1); 2943 assertThat(dataNetworkList.get(0).getNetworkCapabilities() 2944 .hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)).isTrue(); 2945 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 2946 } 2947 2948 @Test testDataDisableTearingDownTetheringNetwork()2949 public void testDataDisableTearingDownTetheringNetwork() throws Exception { 2950 // User data enabled 2951 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2952 TelephonyManager.DATA_ENABLED_REASON_USER, true, mContext.getOpPackageName()); 2953 processAllMessages(); 2954 2955 // Request the restricted tethering network. 2956 NetworkCapabilities netCaps = new NetworkCapabilities(); 2957 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_DUN); 2958 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2959 2960 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 2961 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 2962 2963 mDataNetworkControllerUT.addNetworkRequest( 2964 new TelephonyNetworkRequest(nativeNetworkRequest, mPhone)); 2965 processAllMessages(); 2966 2967 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_DUN); 2968 2969 // User data disabled 2970 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2971 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2972 processAllMessages(); 2973 2974 // Everything should be disconnected. 2975 verifyAllDataDisconnected(); 2976 } 2977 2978 @Test testDataDisableNotAllowingBringingUpTetheringNetwork()2979 public void testDataDisableNotAllowingBringingUpTetheringNetwork() throws Exception { 2980 // User data disabled 2981 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 2982 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 2983 processAllMessages(); 2984 2985 // Request the restricted tethering network. 2986 NetworkCapabilities netCaps = new NetworkCapabilities(); 2987 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_DUN); 2988 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 2989 2990 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 2991 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 2992 2993 mDataNetworkControllerUT.addNetworkRequest( 2994 new TelephonyNetworkRequest(nativeNetworkRequest, mPhone)); 2995 processAllMessages(); 2996 2997 // Everything should be disconnected. 2998 verifyAllDataDisconnected(); 2999 3000 // Telephony should not try to setup a data call for DUN. 3001 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 3002 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3003 any(), any(), anyBoolean(), any(Message.class)); 3004 } 3005 3006 @Test testNonVoPSNoIMSSetup()3007 public void testNonVoPSNoIMSSetup() throws Exception { 3008 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3009 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 3010 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)); 3011 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 3012 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 3013 3014 mDataNetworkControllerUT.addNetworkRequest( 3015 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 3016 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 3017 processAllMessages(); 3018 3019 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3020 verifyAllDataDisconnected(); 3021 } 3022 3023 @Test testNonVoPStoVoPSImsSetup()3024 public void testNonVoPStoVoPSImsSetup() throws Exception { 3025 // Even allow lingering when NoVops, should have no effect on NoVops -> Vops 3026 mCarrierConfig.putBoolean(CarrierConfigManager.Ims.KEY_KEEP_PDN_UP_IN_NO_VOPS_BOOL, true); 3027 carrierConfigChanged(); 3028 3029 // VOPS not supported 3030 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3031 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 3032 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)); 3033 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 3034 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 3035 3036 mDataNetworkControllerUT.addNetworkRequest( 3037 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 3038 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 3039 processAllMessages(); 3040 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3041 3042 // VoPS supported 3043 dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3044 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 3045 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)); 3046 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 3047 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 3048 3049 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3050 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3051 } 3052 3053 @Test testDelayImsTearDownCsRequestsToTearDown()3054 public void testDelayImsTearDownCsRequestsToTearDown() throws Exception { 3055 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL, 3056 true); 3057 TelephonyNetworkRequest networkRequest = createNetworkRequest( 3058 NetworkCapabilities.NET_CAPABILITY_IMS); 3059 mDataNetworkControllerUT.addNetworkRequest(networkRequest); 3060 processAllMessages(); 3061 3062 // Call is ongoing 3063 doReturn(PhoneConstants.State.OFFHOOK).when(mCT).getState(); 3064 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3065 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3066 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 3067 List<DataNetwork> dataNetworks = getDataNetworks(); 3068 assertThat(dataNetworks).hasSize(1); 3069 dataNetworks.get(0).tearDown(DataNetwork.TEAR_DOWN_REASON_RAT_NOT_ALLOWED); 3070 processAllMessages(); 3071 3072 // Make sure IMS network is still connected. 3073 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3074 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3075 verifyConnectedNetworkHasDataProfile(mImsCellularDataProfile); 3076 3077 // Now connectivity service requests to tear down the data network. 3078 mDataNetworkControllerUT.removeNetworkRequest(networkRequest); 3079 dataNetworks.get(0).tearDown(DataNetwork.TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 3080 processAllMessages(); 3081 3082 // All data (including IMS) should be torn down. 3083 verifyAllDataDisconnected(); 3084 } 3085 3086 @Test testUnmeteredMmsWhenDataDisabled()3087 public void testUnmeteredMmsWhenDataDisabled() throws Exception { 3088 mCarrierConfig.putStringArray( 3089 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 3090 new String[]{"default", "dun", "supl"}); 3091 carrierConfigChanged(); 3092 3093 // User data disabled 3094 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 3095 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 3096 processAllMessages(); 3097 3098 mDataNetworkControllerUT.addNetworkRequest( 3099 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 3100 processAllMessages(); 3101 3102 // Make sure MMS is the only capability advertised, but not internet or SUPL. 3103 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 3104 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 3105 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3106 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL); 3107 } 3108 3109 @Test testUnmeteredMmsWhenRoamingDisabled()3110 public void testUnmeteredMmsWhenRoamingDisabled() throws Exception { 3111 mCarrierConfig.putStringArray( 3112 CarrierConfigManager.KEY_CARRIER_METERED_ROAMING_APN_TYPES_STRINGS, 3113 new String[]{"default", "dun", "supl"}); 3114 carrierConfigChanged(); 3115 3116 // Roaming data disabled 3117 mDataNetworkControllerUT.getDataSettingsManager().setDataRoamingEnabled(false); 3118 processAllMessages(); 3119 3120 // Device is roaming 3121 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 3122 NetworkRegistrationInfo.REGISTRATION_STATE_ROAMING); 3123 3124 mDataNetworkControllerUT.addNetworkRequest( 3125 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_MMS)); 3126 processAllMessages(); 3127 3128 // Make sure MMS is the only capability advertised, but not internet or SUPL. 3129 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 3130 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 3131 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3132 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL); 3133 } 3134 3135 @Test testRestrictedNetworkRequestDataDisabled()3136 public void testRestrictedNetworkRequestDataDisabled() throws Exception { 3137 // User data disabled 3138 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 3139 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 3140 processAllMessages(); 3141 3142 // Create a restricted network request. 3143 NetworkCapabilities netCaps = new NetworkCapabilities(); 3144 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3145 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 3146 3147 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 3148 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 3149 3150 mDataNetworkControllerUT.addNetworkRequest( 3151 new TelephonyNetworkRequest(nativeNetworkRequest, mPhone)); 3152 processAllMessages(); 3153 3154 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 3155 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET, 3156 NetworkCapabilities.NET_CAPABILITY_SUPL, NetworkCapabilities.NET_CAPABILITY_MMS); 3157 3158 List<DataNetwork> dataNetworks = getDataNetworks(); 3159 // Make sure the network is restricted. 3160 assertThat(dataNetworks.get(0).getNetworkCapabilities() 3161 .hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)).isFalse(); 3162 } 3163 3164 @Test testRestrictedNetworkRequestDataEnabled()3165 public void testRestrictedNetworkRequestDataEnabled() throws Exception { 3166 // Create a restricted network request. 3167 NetworkCapabilities netCaps = new NetworkCapabilities(); 3168 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3169 netCaps.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 3170 3171 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 3172 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 3173 3174 mDataNetworkControllerUT.addNetworkRequest( 3175 new TelephonyNetworkRequest(nativeNetworkRequest, mPhone)); 3176 processAllMessages(); 3177 3178 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 3179 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_INTERNET, 3180 NetworkCapabilities.NET_CAPABILITY_SUPL, NetworkCapabilities.NET_CAPABILITY_MMS, 3181 // Because data is enabled, even though the network request is restricted, the 3182 // network should still be not-restricted. 3183 NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); 3184 } 3185 3186 @Test testSinglePdnArbitration()3187 public void testSinglePdnArbitration() throws Exception { 3188 // On old 1x network, only one data network is allowed. 3189 serviceStateChanged(TelephonyManager.NETWORK_TYPE_1xRTT, 3190 NetworkRegistrationInfo.REGISTRATION_STATE_HOME); 3191 3192 mDataNetworkControllerUT.addNetworkRequest( 3193 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_DUN)); 3194 processAllMessages(); 3195 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_DUN); 3196 3197 mDataNetworkControllerUT.addNetworkRequest( 3198 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 3199 processAllFutureMessages(); 3200 // Lower priority network should not trump the higher priority network. 3201 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_DUN); 3202 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3203 3204 // Now send a higher priority network request 3205 TelephonyNetworkRequest fotaRequest = createNetworkRequest( 3206 NetworkCapabilities.NET_CAPABILITY_FOTA); 3207 mDataNetworkControllerUT.addNetworkRequest(fotaRequest); 3208 3209 processAllFutureMessages(); 3210 // The existing internet data network should be torn down. 3211 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_DUN); 3212 // The higher priority emergency data network should be established. 3213 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_FOTA); 3214 3215 // Now remove the fota request and tear down fota network. 3216 mDataNetworkControllerUT.removeNetworkRequest(fotaRequest); 3217 processAllMessages(); 3218 List<DataNetwork> dataNetworks = getDataNetworks(); 3219 dataNetworks.get(0).tearDown(DataNetwork.TEAR_DOWN_REASON_CONNECTIVITY_SERVICE_UNWANTED); 3220 processAllMessages(); 3221 3222 // The tethering data network should come back since now it has the highest priority after 3223 // fota is gone. 3224 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_DUN); 3225 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA); 3226 } 3227 3228 @Test testImsGracefulTearDown()3229 public void testImsGracefulTearDown() throws Exception { 3230 setImsRegistered(true); 3231 setRcsRegistered(true); 3232 3233 NetworkCapabilities netCaps = new NetworkCapabilities(); 3234 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3235 netCaps.setRequestorPackageName(FAKE_MMTEL_PACKAGE); 3236 3237 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 3238 ConnectivityManager.TYPE_MOBILE, ++mNetworkRequestId, NetworkRequest.Type.REQUEST); 3239 TelephonyNetworkRequest networkRequest = new TelephonyNetworkRequest( 3240 nativeNetworkRequest, mPhone); 3241 3242 mDataNetworkControllerUT.addNetworkRequest(networkRequest); 3243 3244 processAllMessages(); 3245 Mockito.clearInvocations(mPhone); 3246 3247 // SIM removal 3248 mDataNetworkControllerUT.obtainMessage(9/*EVENT_SIM_STATE_CHANGED*/, 3249 TelephonyManager.SIM_STATE_ABSENT, 0).sendToTarget(); 3250 processAllMessages(); 3251 3252 // Make sure data network enters disconnecting state 3253 ArgumentCaptor<PreciseDataConnectionState> pdcsCaptor = 3254 ArgumentCaptor.forClass(PreciseDataConnectionState.class); 3255 verify(mPhone).notifyDataConnection(pdcsCaptor.capture()); 3256 PreciseDataConnectionState pdcs = pdcsCaptor.getValue(); 3257 assertThat(pdcs.getState()).isEqualTo(TelephonyManager.DATA_DISCONNECTING); 3258 3259 // IMS de-registered. Now data network is safe to be torn down. 3260 Mockito.clearInvocations(mPhone); 3261 setImsRegistered(false); 3262 setRcsRegistered(false); 3263 processAllMessages(); 3264 3265 // All data should be disconnected. 3266 verifyAllDataDisconnected(); 3267 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3268 verify(mPhone).notifyDataConnection(pdcsCaptor.capture()); 3269 pdcs = pdcsCaptor.getValue(); 3270 assertThat(pdcs.getState()).isEqualTo(TelephonyManager.DATA_DISCONNECTED); 3271 } 3272 3273 @Test testNetworkRequestRemovedBeforeRetry()3274 public void testNetworkRequestRemovedBeforeRetry() { 3275 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 3276 DataCallResponse.RETRY_DURATION_UNDEFINED, false); 3277 TelephonyNetworkRequest networkRequest = createNetworkRequest( 3278 NetworkCapabilities.NET_CAPABILITY_INTERNET); 3279 mDataNetworkControllerUT.addNetworkRequest(networkRequest); 3280 logd("Removing network request."); 3281 mDataNetworkControllerUT.removeNetworkRequest(networkRequest); 3282 processAllMessages(); 3283 3284 // There should be only one invocation, which is the original setup data request. There 3285 // shouldn't be more than 1 (i.e. should not retry). 3286 verify(mMockedWwanDataServiceManager, times(1)).setupDataCall(anyInt(), 3287 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3288 any(), any(), anyBoolean(), any(Message.class)); 3289 } 3290 3291 @Test testGetInternetDataDisallowedReasons()3292 public void testGetInternetDataDisallowedReasons() { 3293 List<DataDisallowedReason> reasons = mDataNetworkControllerUT 3294 .getInternetDataDisallowedReasons(); 3295 assertThat(reasons).isEmpty(); 3296 3297 serviceStateChanged(TelephonyManager.NETWORK_TYPE_UNKNOWN, 3298 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 3299 3300 reasons = mDataNetworkControllerUT.getInternetDataDisallowedReasons(); 3301 assertThat(reasons).containsExactly(DataDisallowedReason.NOT_IN_SERVICE, 3302 DataDisallowedReason.NO_SUITABLE_DATA_PROFILE); 3303 } 3304 3305 @Test testEmergencySuplDataDisabled()3306 public void testEmergencySuplDataDisabled() throws Exception { 3307 // Data disabled 3308 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 3309 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 3310 processAllMessages(); 3311 doReturn(true).when(mPhone).isInEmergencyCall(); 3312 mDataNetworkControllerUT.addNetworkRequest( 3313 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_SUPL)); 3314 processAllMessages(); 3315 3316 // Make sure SUPL is the only capability advertised, but not internet or MMS. 3317 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_SUPL); 3318 verifyConnectedNetworkHasDataProfile(mGeneralPurposeDataProfile); 3319 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3320 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMS); 3321 } 3322 3323 @Test testEmergencyCallDataDisabled()3324 public void testEmergencyCallDataDisabled() throws Exception { 3325 doReturn(true).when(mPhone).isInEmergencyCall(); 3326 mDataNetworkControllerUT.addNetworkRequest( 3327 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 3328 processAllMessages(); 3329 3330 verifyInternetConnected(); 3331 3332 // Data disabled 3333 mDataNetworkControllerUT.getDataSettingsManager().setDataEnabled( 3334 TelephonyManager.DATA_ENABLED_REASON_USER, false, mContext.getOpPackageName()); 3335 processAllMessages(); 3336 3337 // Make sure internet is not connected. (Previously it has a bug due to incorrect logic 3338 // to determine it's for emergency SUPL). 3339 verifyAllDataDisconnected(); 3340 } 3341 3342 @Test testDataActivity()3343 public void testDataActivity() { 3344 doReturn(TelephonyManager.DATA_ACTIVITY_IN).when(mLinkBandwidthEstimator).getDataActivity(); 3345 mLinkBandwidthEstimatorCallback.onDataActivityChanged(TelephonyManager.DATA_ACTIVITY_IN); 3346 processAllMessages(); 3347 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 3348 TelephonyManager.DATA_ACTIVITY_IN); 3349 3350 doReturn(TelephonyManager.DATA_ACTIVITY_OUT).when(mLinkBandwidthEstimator) 3351 .getDataActivity(); 3352 mLinkBandwidthEstimatorCallback.onDataActivityChanged(TelephonyManager.DATA_ACTIVITY_OUT); 3353 processAllMessages(); 3354 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 3355 TelephonyManager.DATA_ACTIVITY_OUT); 3356 3357 doReturn(TelephonyManager.DATA_ACTIVITY_INOUT).when(mLinkBandwidthEstimator) 3358 .getDataActivity(); 3359 mLinkBandwidthEstimatorCallback.onDataActivityChanged(TelephonyManager.DATA_ACTIVITY_INOUT); 3360 processAllMessages(); 3361 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 3362 TelephonyManager.DATA_ACTIVITY_INOUT); 3363 3364 doReturn(TelephonyManager.DATA_ACTIVITY_NONE).when(mLinkBandwidthEstimator) 3365 .getDataActivity(); 3366 mLinkBandwidthEstimatorCallback.onDataActivityChanged(TelephonyManager.DATA_ACTIVITY_NONE); 3367 processAllMessages(); 3368 assertThat(mDataNetworkControllerUT.getDataActivity()).isEqualTo( 3369 TelephonyManager.DATA_ACTIVITY_NONE); 3370 } 3371 3372 @Test testHandoverDataNetworkOos()3373 public void testHandoverDataNetworkOos() throws Exception { 3374 ServiceState ss = new ServiceState(); 3375 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3376 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3377 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3378 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3379 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3380 .build()); 3381 3382 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3383 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 3384 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN) 3385 .setRegistrationState( 3386 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING) 3387 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3388 .build()); 3389 3390 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3391 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3392 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3393 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3394 .setDomain(NetworkRegistrationInfo.DOMAIN_CS) 3395 .build()); 3396 processServiceStateRegStateForTest(ss); 3397 doReturn(ss).when(mSST).getServiceState(); 3398 doReturn(ss).when(mPhone).getServiceState(); 3399 3400 mDataNetworkControllerUT.obtainMessage(17/*EVENT_SERVICE_STATE_CHANGED*/).sendToTarget(); 3401 processAllMessages(); 3402 3403 testSetupImsDataNetwork(); 3404 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3405 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3406 3407 // Verify that handover is not performed. 3408 verify(mMockedWlanDataServiceManager, never()).setupDataCall(anyInt(), 3409 any(DataProfile.class), anyBoolean(), anyBoolean(), 3410 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(), 3411 any(Message.class)); 3412 3413 // IMS network should be torn down. 3414 verifyAllDataDisconnected(); 3415 } 3416 3417 @Test testHandoverDataNetworkSourceOos()3418 public void testHandoverDataNetworkSourceOos() throws Exception { 3419 testSetupImsDataNetwork(); 3420 // Configured handover is allowed from OOS to 4G/5G/IWLAN. 3421 mCarrierConfig.putStringArray( 3422 CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY, 3423 new String[]{ 3424 "source=EUTRAN|NGRAN|IWLAN|UNKNOWN, target=EUTRAN|NGRAN|IWLAN, " 3425 + "type=disallowed, capabilities=IMS|EIMS|MMS|XCAP|CBS" 3426 }); 3427 carrierConfigChanged(); 3428 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 3429 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING); 3430 3431 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3432 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3433 3434 // Verify IMS network was torn down on source first. 3435 verify(mMockedWwanDataServiceManager).deactivateDataCall(anyInt(), 3436 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 3437 3438 // Verify that IWLAN is brought up again on IWLAN. 3439 verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), 3440 any(DataProfile.class), anyBoolean(), anyBoolean(), 3441 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(), 3442 any(Message.class)); 3443 3444 DataNetwork dataNetwork = getDataNetworks().get(0); 3445 assertThat(dataNetwork.getTransport()).isEqualTo( 3446 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3447 } 3448 3449 @Test testHandoverDataNetworkNonVops()3450 public void testHandoverDataNetworkNonVops() throws Exception { 3451 ServiceState ss = new ServiceState(); 3452 3453 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3454 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 3455 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)); 3456 3457 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3458 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3459 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3460 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3461 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3462 .setDataSpecificInfo(dsri) 3463 .build()); 3464 3465 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3466 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 3467 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN) 3468 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3469 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3470 .build()); 3471 3472 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3473 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3474 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3475 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3476 .setDomain(NetworkRegistrationInfo.DOMAIN_CS) 3477 .build()); 3478 processServiceStateRegStateForTest(ss); 3479 doReturn(ss).when(mSST).getServiceState(); 3480 doReturn(ss).when(mPhone).getServiceState(); 3481 3482 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 3483 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3484 3485 mDataNetworkControllerUT.obtainMessage(17/*EVENT_SERVICE_STATE_CHANGED*/).sendToTarget(); 3486 processAllMessages(); 3487 3488 mDataNetworkControllerUT.addNetworkRequest( 3489 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 3490 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 3491 processAllMessages(); 3492 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3493 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3494 3495 // Change the preference to cellular 3496 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3497 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3498 3499 // Verify that handover is not performed. 3500 verify(mMockedWwanDataServiceManager, never()).setupDataCall(anyInt(), 3501 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3502 any(), any(), anyBoolean(), any(Message.class)); 3503 3504 // IMS network should be torn down. 3505 verifyAllDataDisconnected(); 3506 } 3507 3508 @Test testHandoverDataNetworkNonVopsAllowLingeringVoPS()3509 public void testHandoverDataNetworkNonVopsAllowLingeringVoPS() throws Exception { 3510 // Allow lingering IMS PDN when enter area VoPS -> no VoPS 3511 mCarrierConfig.putBoolean(CarrierConfigManager.Ims.KEY_KEEP_PDN_UP_IN_NO_VOPS_BOOL, true); 3512 carrierConfigChanged(); 3513 3514 ServiceState ss = new ServiceState(); 3515 3516 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3517 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 3518 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)); 3519 3520 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3521 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3522 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3523 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3524 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3525 .setDataSpecificInfo(dsri) 3526 .build()); 3527 3528 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3529 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 3530 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN) 3531 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3532 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3533 .build()); 3534 3535 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3536 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3537 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3538 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3539 .setDomain(NetworkRegistrationInfo.DOMAIN_CS) 3540 .build()); 3541 processServiceStateRegStateForTest(ss); 3542 doReturn(ss).when(mSST).getServiceState(); 3543 doReturn(ss).when(mPhone).getServiceState(); 3544 3545 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 3546 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3547 3548 mDataNetworkControllerUT.obtainMessage(17/*EVENT_SERVICE_STATE_CHANGED*/).sendToTarget(); 3549 processAllMessages(); 3550 3551 mDataNetworkControllerUT.addNetworkRequest( 3552 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 3553 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 3554 processAllMessages(); 3555 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3556 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3557 3558 // Change the preference to cellular 3559 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3560 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3561 3562 // Verify that handover is not performed. 3563 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), 3564 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3565 any(), any(), anyBoolean(), any(Message.class)); 3566 3567 // IMS network still alive. 3568 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3569 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3570 } 3571 3572 @Test testNonMmtelImsHandoverDataNetworkNonVops()3573 public void testNonMmtelImsHandoverDataNetworkNonVops() throws Exception { 3574 ServiceState ss = new ServiceState(); 3575 3576 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3577 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 3578 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)); 3579 3580 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3581 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3582 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3583 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3584 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3585 .setDataSpecificInfo(dsri) 3586 .build()); 3587 3588 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3589 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 3590 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN) 3591 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3592 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3593 .build()); 3594 3595 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3596 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3597 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3598 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3599 .setDomain(NetworkRegistrationInfo.DOMAIN_CS) 3600 .build()); 3601 processServiceStateRegStateForTest(ss); 3602 doReturn(ss).when(mSST).getServiceState(); 3603 doReturn(ss).when(mPhone).getServiceState(); 3604 3605 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager) 3606 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3607 3608 mDataNetworkControllerUT.obtainMessage(17/*EVENT_SERVICE_STATE_CHANGED*/).sendToTarget(); 3609 processAllMessages(); 3610 3611 // Bring up the IMS network that does not require MMTEL 3612 mDataNetworkControllerUT.addNetworkRequest( 3613 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS)); 3614 processAllMessages(); 3615 3616 // Even though the network request does not have MMTEL, but the network support it, so 3617 // the network capabilities should still have MMTEL. 3618 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3619 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3620 3621 // Change the preference to cellular 3622 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3623 AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 3624 3625 // Verify that handover is performed 3626 verify(mMockedWwanDataServiceManager).setupDataCall(anyInt(), 3627 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3628 any(), any(), anyBoolean(), any(Message.class)); 3629 3630 // The IMS network should still have IMS and MMTEL. 3631 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS); 3632 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMTEL); 3633 } 3634 3635 @Test testMmtelImsDataNetworkMovingToNonVops()3636 public void testMmtelImsDataNetworkMovingToNonVops() throws Exception { 3637 // Allow lingering IMS PDN when enter area VoPS -> no VoPS 3638 mCarrierConfig.putBoolean(CarrierConfigManager.Ims.KEY_KEEP_PDN_UP_IN_NO_VOPS_BOOL, true); 3639 carrierConfigChanged(); 3640 3641 ServiceState ss = new ServiceState(); 3642 3643 // VoPS network 3644 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3645 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 3646 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)); 3647 3648 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3649 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3650 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3651 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3652 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3653 .setDataSpecificInfo(dsri) 3654 .build()); 3655 3656 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3657 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 3658 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN) 3659 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3660 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3661 .build()); 3662 3663 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3664 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3665 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3666 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3667 .setDomain(NetworkRegistrationInfo.DOMAIN_CS) 3668 .build()); 3669 processServiceStateRegStateForTest(ss); 3670 doReturn(ss).when(mSST).getServiceState(); 3671 doReturn(ss).when(mPhone).getServiceState(); 3672 3673 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager) 3674 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3675 3676 mDataNetworkControllerUT.obtainMessage(17/*EVENT_SERVICE_STATE_CHANGED*/).sendToTarget(); 3677 processAllMessages(); 3678 3679 // Bring up the IMS network that does require MMTEL 3680 mDataNetworkControllerUT.addNetworkRequest( 3681 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 3682 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 3683 processAllMessages(); 3684 3685 // the network capabilities should have IMS and MMTEL. 3686 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3687 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3688 3689 ss = new ServiceState(); 3690 // Non VoPS network 3691 dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3692 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 3693 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)); 3694 3695 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3696 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3697 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3698 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3699 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3700 .setDataSpecificInfo(dsri) 3701 .build()); 3702 3703 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3704 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN) 3705 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN) 3706 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3707 .setDomain(NetworkRegistrationInfo.DOMAIN_PS) 3708 .build()); 3709 3710 ss.addNetworkRegistrationInfo(new NetworkRegistrationInfo.Builder() 3711 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WWAN) 3712 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 3713 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 3714 .setDomain(NetworkRegistrationInfo.DOMAIN_CS) 3715 .build()); 3716 processServiceStateRegStateForTest(ss); 3717 doReturn(ss).when(mSST).getServiceState(); 3718 doReturn(ss).when(mPhone).getServiceState(); 3719 3720 mDataNetworkControllerUT.obtainMessage(17/*EVENT_SERVICE_STATE_CHANGED*/).sendToTarget(); 3721 processAllMessages(); 3722 3723 // The IMS network is alive due to KEY_KEEP_PDN_UP_IN_NO_VOPS_BOOL = true 3724 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3725 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3726 3727 mCarrierConfig.putBoolean(CarrierConfigManager.Ims.KEY_KEEP_PDN_UP_IN_NO_VOPS_BOOL, false); 3728 carrierConfigChanged(); 3729 mDataNetworkControllerUT.obtainMessage(16/*EVENT_REEVALUATE_EXISTING_DATA_NETWORKS*/) 3730 .sendToTarget(); 3731 processAllMessages(); 3732 3733 // The IMS network should be torn down by data network controller. 3734 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3735 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL); 3736 } 3737 3738 @Test testVoPStoNonVoPSDelayImsTearDown()3739 public void testVoPStoNonVoPSDelayImsTearDown() throws Exception { 3740 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_DELAY_IMS_TEAR_DOWN_UNTIL_CALL_END_BOOL, 3741 true); 3742 carrierConfigChanged(); 3743 3744 // VoPS supported 3745 DataSpecificRegistrationInfo dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3746 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_SUPPORTED, 3747 LteVopsSupportInfo.LTE_STATUS_SUPPORTED)); 3748 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 3749 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 3750 3751 mDataNetworkControllerUT.addNetworkRequest( 3752 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 3753 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 3754 processAllMessages(); 3755 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS); 3756 3757 doReturn(PhoneConstants.State.OFFHOOK).when(mCT).getState(); 3758 3759 dsri = new DataSpecificRegistrationInfo(8, false, true, true, 3760 new LteVopsSupportInfo(LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED, 3761 LteVopsSupportInfo.LTE_STATUS_NOT_SUPPORTED)); 3762 serviceStateChanged(TelephonyManager.NETWORK_TYPE_LTE, 3763 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, dsri); 3764 3765 // Make sure IMS is still connected. 3766 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3767 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3768 3769 // Call ends 3770 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 3771 mDataNetworkControllerUT.obtainMessage(18/*EVENT_VOICE_CALL_ENDED*/).sendToTarget(); 3772 processAllMessages(); 3773 3774 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3775 } 3776 3777 @Test testDeactivateDataOnOldHal()3778 public void testDeactivateDataOnOldHal() throws Exception { 3779 doAnswer(invocation -> { 3780 // Only send the deactivation data response, no data call list changed event. 3781 Message msg = (Message) invocation.getArguments()[2]; 3782 msg.sendToTarget(); 3783 return null; 3784 }).when(mMockedWwanDataServiceManager).deactivateDataCall( 3785 anyInt(), anyInt(), any(Message.class)); 3786 // Simulate old devices 3787 doReturn(RIL.RADIO_HAL_VERSION_1_6).when(mPhone).getHalVersion(); 3788 3789 testSetupDataNetwork(); 3790 3791 mDataNetworkControllerUT.obtainMessage(9/*EVENT_SIM_STATE_CHANGED*/, 3792 TelephonyManager.SIM_STATE_ABSENT, 0).sendToTarget(); 3793 processAllMessages(); 3794 verifyAllDataDisconnected(); 3795 verify(mMockedDataNetworkControllerCallback).onAnyDataNetworkExistingChanged(eq(false)); 3796 verify(mMockedDataNetworkControllerCallback).onInternetDataNetworkDisconnected(); 3797 } 3798 3799 @Test testHandoverWhileSetupDataCallInProgress()3800 public void testHandoverWhileSetupDataCallInProgress() throws Exception { 3801 // Long delay setup failure 3802 setFailedSetupDataResponse(mMockedWwanDataServiceManager, DataFailCause.CONGESTION, 3803 DataCallResponse.RETRY_DURATION_UNDEFINED, false, 10000); 3804 3805 mDataNetworkControllerUT.addNetworkRequest( 3806 createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS, 3807 NetworkCapabilities.NET_CAPABILITY_MMTEL)); 3808 processAllMessages(); 3809 3810 // Change the preference to IWLAN while setup data is still ongoing. 3811 updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS, 3812 AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 3813 3814 // Data should not be connected. 3815 verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS); 3816 3817 // There shouldn't be any attempt to bring up IMS on IWLAN even though the preference 3818 // has already changed, because the previous setup is still ongoing. 3819 verify(mMockedWlanDataServiceManager, never()).setupDataCall(eq(AccessNetworkType.IWLAN), 3820 any(DataProfile.class), anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), 3821 any(), any(), anyBoolean(), any(Message.class)); 3822 3823 processAllFutureMessages(); 3824 3825 // Should setup a new one instead of handover. 3826 verify(mMockedWlanDataServiceManager).setupDataCall(eq(AccessNetworkType.IWLAN), 3827 any(DataProfile.class), anyBoolean(), anyBoolean(), 3828 eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(), 3829 any(Message.class)); 3830 3831 // IMS should be connected. 3832 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS, 3833 NetworkCapabilities.NET_CAPABILITY_MMTEL); 3834 } 3835 3836 @Test testRemoveNetworkRequest()3837 public void testRemoveNetworkRequest() throws Exception { 3838 NetworkCapabilities netCaps = new NetworkCapabilities(); 3839 netCaps.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); 3840 3841 NetworkRequest nativeNetworkRequest = new NetworkRequest(netCaps, 3842 ConnectivityManager.TYPE_MOBILE, 0, NetworkRequest.Type.REQUEST); 3843 3844 mDataNetworkControllerUT.addNetworkRequest(new TelephonyNetworkRequest( 3845 nativeNetworkRequest, mPhone)); 3846 processAllMessages(); 3847 3848 // Intentionally create a new telephony request with the original native network request. 3849 TelephonyNetworkRequest request = new TelephonyNetworkRequest(nativeNetworkRequest, mPhone); 3850 3851 mDataNetworkControllerUT.removeNetworkRequest(request); 3852 processAllFutureMessages(); 3853 3854 List<DataNetwork> dataNetworkList = getDataNetworks(); 3855 // The data network should not be torn down after network request removal. 3856 assertThat(dataNetworkList).hasSize(1); 3857 // But should be detached from the data network. 3858 assertThat(dataNetworkList.get(0).getAttachedNetworkRequestList()).isEmpty(); 3859 assertThat(dataNetworkList.get(0).isConnected()).isTrue(); 3860 } 3861 3862 @Test testTempDdsSwitchTearDown()3863 public void testTempDdsSwitchTearDown() throws Exception { 3864 TelephonyNetworkRequest request = createNetworkRequest( 3865 NetworkCapabilities.NET_CAPABILITY_INTERNET); 3866 mDataNetworkControllerUT.addNetworkRequest(request); 3867 processAllMessages(); 3868 3869 // Now DDS temporarily switched to phone 1 3870 doReturn(1).when(mMockedPhoneSwitcher).getPreferredDataPhoneId(); 3871 3872 // Simulate telephony network factory remove request due to switch. 3873 mDataNetworkControllerUT.removeNetworkRequest(request); 3874 processAllMessages(); 3875 3876 // Data should be torn down on this non-preferred sub. 3877 verifyAllDataDisconnected(); 3878 } 3879 3880 @Test testSetupDataOnNonDds()3881 public void testSetupDataOnNonDds() throws Exception { 3882 // Now DDS switched to phone 1 3883 doReturn(1).when(mMockedPhoneSwitcher).getPreferredDataPhoneId(); 3884 TelephonyNetworkRequest request = createNetworkRequest( 3885 NetworkCapabilities.NET_CAPABILITY_MMS); 3886 3887 // Test Don't allow setup if both data and voice OOS 3888 serviceStateChanged(TelephonyProtoEnums.NETWORK_TYPE_1XRTT, 3889 // data, voice, Iwlan reg state 3890 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, 3891 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, 3892 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, null); 3893 mDataNetworkControllerUT.addNetworkRequest(request); 3894 processAllMessages(); 3895 3896 verifyAllDataDisconnected(); 3897 3898 // Test Don't allow setup if CS is in service, but current RAT is already PS(e.g. LTE) 3899 serviceStateChanged(TelephonyProtoEnums.NETWORK_TYPE_LTE, 3900 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, 3901 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, 3902 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, null); 3903 3904 verifyAllDataDisconnected(); 3905 3906 // Test Allow if voice is in service if RAT is 2g/3g 3907 serviceStateChanged(TelephonyProtoEnums.NETWORK_TYPE_1XRTT, 3908 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, 3909 NetworkRegistrationInfo.REGISTRATION_STATE_HOME, 3910 NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_OR_SEARCHING, null); 3911 3912 verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_MMS); 3913 } 3914 } 3915