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