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.phone; 18 19 import static android.telephony.ims.ImsRcsManager.CAPABILITY_TYPE_PRESENCE_UCE; 20 import static android.telephony.ims.ProvisioningManager.KEY_EAB_PROVISIONING_STATUS; 21 import static android.telephony.ims.ProvisioningManager.KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE; 22 import static android.telephony.ims.ProvisioningManager.KEY_VOLTE_PROVISIONING_STATUS; 23 import static android.telephony.ims.ProvisioningManager.KEY_VT_PROVISIONING_STATUS; 24 import static android.telephony.ims.ProvisioningManager.PROVISIONING_VALUE_DISABLED; 25 import static android.telephony.ims.ProvisioningManager.PROVISIONING_VALUE_ENABLED; 26 import static android.telephony.ims.feature.ImsFeature.FEATURE_MMTEL; 27 import static android.telephony.ims.feature.ImsFeature.FEATURE_RCS; 28 import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_CALL_COMPOSER; 29 import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_SMS; 30 import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT; 31 import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO; 32 import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE; 33 import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_CROSS_SIM; 34 import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN; 35 import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_LTE; 36 import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_NR; 37 38 import static org.junit.Assert.assertEquals; 39 import static org.mockito.ArgumentMatchers.any; 40 import static org.mockito.ArgumentMatchers.anyBoolean; 41 import static org.mockito.ArgumentMatchers.anyInt; 42 import static org.mockito.ArgumentMatchers.eq; 43 import static org.mockito.Mockito.atLeast; 44 import static org.mockito.Mockito.atLeastOnce; 45 import static org.mockito.Mockito.clearInvocations; 46 import static org.mockito.Mockito.doAnswer; 47 import static org.mockito.Mockito.doNothing; 48 import static org.mockito.Mockito.times; 49 import static org.mockito.Mockito.verify; 50 import static org.mockito.Mockito.verifyNoMoreInteractions; 51 import static org.mockito.Mockito.when; 52 53 import android.content.Context; 54 import android.os.AsyncResult; 55 import android.os.Handler; 56 import android.os.HandlerThread; 57 import android.os.IBinder; 58 import android.os.Looper; 59 import android.os.PersistableBundle; 60 import android.telephony.CarrierConfigManager; 61 import android.telephony.SubscriptionManager; 62 import android.telephony.TelephonyRegistryManager; 63 import android.telephony.ims.ProvisioningManager; 64 import android.telephony.ims.aidl.IFeatureProvisioningCallback; 65 import android.telephony.ims.aidl.IImsConfig; 66 import android.telephony.ims.aidl.IImsConfigCallback; 67 import android.telephony.ims.feature.MmTelFeature.MmTelCapabilities; 68 import android.telephony.ims.feature.RcsFeature.RcsImsCapabilities; 69 import android.telephony.ims.stub.ImsConfigImplBase; 70 import android.telephony.ims.stub.ImsRegistrationImplBase; 71 import android.testing.TestableLooper; 72 import android.util.Log; 73 74 import androidx.test.filters.SmallTest; 75 76 import com.android.ims.FeatureConnector; 77 import com.android.ims.ImsConfig; 78 import com.android.ims.ImsManager; 79 import com.android.ims.RcsFeatureManager; 80 import com.android.internal.telephony.flags.FeatureFlags; 81 82 import org.junit.After; 83 import org.junit.Before; 84 import org.junit.Test; 85 import org.mockito.ArgumentCaptor; 86 import org.mockito.Captor; 87 import org.mockito.Mock; 88 import org.mockito.MockitoAnnotations; 89 import org.mockito.invocation.InvocationOnMock; 90 import org.mockito.stubbing.Answer; 91 92 /** 93 * Unit tests for ImsProvisioningContorller 94 */ 95 public class ImsProvisioningControllerTest { 96 private static final String TAG = "ImsProvisioningControllerTest"; 97 private static final int[] MMTEL_CAPAS = new int[]{ 98 CAPABILITY_TYPE_VOICE, 99 CAPABILITY_TYPE_VIDEO, 100 CAPABILITY_TYPE_UT, 101 CAPABILITY_TYPE_SMS, 102 CAPABILITY_TYPE_CALL_COMPOSER 103 }; 104 private static final int MMTEL_CAPA_INVALID = 0; 105 106 private static final int RCS_CAPA_INVALID = RcsImsCapabilities.CAPABILITY_TYPE_NONE; 107 108 private static final int[] RADIO_TECHS = new int[]{ 109 REGISTRATION_TECH_LTE, 110 REGISTRATION_TECH_IWLAN, 111 REGISTRATION_TECH_CROSS_SIM, 112 REGISTRATION_TECH_NR 113 }; 114 private static final int RADIO_TECH_INVALID = ImsRegistrationImplBase.REGISTRATION_TECH_NONE; 115 116 @Mock 117 Context mContext; 118 119 @Mock 120 PhoneGlobals mPhone; 121 @Mock 122 CarrierConfigManager mCarrierConfigManager; 123 private PersistableBundle mPersistableBundle0; 124 private PersistableBundle mPersistableBundle1; 125 @Mock 126 SubscriptionManager mSubscriptionManager; 127 @Mock 128 TelephonyRegistryManager mTelephonyRegistryManager; 129 @Mock 130 ImsProvisioningLoader mImsProvisioningLoader; 131 132 @Mock 133 ImsManager mImsManager; 134 @Mock 135 ImsConfig mImsConfig; 136 @Mock 137 ImsProvisioningController.MmTelFeatureConnector mMmTelFeatureConnector; 138 @Mock 139 FeatureConnector<ImsManager> mMmTelFeatureConnector0; 140 @Mock 141 FeatureConnector<ImsManager> mMmTelFeatureConnector1; 142 @Captor 143 ArgumentCaptor<FeatureConnector.Listener<ImsManager>> mMmTelConnectorListener0; 144 @Captor 145 ArgumentCaptor<FeatureConnector.Listener<ImsManager>> mMmTelConnectorListener1; 146 147 @Mock 148 RcsFeatureManager mRcsFeatureManager; 149 @Mock 150 ImsProvisioningController.RcsFeatureConnector mRcsFeatureConnector; 151 @Mock 152 FeatureConnector<RcsFeatureManager> mRcsFeatureConnector0; 153 @Mock 154 FeatureConnector<RcsFeatureManager> mRcsFeatureConnector1; 155 @Captor 156 ArgumentCaptor<FeatureConnector.Listener<RcsFeatureManager>> mRcsConnectorListener0; 157 @Captor 158 ArgumentCaptor<FeatureConnector.Listener<RcsFeatureManager>> mRcsConnectorListener1; 159 160 @Mock 161 IFeatureProvisioningCallback mIFeatureProvisioningCallback0; 162 @Mock 163 IFeatureProvisioningCallback mIFeatureProvisioningCallback1; 164 165 @Captor 166 ArgumentCaptor<IImsConfigCallback> mIImsConfigCallback; 167 168 @Mock 169 IBinder mIbinder0; 170 @Mock 171 IBinder mIbinder1; 172 173 @Mock 174 FeatureFlags mFeatureFlags; 175 176 private SubscriptionManager.OnSubscriptionsChangedListener mSubChangedListener; 177 178 private Handler mHandler; 179 private HandlerThread mHandlerThread; 180 private TestableLooper mLooper; 181 182 TestImsProvisioningController mTestImsProvisioningController; 183 184 int mPhoneId0 = 0; 185 int mPhoneId1 = 1; 186 int mSubId0 = 1234; 187 int mSubId1 = 5678; 188 189 int[][] mMmTelProvisioningStorage; 190 int[][] mRcsProvisioningStorage; 191 int[][] mImsConfigStorage; 192 193 private class TestImsProvisioningController extends ImsProvisioningController { 194 boolean mIsValidSubId = true; 195 TestImsProvisioningController()196 TestImsProvisioningController() { 197 super(mPhone, 2, mHandlerThread.getLooper(), 198 mMmTelFeatureConnector, mRcsFeatureConnector, 199 mImsProvisioningLoader, mFeatureFlags); 200 } 201 getSubId(int slotId)202 protected int getSubId(int slotId) { 203 return (slotId == mPhoneId0) ? mSubId0 : mSubId1; 204 } 205 getSlotId(int subId)206 protected int getSlotId(int subId) { 207 return (subId == mSubId0) ? mPhoneId0 : mPhoneId1; 208 } 209 getImsConfig(ImsManager imsManager)210 protected ImsConfig getImsConfig(ImsManager imsManager) { 211 return mImsConfig; 212 } 213 getImsConfig(IImsConfig iImsConfig)214 protected ImsConfig getImsConfig(IImsConfig iImsConfig) { 215 return mImsConfig; 216 } 217 isValidSubId(int subId)218 protected boolean isValidSubId(int subId) { 219 return mIsValidSubId; 220 } 221 setValidSubId(boolean valid)222 public void setValidSubId(boolean valid) { 223 mIsValidSubId = valid; 224 } 225 } 226 227 @Before setUp()228 public void setUp() throws Exception { 229 logd("setUp"); 230 MockitoAnnotations.initMocks(this); 231 232 when(mPhone.getSystemServiceName(eq(CarrierConfigManager.class))) 233 .thenReturn(Context.CARRIER_CONFIG_SERVICE); 234 when(mPhone.getSystemService(eq(Context.CARRIER_CONFIG_SERVICE))) 235 .thenReturn(mCarrierConfigManager); 236 237 mPersistableBundle0 = new PersistableBundle(); 238 mPersistableBundle1 = new PersistableBundle(); 239 240 when(mCarrierConfigManager.getConfigForSubId(eq(mSubId0))) 241 .thenReturn(mPersistableBundle0); 242 when(mCarrierConfigManager.getConfigForSubId(eq(mSubId1))) 243 .thenReturn(mPersistableBundle1); 244 245 when(mPhone.getSystemServiceName(eq(SubscriptionManager.class))) 246 .thenReturn(Context.TELEPHONY_SUBSCRIPTION_SERVICE); 247 when(mPhone.getSystemService(eq(Context.TELEPHONY_SUBSCRIPTION_SERVICE))) 248 .thenReturn(mSubscriptionManager); 249 250 251 when(mPhone.getSystemServiceName(eq(TelephonyRegistryManager.class))) 252 .thenReturn(Context.TELEPHONY_REGISTRY_SERVICE); 253 when(mPhone.getSystemService(eq(Context.TELEPHONY_REGISTRY_SERVICE))) 254 .thenReturn(mTelephonyRegistryManager); 255 doAnswer(new Answer<Void>() { 256 @Override 257 public Void answer(InvocationOnMock invocation) throws Throwable { 258 mSubChangedListener = (SubscriptionManager.OnSubscriptionsChangedListener) 259 invocation.getArguments()[0]; 260 return null; 261 } 262 }).when(mTelephonyRegistryManager).addOnSubscriptionsChangedListener( 263 any(SubscriptionManager.OnSubscriptionsChangedListener.class), 264 any()); 265 266 mHandlerThread = new HandlerThread("ImsStateCallbackControllerTest"); 267 mHandlerThread.start(); 268 269 initializeDefaultData(); 270 } 271 272 @After tearDown()273 public void tearDown() throws Exception { 274 logd("tearDown"); 275 if (mTestImsProvisioningController != null) { 276 mTestImsProvisioningController.destroy(); 277 mTestImsProvisioningController = null; 278 } 279 280 if (mLooper != null) { 281 mLooper.destroy(); 282 mLooper = null; 283 } 284 } 285 286 @Test 287 @SmallTest addFeatureProvisioningChangedCallback_withCallback()288 public void addFeatureProvisioningChangedCallback_withCallback() throws Exception { 289 createImsProvisioningController(); 290 291 // add callback with valid obj 292 try { 293 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 294 mSubId0, mIFeatureProvisioningCallback0); 295 } catch (Exception e) { 296 throw new AssertionError("not expected exception", e); 297 } 298 // add callback with invalid obj 299 try { 300 mTestImsProvisioningController.addFeatureProvisioningChangedCallback(mSubId0, null); 301 } catch (IllegalArgumentException e) { 302 // expected result 303 } catch (Exception e) { 304 throw new AssertionError("not expected exception", e); 305 } 306 // remove callback with valid obj 307 try { 308 mTestImsProvisioningController.removeFeatureProvisioningChangedCallback( 309 mSubId0, mIFeatureProvisioningCallback0); 310 } catch (Exception e) { 311 throw new AssertionError("not expected exception", e); 312 } 313 // remove callback with invalid obj 314 try { 315 mTestImsProvisioningController.removeFeatureProvisioningChangedCallback(mSubId0, null); 316 } catch (IllegalArgumentException e) { 317 // expected result 318 } catch (Exception e) { 319 throw new AssertionError("not expected exception", e); 320 } 321 } 322 323 @Test 324 @SmallTest connectionReady_MmTelFeatureListener()325 public void connectionReady_MmTelFeatureListener() throws Exception { 326 createImsProvisioningController(); 327 328 // provisioning required capability 329 // voice, all tech 330 // video, all tech 331 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 332 RADIO_TECHS); 333 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 334 RADIO_TECHS); 335 336 try { 337 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 338 mSubId0, mIFeatureProvisioningCallback0); 339 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 340 mSubId1, mIFeatureProvisioningCallback1); 341 } catch (Exception e) { 342 throw new AssertionError("not expected exception", e); 343 } 344 clearInvocations(mIFeatureProvisioningCallback0); 345 clearInvocations(mIFeatureProvisioningCallback1); 346 347 // change subId to be invalid 348 mTestImsProvisioningController.setValidSubId(false); 349 350 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 351 352 // setConfig not called, wait until subId is valid 353 verify(mImsConfig, times(0)).setConfig(anyInt(), anyInt()); 354 355 // change subId 356 mSubChangedListener.onSubscriptionsChanged(); 357 processAllMessages(); 358 359 verify(mImsConfig, times(1)).addConfigCallback((IImsConfigCallback) any()); 360 361 int[] keys = { 362 ProvisioningManager.KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE, 363 ProvisioningManager.KEY_VOLTE_PROVISIONING_STATUS, 364 ProvisioningManager.KEY_VT_PROVISIONING_STATUS}; 365 366 // verify # of read data times from storage : # of MmTel storage length 367 verify(mImsProvisioningLoader, atLeast(keys.length)) 368 .getProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), anyInt(), anyInt()); 369 370 for (int index = 0; index < keys.length; index++) { 371 // verify function call vendor interface 372 verify(mImsConfig, times(1)).setConfig(eq(keys[index]), anyInt()); 373 } 374 375 // verify other interactions 376 verifyNoMoreInteractions(mImsConfig); 377 } 378 379 @Test 380 @SmallTest connectionReady_RcsFeatureListener()381 public void connectionReady_RcsFeatureListener() throws Exception { 382 createImsProvisioningController(); 383 384 // provisioning required capability : PRESENCE, tech : all 385 setCarrierConfig(mSubId0, 386 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 387 388 try { 389 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 390 mSubId0, mIFeatureProvisioningCallback0); 391 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 392 mSubId1, mIFeatureProvisioningCallback1); 393 } catch (Exception e) { 394 throw new AssertionError("not expected exception", e); 395 } 396 clearInvocations(mIFeatureProvisioningCallback0); 397 clearInvocations(mIFeatureProvisioningCallback1); 398 399 mRcsConnectorListener0.getValue().connectionReady(mRcsFeatureManager, mSubId0); 400 processAllMessages(); 401 402 verify(mImsConfig, times(1)).addConfigCallback((IImsConfigCallback) any()); 403 404 // verify # of read data times from storage : # of Rcs storage length 405 verify(mImsProvisioningLoader, times(1)) 406 .getProvisioningStatus(eq(mSubId0), eq(FEATURE_RCS), anyInt(), anyInt()); 407 408 int key = ProvisioningManager.KEY_EAB_PROVISIONING_STATUS; 409 // verify function call vendor interface 410 verify(mImsConfig, times(1)).setConfig(eq(key), anyInt()); 411 412 // verify other interactions 413 verifyNoMoreInteractions(mImsConfig); 414 } 415 416 @Test 417 @SmallTest isImsProvisioningRequiredForCapability_withInvalidCapabilityTech()418 public void isImsProvisioningRequiredForCapability_withInvalidCapabilityTech() 419 throws Exception { 420 createImsProvisioningController(); 421 422 // invalid Capa. and valid Radio tech - IllegalArgumentException OK 423 try { 424 mTestImsProvisioningController.isImsProvisioningRequiredForCapability( 425 mSubId0, MMTEL_CAPA_INVALID, RADIO_TECHS[0]); 426 } catch (IllegalArgumentException e) { 427 // expected result 428 } catch (Exception e) { 429 throw new AssertionError("not expected exception", e); 430 } 431 432 // valid Capa. and invalid Radio tech - IllegalArumentException OK 433 try { 434 mTestImsProvisioningController.isImsProvisioningRequiredForCapability( 435 mSubId0, MMTEL_CAPAS[0], RADIO_TECH_INVALID); 436 } catch (IllegalArgumentException e) { 437 // expected result 438 } catch (Exception e) { 439 throw new AssertionError("not expected exception", e); 440 } 441 } 442 443 @Test 444 @SmallTest isImsProvisioningRequiredForCapability_withValidCapabilityTech()445 public void isImsProvisioningRequiredForCapability_withValidCapabilityTech() throws Exception { 446 createImsProvisioningController(); 447 448 // provisioning required capability 449 // voice, all tech 450 // video, all tech 451 // UT, all tech 452 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 453 RADIO_TECHS); 454 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 455 RADIO_TECHS); 456 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_UT_INT_ARRAY, 457 RADIO_TECHS); 458 459 // provisioning required for each capability 460 boolean[][] expectedRequired = new boolean[][] { 461 //voice - LTE, WLAN, CROSS-SIM, NR 462 {true, true, true, true}, 463 //video - LTE, WLAN, CROSS-SIM, NR 464 {true, true, true, true}, 465 //UT - LTE, WLAN, CROSS-SIM, NR 466 {true, true, true, true}, 467 //SMS not required 468 {false, false, false, false}, 469 //Call composer not required 470 {false, false, false, false} 471 }; 472 473 boolean isRequired; 474 for (int i = 0; i < MMTEL_CAPAS.length; i++) { 475 for (int j = 0; j < RADIO_TECHS.length; j++) { 476 isRequired = mTestImsProvisioningController 477 .isImsProvisioningRequiredForCapability( 478 mSubId0, MMTEL_CAPAS[i], RADIO_TECHS[j]); 479 assertEquals(expectedRequired[i][j], isRequired); 480 } 481 } 482 } 483 484 @Test 485 @SmallTest isImsProvisioningRequiredForCapability_withDeprecatedKey()486 public void isImsProvisioningRequiredForCapability_withDeprecatedKey() throws Exception { 487 createImsProvisioningController(); 488 489 // provisioning required capability 490 // KEY_MMTEL_REQUIRES_PROVISIONING_BUNDLE is not defined 491 // but KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL and 492 // KEY_CARRIER_SUPPORTS_SS_OVER_UT_BOOL are defined 493 setDeprecatedCarrierConfig( 494 CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL, true); 495 setDeprecatedCarrierConfig( 496 CarrierConfigManager.KEY_CARRIER_UT_PROVISIONING_REQUIRED_BOOL, true); 497 498 // provisioning required for each capability 499 boolean[][] expectedRequired = new boolean[][] { 500 //voice - LTE, WLAN, CROSS-SIM, NR 501 {true, true, true, true}, 502 //video - LTE, WLAN, CROSS-SIM, NR 503 {true, true, true, true}, 504 //UT - LTE, WLAN, CROSS-SIM, NR 505 {true, true, true, true}, 506 //SMS not required 507 {false, false, false, false}, 508 //Call composer not required 509 {false, false, false, false} 510 }; 511 512 boolean isRequired; 513 for (int i = 0; i < MMTEL_CAPAS.length; i++) { 514 for (int j = 0; j < RADIO_TECHS.length; j++) { 515 isRequired = mTestImsProvisioningController 516 .isImsProvisioningRequiredForCapability( 517 mSubId0, MMTEL_CAPAS[i], RADIO_TECHS[j]); 518 assertEquals(expectedRequired[i][j], isRequired); 519 } 520 } 521 } 522 523 @Test 524 @SmallTest isRcsProvisioningRequiredForCapability_withInvalidCapabilityTech()525 public void isRcsProvisioningRequiredForCapability_withInvalidCapabilityTech() 526 throws Exception { 527 createImsProvisioningController(); 528 529 // invalid Capa. and valid Radio tech - IllegalArgumentException OK 530 try { 531 mTestImsProvisioningController.isRcsProvisioningRequiredForCapability( 532 mSubId0, RCS_CAPA_INVALID, RADIO_TECHS[0]); 533 } catch (IllegalArgumentException e) { 534 // expected result 535 } catch (Exception e) { 536 throw new AssertionError("not expected exception", e); 537 } 538 539 // valid Capa. and invalid Radio tech - IllegalArumentException OK 540 try { 541 mTestImsProvisioningController.isRcsProvisioningRequiredForCapability( 542 mSubId0, CAPABILITY_TYPE_PRESENCE_UCE, RADIO_TECH_INVALID); 543 } catch (IllegalArgumentException e) { 544 // expected result 545 } catch (Exception e) { 546 throw new AssertionError("not expected exception", e); 547 } 548 } 549 550 @Test 551 @SmallTest isRcsProvisioningRequiredForCapability_withValidCapabilityTech()552 public void isRcsProvisioningRequiredForCapability_withValidCapabilityTech() throws Exception { 553 createImsProvisioningController(); 554 555 // provisioning required capability : PRESENCE, tech : all 556 setCarrierConfig(mSubId0, 557 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 558 559 // PRESENCE provisioning required on 560 boolean[] expectedRequired = new boolean[] 561 //LTE, WLAN, CROSS-SIM, NR 562 {true, true, true, true}; 563 564 boolean isRequired; 565 for (int i = 0; i < RADIO_TECHS.length; i++) { 566 isRequired = mTestImsProvisioningController 567 .isRcsProvisioningRequiredForCapability( 568 mSubId0, CAPABILITY_TYPE_PRESENCE_UCE, RADIO_TECHS[i]); 569 assertEquals(expectedRequired[i], isRequired); 570 } 571 } 572 573 @Test 574 @SmallTest isRcsProvisioningRequiredForCapability_withDeprecatedKey()575 public void isRcsProvisioningRequiredForCapability_withDeprecatedKey() throws Exception { 576 createImsProvisioningController(); 577 578 // provisioning required capability 579 // KEY_MMTEL_REQUIRES_PROVISIONING_BUNDLE is not defined 580 // but KEY_CARRIER_RCS_PROVISIONING_REQUIRED_BOOL is defined 581 setDeprecatedCarrierConfig( 582 CarrierConfigManager.KEY_CARRIER_RCS_PROVISIONING_REQUIRED_BOOL, true); 583 584 // PRESENCE provisioning required on 585 boolean[] expectedRequired = new boolean[] 586 //LTE, WLAN, CROSS-SIM, NR 587 {true, true, true, true}; 588 589 boolean isRequired; 590 for (int i = 0; i < RADIO_TECHS.length; i++) { 591 isRequired = mTestImsProvisioningController 592 .isRcsProvisioningRequiredForCapability( 593 mSubId0, CAPABILITY_TYPE_PRESENCE_UCE, RADIO_TECHS[i]); 594 assertEquals(expectedRequired[i], isRequired); 595 } 596 } 597 598 @Test 599 @SmallTest getImsProvisioningRequiredForCapability_withVoiceVideoUt()600 public void getImsProvisioningRequiredForCapability_withVoiceVideoUt() throws Exception { 601 createImsProvisioningController(); 602 603 // provisioning required capability 604 // voice, all tech 605 // video, all tech 606 // UT, all tech 607 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 608 RADIO_TECHS); 609 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 610 RADIO_TECHS); 611 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_UT_INT_ARRAY, 612 RADIO_TECHS); 613 614 // provisioning Status 615 mMmTelProvisioningStorage = new int[][] { 616 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE, 0}, 617 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN, 1}, 618 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_CROSS_SIM, 1}, 619 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_NR, 1}, 620 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE, 0}, 621 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_IWLAN, 0}, 622 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_CROSS_SIM, 1}, 623 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_NR, 1}, 624 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_LTE, 0}, 625 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_IWLAN, 0}, 626 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_CROSS_SIM, 0}, 627 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_NR, 0}, 628 }; 629 630 boolean[] expectedVoiceProvisioningStatus = new boolean[] {false, true, true, true}; 631 boolean[] expectedVideoProvisioningStatus = new boolean[] {false, false, true, true}; 632 boolean[] expectedUtProvisioningStatus = new boolean[] {false, false, false, false}; 633 634 boolean provisioned = false; 635 int capability = CAPABILITY_TYPE_VOICE; 636 for (int i = 0; i < RADIO_TECHS.length; i++) { 637 // get provisioning status 638 provisioned = mTestImsProvisioningController 639 .getImsProvisioningStatusForCapability(mSubId0, capability, RADIO_TECHS[i]); 640 641 // verify return value 642 assertEquals(expectedVoiceProvisioningStatus[i], provisioned); 643 644 // verify whether ImsProvisioningLoader is called or not 645 verify(mImsProvisioningLoader, times(1)) 646 .getProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), 647 eq(RADIO_TECHS[i])); 648 } 649 650 capability = CAPABILITY_TYPE_VIDEO; 651 for (int i = 0; i < RADIO_TECHS.length; i++) { 652 // get provisioning status 653 provisioned = mTestImsProvisioningController 654 .getImsProvisioningStatusForCapability(mSubId0, capability, RADIO_TECHS[i]); 655 656 // verify return value 657 assertEquals(expectedVideoProvisioningStatus[i], provisioned); 658 659 // verify whether ImsProvisioningLoader is called or not 660 verify(mImsProvisioningLoader, times(1)) 661 .getProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), 662 eq(RADIO_TECHS[i])); 663 } 664 665 capability = CAPABILITY_TYPE_UT; 666 for (int i = 0; i < RADIO_TECHS.length; i++) { 667 // get provisioning status 668 provisioned = mTestImsProvisioningController 669 .getImsProvisioningStatusForCapability(mSubId0, capability, RADIO_TECHS[i]); 670 671 // verify return value 672 assertEquals(expectedUtProvisioningStatus[i], provisioned); 673 674 // verify whether ImsProvisioningLoader is called or not 675 verify(mImsProvisioningLoader, times(1)) 676 .getProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), 677 eq(RADIO_TECHS[i])); 678 } 679 680 verifyNoMoreInteractions(mImsProvisioningLoader); 681 } 682 683 @Test 684 @SmallTest getImsProvisioningRequiredForCapability_withNotSet()685 public void getImsProvisioningRequiredForCapability_withNotSet() throws Exception { 686 createImsProvisioningController(); 687 688 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 689 processAllMessages(); 690 691 clearInvocations(mImsConfig); 692 clearInvocations(mImsProvisioningLoader); 693 694 // provisioning required capability 695 // voice, LTE, IWLAN 696 // video, LTE 697 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 698 REGISTRATION_TECH_LTE, REGISTRATION_TECH_IWLAN); 699 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 700 REGISTRATION_TECH_LTE); 701 702 // provisioning StatusP, all of provisioning status is not provisioned 703 mMmTelProvisioningStorage = new int[][]{ 704 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE, -1}, 705 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN, -1}, 706 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE, -1} 707 }; 708 // provisioning status in vendor ImsService 709 mImsConfigStorage = new int[][] { 710 {KEY_VOLTE_PROVISIONING_STATUS, 1}, 711 {KEY_VT_PROVISIONING_STATUS, 0}, 712 {KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE, 1}, 713 }; 714 715 boolean provisioned; 716 717 // for KEY_VOLTE_PROVISIONING_STATUS 718 int capability = CAPABILITY_TYPE_VOICE; 719 int tech = REGISTRATION_TECH_LTE; 720 provisioned = mTestImsProvisioningController 721 .getImsProvisioningStatusForCapability(mSubId0, capability, tech); 722 723 // verify return value default false - not provisioned 724 assertEquals(true, provisioned); 725 726 verify(mImsProvisioningLoader, times(1)) 727 .getProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), eq(tech)); 728 729 // verify whether ImsProvisioningLoader is called or not 730 verify(mImsConfig, times(1)).getConfigInt(eq(KEY_VOLTE_PROVISIONING_STATUS)); 731 732 // verify whether ImsProvisioningLoader is called or not 733 verify(mImsProvisioningLoader, times(1)) 734 .setProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), eq(tech), 735 eq(provisioned)); 736 737 clearInvocations(mImsConfig); 738 clearInvocations(mImsProvisioningLoader); 739 740 // for KEY_VT_PROVISIONING_STATUS 741 capability = CAPABILITY_TYPE_VIDEO; 742 tech = REGISTRATION_TECH_LTE; 743 provisioned = mTestImsProvisioningController 744 .getImsProvisioningStatusForCapability(mSubId0, capability, tech); 745 746 // verify return value default false - not provisioned 747 assertEquals(false, provisioned); 748 749 verify(mImsProvisioningLoader, times(1)) 750 .getProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), eq(tech)); 751 752 // verify whether ImsProvisioningLoader is called or not 753 verify(mImsConfig, times(1)).getConfigInt(eq(KEY_VT_PROVISIONING_STATUS)); 754 755 // verify whether ImsProvisioningLoader is called or not 756 verify(mImsProvisioningLoader, times(1)) 757 .setProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), eq(tech), 758 eq(provisioned)); 759 760 verifyNoMoreInteractions(mImsConfig); 761 verifyNoMoreInteractions(mImsProvisioningLoader); 762 } 763 764 @Test 765 @SmallTest getRcsProvisioningRequiredForCapability_withPresence()766 public void getRcsProvisioningRequiredForCapability_withPresence() throws Exception { 767 createImsProvisioningController(); 768 769 // provisioning required capability 770 // PRESENCE, all tech 771 setCarrierConfig(mSubId0, 772 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 773 774 // provisioning Status 775 mRcsProvisioningStorage = new int[][] { 776 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, 1}, 777 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, 1}, 778 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, 1}, 779 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, 1} 780 }; 781 782 boolean[] expectedPresenceProvisioningStatus = new boolean[] {true, true, true, true}; 783 784 boolean provisioned = false; 785 int capability = CAPABILITY_TYPE_PRESENCE_UCE; 786 for (int i = 0; i < RADIO_TECHS.length; i++) { 787 // get provisioning status 788 provisioned = mTestImsProvisioningController 789 .getRcsProvisioningStatusForCapability(mSubId0, capability, RADIO_TECHS[i]); 790 791 // verify return value 792 assertEquals(expectedPresenceProvisioningStatus[i], provisioned); 793 794 // verify whether ImsProvisioningLoader is called or not 795 verify(mImsProvisioningLoader, times(1)).getProvisioningStatus( 796 eq(mSubId0), eq(FEATURE_RCS), eq(capability), eq(RADIO_TECHS[i])); 797 } 798 799 verifyNoMoreInteractions(mImsProvisioningLoader); 800 } 801 802 @Test 803 @SmallTest getRcsProvisioningRequiredForCapability_withNotSet()804 public void getRcsProvisioningRequiredForCapability_withNotSet() throws Exception { 805 createImsProvisioningController(); 806 807 mRcsConnectorListener0.getValue().connectionReady(mRcsFeatureManager, mSubId0); 808 processAllMessages(); 809 810 clearInvocations(mImsConfig); 811 clearInvocations(mImsProvisioningLoader); 812 813 // provisioning required capability 814 // PRESENCE, LTE, IWLAN 815 setCarrierConfig(mSubId0, 816 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, 817 REGISTRATION_TECH_LTE, REGISTRATION_TECH_IWLAN); 818 819 // provisioning Status, all of provisioning status is not provisioned 820 mRcsProvisioningStorage = new int[][]{ 821 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, -1}, 822 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, -1}, 823 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, -1}, 824 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, -1} 825 }; 826 // provisioning status in vendor ImsService 827 mImsConfigStorage = new int[][] { 828 {KEY_EAB_PROVISIONING_STATUS, 1} 829 }; 830 831 boolean provisioned; 832 833 // for KEY_EAB_PROVISIONING_STATUS 834 int capability = CAPABILITY_TYPE_PRESENCE_UCE; 835 int tech = REGISTRATION_TECH_LTE; 836 provisioned = mTestImsProvisioningController 837 .getRcsProvisioningStatusForCapability(mSubId0, capability, tech); 838 839 // verify return value default false - not provisioned 840 assertEquals(true, provisioned); 841 842 verify(mImsProvisioningLoader, times(1)).getProvisioningStatus( 843 eq(mSubId0), eq(FEATURE_RCS), eq(capability), eq(tech)); 844 845 // verify whether ImsProvisioningLoader is called or not 846 verify(mImsConfig, times(1)).getConfigInt(eq(KEY_EAB_PROVISIONING_STATUS)); 847 848 // verify whether ImsProvisioningLoader is called or not 849 verify(mImsProvisioningLoader, times(RADIO_TECHS.length)).setProvisioningStatus( 850 eq(mSubId0), eq(FEATURE_RCS), eq(capability), anyInt(), eq(provisioned)); 851 852 verifyNoMoreInteractions(mImsConfig); 853 verifyNoMoreInteractions(mImsProvisioningLoader); 854 } 855 856 @Test 857 @SmallTest setImsProvisioningRequiredForCapability_withVoice()858 public void setImsProvisioningRequiredForCapability_withVoice() throws Exception { 859 createImsProvisioningController(); 860 861 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 862 processAllMessages(); 863 864 // register callbacks 865 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 866 mSubId0, mIFeatureProvisioningCallback0); 867 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 868 mSubId1, mIFeatureProvisioningCallback1); 869 870 clearInvocations(mIFeatureProvisioningCallback0); 871 clearInvocations(mIFeatureProvisioningCallback1); 872 clearInvocations(mImsConfig); 873 clearInvocations(mImsProvisioningLoader); 874 875 // provisioning required capability 876 // voice, all tech 877 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 878 RADIO_TECHS); 879 880 // provisioning Status, all of provisioning status is not provisioned 881 mMmTelProvisioningStorage = new int[][] { 882 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE, 0}, 883 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN, 0}, 884 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_CROSS_SIM, 0}, 885 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_NR, 0} 886 }; 887 888 boolean provisionedFirst = false; 889 boolean provisionedSecond = false; 890 int capability = CAPABILITY_TYPE_VOICE; 891 for (int i = 0; i < RADIO_TECHS.length; i++) { 892 // get provisioning status 893 provisionedFirst = mTestImsProvisioningController 894 .getImsProvisioningStatusForCapability(mSubId0, capability, RADIO_TECHS[i]); 895 896 // verify return value default false - not provisioned 897 assertEquals(false, provisionedFirst); 898 899 mTestImsProvisioningController.setImsProvisioningStatusForCapability( 900 mSubId0, capability, RADIO_TECHS[i], !provisionedFirst); 901 processAllMessages(); 902 903 provisionedSecond = mTestImsProvisioningController 904 .getImsProvisioningStatusForCapability(mSubId0, capability, RADIO_TECHS[i]); 905 906 // verify return value default false - provisioned 907 assertEquals(!provisionedFirst, provisionedSecond); 908 909 // verify whether ImsProvisioningLoader is called or not 910 verify(mImsProvisioningLoader, times(2)) 911 .getProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), 912 eq(RADIO_TECHS[i])); 913 verify(mImsProvisioningLoader, times(1)) 914 .setProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), 915 eq(RADIO_TECHS[i]), eq(provisionedSecond)); 916 917 // verify whether Callback is called or not 918 verify(mIFeatureProvisioningCallback0, times(1)) 919 .onFeatureProvisioningChanged(eq(capability), eq(RADIO_TECHS[i]), 920 eq(provisionedSecond)); 921 } 922 923 // verify whether ImsConfig is called or not 924 verify(mImsConfig, times(1)).setConfig( 925 eq(KEY_VOLTE_PROVISIONING_STATUS), eq(PROVISIONING_VALUE_ENABLED)); 926 verify(mImsConfig, times(1)).setConfig( 927 eq(KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE), eq(PROVISIONING_VALUE_ENABLED)); 928 929 verifyNoMoreInteractions(mImsConfig); 930 verifyNoMoreInteractions(mImsProvisioningLoader); 931 } 932 933 @Test 934 @SmallTest setImsProvisioningRequiredForCapability_withVideo()935 public void setImsProvisioningRequiredForCapability_withVideo() throws Exception { 936 createImsProvisioningController(); 937 938 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 939 processAllMessages(); 940 941 // register callbacks 942 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 943 mSubId0, mIFeatureProvisioningCallback0); 944 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 945 mSubId1, mIFeatureProvisioningCallback1); 946 947 clearInvocations(mIFeatureProvisioningCallback0); 948 clearInvocations(mIFeatureProvisioningCallback1); 949 clearInvocations(mImsConfig); 950 clearInvocations(mImsProvisioningLoader); 951 952 // provisioning required capability 953 // video, all tech 954 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 955 RADIO_TECHS); 956 957 // provisioning Status, all of provisioning status is not provisioned 958 mMmTelProvisioningStorage = new int[][] { 959 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE, 0}, 960 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_IWLAN, 0}, 961 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_CROSS_SIM, 0}, 962 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_NR, 0} 963 }; 964 965 boolean provisionedFirst = false; 966 boolean provisionedSecond = false; 967 int capability = CAPABILITY_TYPE_VIDEO; 968 for (int i = 0; i < RADIO_TECHS.length; i++) { 969 // get provisioning status 970 provisionedFirst = mTestImsProvisioningController 971 .getImsProvisioningStatusForCapability(mSubId0, capability, RADIO_TECHS[i]); 972 973 // verify return value default false - not provisioned 974 assertEquals(false, provisionedFirst); 975 976 mTestImsProvisioningController.setImsProvisioningStatusForCapability( 977 mSubId0, capability, RADIO_TECHS[i], !provisionedFirst); 978 processAllMessages(); 979 980 provisionedSecond = mTestImsProvisioningController 981 .getImsProvisioningStatusForCapability(mSubId0, capability, RADIO_TECHS[i]); 982 983 // verify return value default false - provisioned 984 assertEquals(!provisionedFirst, provisionedSecond); 985 986 // verify whether ImsProvisioningLoader is called or not 987 verify(mImsProvisioningLoader, times(2)) 988 .getProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), 989 eq(RADIO_TECHS[i])); 990 verify(mImsProvisioningLoader, times(1)) 991 .setProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capability), 992 eq(RADIO_TECHS[i]), eq(provisionedSecond)); 993 994 // verify whether Callback is called or not 995 verify(mIFeatureProvisioningCallback0, times(1)) 996 .onFeatureProvisioningChanged(eq(capability), eq(RADIO_TECHS[i]), 997 eq(provisionedSecond)); 998 } 999 1000 // verify whether ImsConfig is called or not 1001 verify(mImsConfig, times(1)).setConfig( 1002 eq(KEY_VT_PROVISIONING_STATUS), eq(PROVISIONING_VALUE_ENABLED)); 1003 1004 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1005 verifyNoMoreInteractions(mIFeatureProvisioningCallback1); 1006 verifyNoMoreInteractions(mImsConfig); 1007 verifyNoMoreInteractions(mImsProvisioningLoader); 1008 } 1009 1010 @Test 1011 @SmallTest setRcsProvisioningRequiredForCapability_withPresence()1012 public void setRcsProvisioningRequiredForCapability_withPresence() throws Exception { 1013 createImsProvisioningController(); 1014 1015 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 1016 mRcsConnectorListener0.getValue().connectionReady(mRcsFeatureManager, mSubId0); 1017 processAllMessages(); 1018 1019 // register callbacks 1020 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1021 mSubId0, mIFeatureProvisioningCallback0); 1022 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1023 mSubId1, mIFeatureProvisioningCallback1); 1024 1025 clearInvocations(mIFeatureProvisioningCallback0); 1026 clearInvocations(mIFeatureProvisioningCallback1); 1027 clearInvocations(mImsConfig); 1028 clearInvocations(mImsProvisioningLoader); 1029 1030 // provisioning required capability 1031 // PRESENCE, all tech 1032 setCarrierConfig(mSubId0, 1033 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 1034 1035 // provisioning Status, all of provisioning status is not provisioned 1036 mRcsProvisioningStorage = new int[][] { 1037 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, 0}, 1038 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, 0}, 1039 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, 0}, 1040 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, 0} 1041 }; 1042 1043 boolean provisionedFirst; 1044 boolean provisionedSecond; 1045 int capability = CAPABILITY_TYPE_PRESENCE_UCE; 1046 1047 // get provisioning status 1048 provisionedFirst = mTestImsProvisioningController 1049 .getRcsProvisioningStatusForCapability(mSubId0, capability, REGISTRATION_TECH_LTE); 1050 1051 // verify return value default false - not provisioned 1052 assertEquals(false, provisionedFirst); 1053 1054 mTestImsProvisioningController.setRcsProvisioningStatusForCapability( 1055 mSubId0, capability, REGISTRATION_TECH_LTE, !provisionedFirst); 1056 processAllMessages(); 1057 1058 provisionedSecond = mTestImsProvisioningController 1059 .getRcsProvisioningStatusForCapability(mSubId0, capability, REGISTRATION_TECH_LTE); 1060 1061 // verify return value default false - provisioned 1062 assertEquals(!provisionedFirst, provisionedSecond); 1063 1064 // verify whether ImsProvisioningLoader is called or not 1065 verify(mImsProvisioningLoader, times(2)).getProvisioningStatus( 1066 eq(mSubId0), eq(FEATURE_RCS), eq(capability), eq(REGISTRATION_TECH_LTE)); 1067 // verify setProvisioningStatus is called RADIO_TECHS.length times for all tech or not 1068 verify(mImsProvisioningLoader, times(1)).setProvisioningStatus( 1069 eq(mSubId0), eq(FEATURE_RCS), eq(capability), anyInt(), eq(provisionedSecond)); 1070 1071 // verify whether Callback is called RADIO_TECHS.length times for all tech or not 1072 verify(mIFeatureProvisioningCallback0, times(1)) 1073 .onRcsFeatureProvisioningChanged(eq(capability), eq(REGISTRATION_TECH_LTE), 1074 eq(provisionedSecond)); 1075 1076 // verify whether ImsConfig is called or not 1077 // EAB provisioning status should be updated to both the Rcs and MmTel ImsService 1078 verify(mImsConfig, times(2)).setConfig( 1079 eq(KEY_EAB_PROVISIONING_STATUS), eq(PROVISIONING_VALUE_ENABLED)); 1080 1081 // verify reset 1082 clearInvocations(mImsProvisioningLoader); 1083 1084 // only CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE - provisioned 1085 boolean[] expected = {true, false, false, false}; 1086 for (int i = 0; i < RADIO_TECHS.length; i++) { 1087 provisionedSecond = mTestImsProvisioningController 1088 .getRcsProvisioningStatusForCapability(mSubId0, capability, RADIO_TECHS[i]); 1089 1090 // verify return value 1091 assertEquals(expected[i], provisionedSecond); 1092 1093 // verify whether ImsProvisioningLoader is called or not 1094 verify(mImsProvisioningLoader, times(1)).getProvisioningStatus( 1095 eq(mSubId0), eq(FEATURE_RCS), eq(capability), eq(RADIO_TECHS[i])); 1096 } 1097 1098 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1099 verifyNoMoreInteractions(mIFeatureProvisioningCallback1); 1100 verifyNoMoreInteractions(mImsConfig); 1101 verifyNoMoreInteractions(mImsProvisioningLoader); 1102 } 1103 1104 @Test 1105 @SmallTest setProvisioningValue_withMmTelKey()1106 public void setProvisioningValue_withMmTelKey() throws Exception { 1107 createImsProvisioningController(); 1108 1109 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 1110 processAllMessages(); 1111 1112 // add callback with valid obj 1113 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1114 mSubId0, mIFeatureProvisioningCallback0); 1115 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1116 mSubId1, mIFeatureProvisioningCallback1); 1117 1118 clearInvocations(mIFeatureProvisioningCallback0); 1119 clearInvocations(mIFeatureProvisioningCallback1); 1120 clearInvocations(mImsConfig); 1121 clearInvocations(mImsProvisioningLoader); 1122 1123 // provisioning required capability 1124 // voice, all tech 1125 // video, all tech 1126 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 1127 RADIO_TECHS); 1128 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 1129 RADIO_TECHS); 1130 1131 // provisioning Status, all of provisioning status is not set 1132 mMmTelProvisioningStorage = new int[][] { 1133 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE, -1}, 1134 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN, -1}, 1135 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_CROSS_SIM, -1}, 1136 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_NR, -1}, 1137 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE, -1}, 1138 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_IWLAN, -1}, 1139 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_CROSS_SIM, -1}, 1140 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_NR, -1} 1141 }; 1142 1143 // MmTel valid 1144 int[] keys = { 1145 ProvisioningManager.KEY_VOLTE_PROVISIONING_STATUS, 1146 ProvisioningManager.KEY_VT_PROVISIONING_STATUS, 1147 ProvisioningManager.KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE 1148 }; 1149 int[] capas = { 1150 MmTelCapabilities.CAPABILITY_TYPE_VOICE, 1151 MmTelCapabilities.CAPABILITY_TYPE_VIDEO, 1152 MmTelCapabilities.CAPABILITY_TYPE_VOICE 1153 }; 1154 int[] techs = { 1155 ImsRegistrationImplBase.REGISTRATION_TECH_LTE, 1156 ImsRegistrationImplBase.REGISTRATION_TECH_LTE, 1157 ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN 1158 }; 1159 1160 int result; 1161 for (int i = 0; i < keys.length; i++) { 1162 clearInvocations(mIFeatureProvisioningCallback0); 1163 result = mTestImsProvisioningController.setProvisioningValue( 1164 mSubId0, keys[i], PROVISIONING_VALUE_ENABLED); 1165 processAllMessages(); 1166 1167 // check return value 1168 assertEquals(ImsConfig.OperationStatusConstants.SUCCESS, result); 1169 1170 // check whether to save 1171 verify(mImsProvisioningLoader, times(1)).setProvisioningStatus( 1172 eq(mSubId0), eq(FEATURE_MMTEL), eq(capas[i]), eq(techs[i]), eq(true)); 1173 1174 verify(mIFeatureProvisioningCallback0, times(1)) 1175 .onFeatureProvisioningChanged(eq(capas[i]), eq(techs[i]), eq(true)); 1176 1177 verify(mImsConfig, times(1)).setConfig(eq(keys[i]), eq(PROVISIONING_VALUE_ENABLED)); 1178 } 1179 1180 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1181 verifyNoMoreInteractions(mIFeatureProvisioningCallback1); 1182 verifyNoMoreInteractions(mImsConfig); 1183 verifyNoMoreInteractions(mImsProvisioningLoader); 1184 } 1185 1186 @Test 1187 @SmallTest setProvisioningValue_withRcsKey()1188 public void setProvisioningValue_withRcsKey() throws Exception { 1189 createImsProvisioningController(); 1190 1191 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 1192 mRcsConnectorListener0.getValue().connectionReady(mRcsFeatureManager, mSubId0); 1193 processAllMessages(); 1194 1195 // add callback with valid obj 1196 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1197 mSubId0, mIFeatureProvisioningCallback0); 1198 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1199 mSubId1, mIFeatureProvisioningCallback1); 1200 1201 clearInvocations(mIFeatureProvisioningCallback0); 1202 clearInvocations(mIFeatureProvisioningCallback1); 1203 clearInvocations(mImsConfig); 1204 clearInvocations(mImsProvisioningLoader); 1205 1206 // provisioning required capability 1207 // presence, all tech 1208 setCarrierConfig(mSubId0, 1209 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 1210 1211 // provisioning Status, all of provisioning status is not set 1212 mRcsProvisioningStorage = new int[][]{ 1213 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, -1}, 1214 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, -1}, 1215 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, -1}, 1216 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, -1} 1217 }; 1218 1219 int key = KEY_EAB_PROVISIONING_STATUS; 1220 int capa = CAPABILITY_TYPE_PRESENCE_UCE; 1221 1222 int result = mTestImsProvisioningController.setProvisioningValue( 1223 mSubId0, key, PROVISIONING_VALUE_ENABLED); 1224 processAllMessages(); 1225 1226 // check return value 1227 assertEquals(ImsConfig.OperationStatusConstants.SUCCESS, result); 1228 1229 // check to save, for all techs 4 times 1230 verify(mImsProvisioningLoader, times(RADIO_TECHS.length)).setProvisioningStatus( 1231 eq(mSubId0), eq(FEATURE_RCS), eq(capa), anyInt(), eq(true)); 1232 1233 verify(mIFeatureProvisioningCallback0, times(RADIO_TECHS.length)) 1234 .onRcsFeatureProvisioningChanged(eq(capa), anyInt(), eq(true)); 1235 1236 // verify whether ImsConfig is called or not 1237 // EAB provisioning status should be updated to both the Rcs and MmTel ImsService 1238 verify(mImsConfig, times(2)).setConfig(eq(key), eq(PROVISIONING_VALUE_ENABLED)); 1239 1240 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1241 verifyNoMoreInteractions(mIFeatureProvisioningCallback1); 1242 verifyNoMoreInteractions(mImsConfig); 1243 verifyNoMoreInteractions(mImsProvisioningLoader); 1244 } 1245 1246 @Test 1247 @SmallTest setProvisioningValue_withInvalidKey()1248 public void setProvisioningValue_withInvalidKey() throws Exception { 1249 createImsProvisioningController(); 1250 1251 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 1252 mRcsConnectorListener0.getValue().connectionReady(mRcsFeatureManager, mSubId0); 1253 processAllMessages(); 1254 1255 // add callback with valid obj 1256 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1257 mSubId0, mIFeatureProvisioningCallback0); 1258 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1259 mSubId1, mIFeatureProvisioningCallback1); 1260 1261 clearInvocations(mIFeatureProvisioningCallback0); 1262 clearInvocations(mIFeatureProvisioningCallback1); 1263 clearInvocations(mImsConfig); 1264 clearInvocations(mImsProvisioningLoader); 1265 1266 // invalid key 1267 int[] keys = { 1268 ProvisioningManager.KEY_SIP_SESSION_TIMER_SEC, 1269 ProvisioningManager.KEY_MINIMUM_SIP_SESSION_EXPIRATION_TIMER_SEC, 1270 ProvisioningManager.KEY_TF_TIMER_VALUE_MS 1271 }; 1272 for (int key : keys) { 1273 int result = mTestImsProvisioningController.setProvisioningValue( 1274 mSubId0, key, PROVISIONING_VALUE_ENABLED); 1275 processAllMessages(); 1276 1277 // check return value 1278 assertEquals(ImsConfigImplBase.CONFIG_RESULT_UNKNOWN, result); 1279 } 1280 1281 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1282 verifyNoMoreInteractions(mIFeatureProvisioningCallback1); 1283 verifyNoMoreInteractions(mImsConfig); 1284 verifyNoMoreInteractions(mImsProvisioningLoader); 1285 } 1286 1287 @Test 1288 @SmallTest getProvisioningValue_withValidKey()1289 public void getProvisioningValue_withValidKey() throws Exception { 1290 createImsProvisioningController(); 1291 1292 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 1293 mRcsConnectorListener0.getValue().connectionReady(mRcsFeatureManager, mSubId0); 1294 processAllMessages(); 1295 1296 // add callback with valid obj 1297 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1298 mSubId0, mIFeatureProvisioningCallback0); 1299 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1300 mSubId1, mIFeatureProvisioningCallback1); 1301 1302 clearInvocations(mIFeatureProvisioningCallback0); 1303 clearInvocations(mIFeatureProvisioningCallback1); 1304 clearInvocations(mImsConfig); 1305 clearInvocations(mImsProvisioningLoader); 1306 1307 // provisioning required capability 1308 // voice, LTE, IWLAN 1309 // video, LTE 1310 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 1311 REGISTRATION_TECH_LTE, REGISTRATION_TECH_IWLAN); 1312 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 1313 REGISTRATION_TECH_LTE); 1314 1315 // provisioning Status, all of provisioning status is not set 1316 mMmTelProvisioningStorage = new int[][] { 1317 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE, 1}, 1318 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN, 1}, 1319 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE, 1} 1320 }; 1321 1322 // provisioning required capability 1323 // presence, all tech 1324 setCarrierConfig(mSubId0, 1325 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 1326 1327 // provisioning Status, all of provisioning status is not set 1328 mRcsProvisioningStorage = new int[][]{ 1329 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, 1}, 1330 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, 1}, 1331 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, 1}, 1332 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, 1} 1333 }; 1334 1335 // MmTel keys 1336 int[] keys = { 1337 KEY_VOLTE_PROVISIONING_STATUS, 1338 KEY_VT_PROVISIONING_STATUS, 1339 KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE, 1340 }; 1341 int[] capas = { 1342 CAPABILITY_TYPE_VOICE, 1343 CAPABILITY_TYPE_VIDEO, 1344 CAPABILITY_TYPE_VOICE 1345 }; 1346 int[] techs = { 1347 REGISTRATION_TECH_LTE, 1348 REGISTRATION_TECH_LTE, 1349 REGISTRATION_TECH_IWLAN 1350 }; 1351 for (int i = 0; i < keys.length; i++) { 1352 int result = mTestImsProvisioningController.getProvisioningValue(mSubId0, keys[i]); 1353 processAllMessages(); 1354 1355 // check return value 1356 assertEquals(PROVISIONING_VALUE_ENABLED, result); 1357 1358 // verify whether ImsProvisioningLoader is called or not 1359 verify(mImsProvisioningLoader, times(1)).getProvisioningStatus(eq(mSubId0), 1360 eq(FEATURE_MMTEL), eq(capas[i]), eq(techs[i])); 1361 } 1362 clearInvocations(mImsProvisioningLoader); 1363 1364 // Rcs keys 1365 int key = KEY_EAB_PROVISIONING_STATUS; 1366 int capa = CAPABILITY_TYPE_PRESENCE_UCE; 1367 1368 int result = mTestImsProvisioningController.getProvisioningValue(mSubId0, key); 1369 processAllMessages(); 1370 1371 // check return value 1372 assertEquals(PROVISIONING_VALUE_ENABLED, result); 1373 1374 // verify whether ImsProvisioningLoader is called or not 1375 verify(mImsProvisioningLoader, times(1)).getProvisioningStatus( 1376 eq(mSubId0), eq(FEATURE_RCS), eq(capa), anyInt()); 1377 1378 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1379 verifyNoMoreInteractions(mIFeatureProvisioningCallback1); 1380 verifyNoMoreInteractions(mImsConfig); 1381 verifyNoMoreInteractions(mImsProvisioningLoader); 1382 } 1383 1384 @Test 1385 @SmallTest getProvisioningValue_withNotSet()1386 public void getProvisioningValue_withNotSet() throws Exception { 1387 createImsProvisioningController(); 1388 1389 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 1390 mRcsConnectorListener0.getValue().connectionReady(mRcsFeatureManager, mSubId0); 1391 processAllMessages(); 1392 1393 // add callback with valid obj 1394 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1395 mSubId0, mIFeatureProvisioningCallback0); 1396 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1397 mSubId1, mIFeatureProvisioningCallback1); 1398 1399 clearInvocations(mIFeatureProvisioningCallback0); 1400 clearInvocations(mIFeatureProvisioningCallback1); 1401 clearInvocations(mImsConfig); 1402 clearInvocations(mImsProvisioningLoader); 1403 1404 // provisioning required capability 1405 // voice, LTE, IWLAN 1406 // video, LTE 1407 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 1408 REGISTRATION_TECH_LTE, REGISTRATION_TECH_IWLAN); 1409 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 1410 REGISTRATION_TECH_LTE); 1411 1412 // provisioning Status, all of provisioning status is not set 1413 mMmTelProvisioningStorage = new int[][] { 1414 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE, -1}, 1415 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN, -1}, 1416 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE, -1} 1417 }; 1418 1419 // provisioning required capability 1420 // presence, all tech 1421 setCarrierConfig(mSubId0, 1422 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 1423 1424 // provisioning Status, all of provisioning status is not set 1425 mRcsProvisioningStorage = new int[][]{ 1426 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, -1}, 1427 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, -1}, 1428 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, -1}, 1429 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, -1} 1430 }; 1431 // provisioning status in ImsService 1432 mImsConfigStorage = new int[][] { 1433 {KEY_VOLTE_PROVISIONING_STATUS, 1}, 1434 {KEY_VT_PROVISIONING_STATUS, 1}, 1435 {KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE, 1}, 1436 {KEY_EAB_PROVISIONING_STATUS, 1} 1437 }; 1438 1439 // MmTel keys 1440 int[] keys = { 1441 KEY_VOLTE_PROVISIONING_STATUS, 1442 KEY_VT_PROVISIONING_STATUS, 1443 KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE, 1444 }; 1445 int[] capas = { 1446 CAPABILITY_TYPE_VOICE, 1447 CAPABILITY_TYPE_VIDEO, 1448 CAPABILITY_TYPE_VOICE 1449 }; 1450 int[] techs = { 1451 REGISTRATION_TECH_LTE, 1452 REGISTRATION_TECH_LTE, 1453 REGISTRATION_TECH_IWLAN 1454 }; 1455 for (int i = 0; i < keys.length; i++) { 1456 int result = mTestImsProvisioningController.getProvisioningValue(mSubId0, keys[i]); 1457 processAllMessages(); 1458 1459 // check return value 1460 assertEquals(PROVISIONING_VALUE_ENABLED, result); 1461 1462 // verify whether ImsProvisioningLoader is called or not 1463 verify(mImsProvisioningLoader, times(1)).getProvisioningStatus(eq(mSubId0), 1464 eq(FEATURE_MMTEL), eq(capas[i]), eq(techs[i])); 1465 1466 // verify whether ImsConfig is called or not 1467 verify(mImsConfig, times(1)).getConfigInt(eq(keys[i])); 1468 1469 // verify whether ImsProvisioningLoader is called or not 1470 verify(mImsProvisioningLoader, times(1)).setProvisioningStatus(eq(mSubId0), 1471 eq(FEATURE_MMTEL), eq(capas[i]), eq(techs[i]), eq(true)); 1472 1473 // verify whether callback is called or not 1474 verify(mIFeatureProvisioningCallback0, times(1)).onFeatureProvisioningChanged( 1475 eq(capas[i]), eq(techs[i]), eq(true)); 1476 } 1477 clearInvocations(mImsConfig); 1478 clearInvocations(mImsProvisioningLoader); 1479 1480 // Rcs keys 1481 int key = KEY_EAB_PROVISIONING_STATUS; 1482 int capa = CAPABILITY_TYPE_PRESENCE_UCE; 1483 1484 int result = mTestImsProvisioningController.getProvisioningValue(mSubId0, key); 1485 processAllMessages(); 1486 1487 // check return value 1488 assertEquals(PROVISIONING_VALUE_ENABLED, result); 1489 1490 // verify whether ImsProvisioningLoader is called or not 1491 verify(mImsProvisioningLoader, times(1)).getProvisioningStatus( 1492 eq(mSubId0), eq(FEATURE_RCS), eq(capa), anyInt()); 1493 1494 // verify whether ImsConfig is called or not 1495 verify(mImsConfig, times(1)).getConfigInt(eq(key)); 1496 1497 // verify whether ImsProvisioningLoader is called or not 1498 verify(mImsProvisioningLoader, times(RADIO_TECHS.length)).setProvisioningStatus( 1499 eq(mSubId0), eq(FEATURE_RCS), eq(capa), anyInt(), eq(true)); 1500 1501 // verify whether callback is called or not 1502 verify(mIFeatureProvisioningCallback0, times(RADIO_TECHS.length)) 1503 .onRcsFeatureProvisioningChanged(eq(capa), anyInt(), eq(true)); 1504 1505 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1506 verifyNoMoreInteractions(mIFeatureProvisioningCallback1); 1507 verifyNoMoreInteractions(mImsConfig); 1508 verifyNoMoreInteractions(mImsProvisioningLoader); 1509 } 1510 1511 @Test 1512 @SmallTest onMultiSimConfigChanged()1513 public void onMultiSimConfigChanged() throws Exception { 1514 createImsProvisioningController(); 1515 1516 // provisioning required capability 1517 // voice, all tech 1518 // video, all tech 1519 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 1520 RADIO_TECHS); 1521 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 1522 RADIO_TECHS); 1523 1524 // change number of slot 2 -> 1 1525 mHandler.sendMessage(mHandler.obtainMessage( 1526 mTestImsProvisioningController.EVENT_MULTI_SIM_CONFIGURATION_CHANGE, 1527 0, 0, (Object) new AsyncResult(null, 1, null))); 1528 processAllMessages(); 1529 1530 // add callback with mSubId0, mPhoneId0 : Ok. 1531 try { 1532 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1533 mSubId0, mIFeatureProvisioningCallback0); 1534 } catch (Exception e) { 1535 throw new AssertionError("not expected exception", e); 1536 } 1537 1538 // add callbacks with new mSubId1, mPhoneId1 : IllegalArgumentException. 1539 try { 1540 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1541 mSubId1, mIFeatureProvisioningCallback1); 1542 } catch (IllegalArgumentException e) { 1543 // expected result 1544 } catch (Exception e) { 1545 throw new AssertionError("not expected exception", e); 1546 } 1547 // check isImsProvisioningRequiredForCapability with mSubId1 : IllegalArgumentException 1548 try { 1549 mTestImsProvisioningController.isImsProvisioningRequiredForCapability( 1550 mSubId1, CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE); 1551 } catch (IllegalArgumentException e) { 1552 // expected result 1553 } catch (Exception e) { 1554 throw new AssertionError("not expected exception", e); 1555 } 1556 clearInvocations(mIFeatureProvisioningCallback0); 1557 clearInvocations(mIFeatureProvisioningCallback1); 1558 1559 // change number of slot 1 -> 2 1560 mHandler.sendMessage(mHandler.obtainMessage( 1561 mTestImsProvisioningController.EVENT_MULTI_SIM_CONFIGURATION_CHANGE, 1562 0, 0, (Object) new AsyncResult(null, 2, null))); 1563 processAllMessages(); 1564 1565 // add callback with mSubId0, mPhoneId0 : Ok. 1566 try { 1567 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1568 mSubId0, mIFeatureProvisioningCallback0); 1569 } catch (Exception e) { 1570 throw new AssertionError("not expected exception", e); 1571 } 1572 1573 // add callbacks with new mSubId1, mPhoneId1 : Ok. 1574 try { 1575 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1576 mSubId1, mIFeatureProvisioningCallback1); 1577 } catch (Exception e) { 1578 throw new AssertionError("not expected exception", e); 1579 } 1580 clearInvocations(mIFeatureProvisioningCallback0); 1581 clearInvocations(mIFeatureProvisioningCallback1); 1582 1583 // provisioning required capability 1584 // voice, all tech 1585 setCarrierConfig(mSubId1, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 1586 RADIO_TECHS); 1587 1588 // check get,setImsProvisioningRequiredForCapability with mSubId1, mPhoneId1 : Ok 1589 int capability = CAPABILITY_TYPE_VOICE; 1590 int tech = REGISTRATION_TECH_LTE; 1591 boolean provisioned; 1592 provisioned = mTestImsProvisioningController.getImsProvisioningStatusForCapability( 1593 mSubId1, capability, tech); 1594 mTestImsProvisioningController.setImsProvisioningStatusForCapability(mSubId1, 1595 capability, tech, !provisioned); 1596 processAllMessages(); 1597 1598 // verify whether Callback is called or not 1599 verify(mIFeatureProvisioningCallback1, times(1)) 1600 .onFeatureProvisioningChanged(eq(capability), eq(tech), eq(!provisioned)); 1601 1602 clearInvocations(mIFeatureProvisioningCallback0); 1603 clearInvocations(mIFeatureProvisioningCallback1); 1604 clearInvocations(mImsConfig); 1605 } 1606 1607 @Test 1608 @SmallTest eabProvisioningStatus_onlyMmTelConnectionReady()1609 public void eabProvisioningStatus_onlyMmTelConnectionReady() throws Exception { 1610 createImsProvisioningController(); 1611 1612 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 1613 processAllMessages(); 1614 1615 // add callback with valid obj 1616 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1617 mSubId0, mIFeatureProvisioningCallback0); 1618 1619 clearInvocations(mIFeatureProvisioningCallback0); 1620 clearInvocations(mImsConfig); 1621 clearInvocations(mImsProvisioningLoader); 1622 1623 // provisioning required capability 1624 // presence, all tech 1625 setCarrierConfig(mSubId0, 1626 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 1627 1628 // provisioning Status, all of provisioning status is not set 1629 mRcsProvisioningStorage = new int[][]{ 1630 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, -1}, 1631 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, -1}, 1632 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, -1}, 1633 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, -1} 1634 }; 1635 1636 // provisioning status in ImsService 1637 mImsConfigStorage = new int[][] { 1638 {KEY_EAB_PROVISIONING_STATUS, 1} 1639 }; 1640 1641 // Rcs keys 1642 int key = KEY_EAB_PROVISIONING_STATUS; 1643 int capa = CAPABILITY_TYPE_PRESENCE_UCE; 1644 int tech = REGISTRATION_TECH_LTE; 1645 1646 int result = mTestImsProvisioningController.getProvisioningValue(mSubId0, key); 1647 processAllMessages(); 1648 1649 // check return value 1650 assertEquals(PROVISIONING_VALUE_ENABLED, result); 1651 1652 // verify whether ImsProvisioningLoader is called or not 1653 verify(mImsProvisioningLoader, times(1)).getProvisioningStatus( 1654 eq(mSubId0), eq(FEATURE_RCS), eq(capa), anyInt()); 1655 1656 // even if ImsConfig is not available in RcsFeatureListener, ImsConfig in 1657 // MmTelFeatureListener will be called. 1658 verify(mImsConfig, times(1)).getConfigInt( 1659 eq(KEY_EAB_PROVISIONING_STATUS)); 1660 1661 // verify whether ImsProvisioningLoader is called or not 1662 verify(mImsProvisioningLoader, times(RADIO_TECHS.length)).setProvisioningStatus( 1663 eq(mSubId0), eq(FEATURE_RCS), eq(capa), anyInt(), eq(true)); 1664 1665 verifyNoMoreInteractions(mImsConfig); 1666 verifyNoMoreInteractions(mImsProvisioningLoader); 1667 1668 clearInvocations(mImsConfig); 1669 clearInvocations(mImsProvisioningLoader); 1670 1671 mTestImsProvisioningController.setProvisioningValue(mSubId0, key, 1672 PROVISIONING_VALUE_DISABLED); 1673 processAllMessages(); 1674 1675 // verify whether ImsProvisioningLoader is called or not 1676 verify(mImsProvisioningLoader, times(RADIO_TECHS.length)).setProvisioningStatus( 1677 eq(mSubId0), eq(FEATURE_RCS), eq(capa), anyInt(), eq(false)); 1678 1679 // even if ImsConfig is not available in RcsFeatureListener, ImsConfig in 1680 // MmTelFeatureListener will be called. 1681 verify(mImsConfig, times(1)).setConfig( 1682 eq(KEY_EAB_PROVISIONING_STATUS), eq(PROVISIONING_VALUE_DISABLED)); 1683 1684 verifyNoMoreInteractions(mImsConfig); 1685 verifyNoMoreInteractions(mImsProvisioningLoader); 1686 1687 clearInvocations(mImsConfig); 1688 clearInvocations(mImsProvisioningLoader); 1689 1690 // reset provisioning status, all of provisioning status is not set 1691 mRcsProvisioningStorage = new int[][]{ 1692 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, -1}, 1693 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, -1}, 1694 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, -1}, 1695 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, -1} 1696 }; 1697 1698 // reset provisioning status in ImsService 1699 mImsConfigStorage = new int[][] { 1700 {KEY_EAB_PROVISIONING_STATUS, 1} 1701 }; 1702 1703 boolean expected = true; 1704 boolean provisioned = mTestImsProvisioningController.getRcsProvisioningStatusForCapability( 1705 mSubId0, capa, tech); 1706 processAllMessages(); 1707 1708 assertEquals(expected, provisioned); 1709 1710 // verify whether ImsProvisioningLoader is called or not 1711 verify(mImsProvisioningLoader, times(1)).getProvisioningStatus( 1712 eq(mSubId0), eq(FEATURE_RCS), eq(capa), eq(tech)); 1713 1714 // even if ImsConfig is not available in RcsFeatureListener, ImsConfig in 1715 // MmTelFeatureListener will be called. 1716 verify(mImsConfig, times(1)).getConfigInt( 1717 eq(KEY_EAB_PROVISIONING_STATUS)); 1718 1719 // verify whether ImsProvisioningLoader is called or not 1720 verify(mImsProvisioningLoader, times(RADIO_TECHS.length)).setProvisioningStatus( 1721 eq(mSubId0), eq(FEATURE_RCS), eq(capa), anyInt(), eq(true)); 1722 1723 verifyNoMoreInteractions(mImsConfig); 1724 verifyNoMoreInteractions(mImsProvisioningLoader); 1725 1726 clearInvocations(mImsConfig); 1727 clearInvocations(mImsProvisioningLoader); 1728 1729 mTestImsProvisioningController.setRcsProvisioningStatusForCapability( 1730 mSubId0, capa, tech, !expected); 1731 processAllMessages(); 1732 1733 // verify whether ImsProvisioningLoader is called or not 1734 verify(mImsProvisioningLoader, times(1)).setProvisioningStatus( 1735 eq(mSubId0), eq(FEATURE_RCS), eq(capa), eq(tech), eq(!expected)); 1736 1737 // even if ImsConfig is not available in RcsFeatureListener, ImsConfig in 1738 // MmTelFeatureListener will be called. 1739 verify(mImsConfig, times(1)).setConfig( 1740 eq(KEY_EAB_PROVISIONING_STATUS), eq(PROVISIONING_VALUE_DISABLED)); 1741 1742 verifyNoMoreInteractions(mImsConfig); 1743 verifyNoMoreInteractions(mImsProvisioningLoader); 1744 } 1745 1746 @Test 1747 @SmallTest changedProvisioningValue_withMmTel()1748 public void changedProvisioningValue_withMmTel() throws Exception { 1749 createImsProvisioningController(); 1750 1751 // provisioning required capability 1752 // voice, all tech 1753 // video, all tech 1754 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 1755 RADIO_TECHS); 1756 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 1757 RADIO_TECHS); 1758 1759 try { 1760 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1761 mSubId0, mIFeatureProvisioningCallback0); 1762 } catch (Exception e) { 1763 throw new AssertionError("not expected exception", e); 1764 } 1765 1766 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 1767 1768 // clear interactions 1769 clearInvocations(mIFeatureProvisioningCallback0); 1770 clearInvocations(mImsConfig); 1771 clearInvocations(mImsProvisioningLoader); 1772 1773 // MmTel valid 1774 int[] keys = { 1775 ProvisioningManager.KEY_VOLTE_PROVISIONING_STATUS, 1776 ProvisioningManager.KEY_VT_PROVISIONING_STATUS, 1777 ProvisioningManager.KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE 1778 }; 1779 int[] capas = { 1780 MmTelCapabilities.CAPABILITY_TYPE_VOICE, 1781 MmTelCapabilities.CAPABILITY_TYPE_VIDEO, 1782 MmTelCapabilities.CAPABILITY_TYPE_VOICE 1783 }; 1784 int[] techs = { 1785 ImsRegistrationImplBase.REGISTRATION_TECH_LTE, 1786 ImsRegistrationImplBase.REGISTRATION_TECH_LTE, 1787 ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN 1788 }; 1789 1790 for (int index = 0; index < keys.length; index++) { 1791 mIImsConfigCallback.getValue().onIntConfigChanged(keys[index], 1792 PROVISIONING_VALUE_DISABLED); 1793 processAllMessages(); 1794 1795 // verify # of read data times from storage : # of MmTel storage length 1796 verify(mImsProvisioningLoader, times(1)) 1797 .setProvisioningStatus(eq(mSubId0), eq(FEATURE_MMTEL), eq(capas[index]), 1798 eq(techs[index]), eq(false)); 1799 1800 verify(mIFeatureProvisioningCallback0, times(1)) 1801 .onFeatureProvisioningChanged(eq(capas[index]), eq(techs[index]), eq(false)); 1802 } 1803 1804 verifyNoMoreInteractions(mImsProvisioningLoader); 1805 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1806 verifyNoMoreInteractions(mImsConfig); 1807 } 1808 1809 @Test 1810 @SmallTest changedProvisioningValue_withRcs()1811 public void changedProvisioningValue_withRcs() throws Exception { 1812 createImsProvisioningController(); 1813 1814 // provisioning required capability : PRESENCE, tech : all 1815 setCarrierConfig(mSubId0, 1816 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 1817 1818 try { 1819 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1820 mSubId0, mIFeatureProvisioningCallback0); 1821 } catch (Exception e) { 1822 throw new AssertionError("not expected exception", e); 1823 } 1824 1825 mRcsConnectorListener0.getValue().connectionReady(mRcsFeatureManager, mSubId0); 1826 1827 // clear interactions 1828 clearInvocations(mIFeatureProvisioningCallback0); 1829 clearInvocations(mImsConfig); 1830 clearInvocations(mImsProvisioningLoader); 1831 1832 mIImsConfigCallback.getValue().onIntConfigChanged(KEY_EAB_PROVISIONING_STATUS, 1833 PROVISIONING_VALUE_DISABLED); 1834 processAllMessages(); 1835 1836 // verify # of read data times from storage : # of MmTel storage length 1837 verify(mImsProvisioningLoader, times(RADIO_TECHS.length)) 1838 .setProvisioningStatus(eq(mSubId0), eq(FEATURE_RCS), 1839 eq(CAPABILITY_TYPE_PRESENCE_UCE), anyInt(), eq(false)); 1840 1841 verify(mIFeatureProvisioningCallback0, times(RADIO_TECHS.length)) 1842 .onRcsFeatureProvisioningChanged(eq(CAPABILITY_TYPE_PRESENCE_UCE), anyInt(), 1843 eq(false)); 1844 1845 verifyNoMoreInteractions(mImsProvisioningLoader); 1846 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1847 verifyNoMoreInteractions(mImsConfig); 1848 } 1849 1850 @Test 1851 @SmallTest initialNotifyMmTelProvisioningStatusWhenCallbackRegistered()1852 public void initialNotifyMmTelProvisioningStatusWhenCallbackRegistered() throws Exception { 1853 when(mFeatureFlags.notifyInitialImsProvisioningStatus()).thenReturn(true); 1854 1855 createImsProvisioningController(); 1856 1857 // Provisioning required for capability on all network type 1858 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 1859 RADIO_TECHS); 1860 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 1861 RADIO_TECHS); 1862 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_UT_INT_ARRAY, 1863 RADIO_TECHS); 1864 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_SMS_INT_ARRAY, 1865 RADIO_TECHS); 1866 setCarrierConfig(mSubId0, 1867 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_CALL_COMPOSER_INT_ARRAY, RADIO_TECHS); 1868 1869 // Stored provisioning Status 1870 mMmTelProvisioningStorage = new int[][] { 1871 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE, 0}, 1872 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN, 1}, 1873 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_CROSS_SIM, 1}, 1874 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_NR, 1}, 1875 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE, 0}, 1876 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_IWLAN, 0}, 1877 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_CROSS_SIM, 1}, 1878 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_NR, 1}, 1879 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_LTE, 0}, 1880 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_IWLAN, 0}, 1881 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_CROSS_SIM, 0}, 1882 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_NR, 0}, 1883 {CAPABILITY_TYPE_SMS, REGISTRATION_TECH_LTE, 1}, 1884 {CAPABILITY_TYPE_SMS, REGISTRATION_TECH_IWLAN, 1}, 1885 {CAPABILITY_TYPE_SMS, REGISTRATION_TECH_CROSS_SIM, 1}, 1886 {CAPABILITY_TYPE_SMS, REGISTRATION_TECH_NR, 1}, 1887 {CAPABILITY_TYPE_CALL_COMPOSER, REGISTRATION_TECH_LTE, 1}, 1888 {CAPABILITY_TYPE_CALL_COMPOSER, REGISTRATION_TECH_IWLAN, 1}, 1889 {CAPABILITY_TYPE_CALL_COMPOSER, REGISTRATION_TECH_CROSS_SIM, 0}, 1890 {CAPABILITY_TYPE_CALL_COMPOSER, REGISTRATION_TECH_NR, 1} 1891 }; 1892 1893 try { 1894 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1895 mSubId0, mIFeatureProvisioningCallback0); 1896 } catch (Exception e) { 1897 throw new AssertionError("not expected exception", e); 1898 } 1899 processAllMessages(); 1900 1901 for (int[] capa: mMmTelProvisioningStorage) { 1902 verify(mIFeatureProvisioningCallback0, times(1)) 1903 .onFeatureProvisioningChanged(eq(capa[0]), eq(capa[1]), eq(capa[2] == 1)); 1904 } 1905 } 1906 1907 @Test 1908 @SmallTest initialNotifyRcsProvisioningStatusWhenCallbackRegistered()1909 public void initialNotifyRcsProvisioningStatusWhenCallbackRegistered() throws Exception { 1910 when(mFeatureFlags.notifyInitialImsProvisioningStatus()).thenReturn(true); 1911 1912 createImsProvisioningController(); 1913 1914 // Provisioning required capability : PRESENCE, tech : all 1915 setCarrierConfig(mSubId0, 1916 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 1917 1918 // Stored provisioning Status 1919 mRcsProvisioningStorage = new int[][]{ 1920 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, 1}, 1921 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, 1}, 1922 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, 0}, 1923 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, 1} 1924 }; 1925 1926 try { 1927 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1928 mSubId0, mIFeatureProvisioningCallback0); 1929 } catch (Exception e) { 1930 throw new AssertionError("not expected exception", e); 1931 } 1932 processAllMessages(); 1933 1934 for (int[] capa: mRcsProvisioningStorage) { 1935 verify(mIFeatureProvisioningCallback0, times(1)) 1936 .onRcsFeatureProvisioningChanged(eq(capa[0]), eq(capa[1]), eq(capa[2] == 1)); 1937 } 1938 } 1939 1940 @Test 1941 @SmallTest initialNotifyMmTelProvisioningStatusWhenImsServiceConnected()1942 public void initialNotifyMmTelProvisioningStatusWhenImsServiceConnected() throws Exception { 1943 when(mFeatureFlags.notifyInitialImsProvisioningStatus()).thenReturn(true); 1944 1945 createImsProvisioningController(); 1946 1947 // Provisioning required for capability on all network type 1948 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY, 1949 RADIO_TECHS); 1950 setCarrierConfig(mSubId0, CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY, 1951 RADIO_TECHS); 1952 1953 // Stored provisioning Status 1954 mMmTelProvisioningStorage = new int[][] { 1955 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE, 1}, 1956 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN, 1}, 1957 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_CROSS_SIM, 1}, 1958 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_NR, 1}, 1959 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE, 1}, 1960 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_IWLAN, 0}, 1961 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_CROSS_SIM, 0}, 1962 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_NR, 1}, 1963 }; 1964 1965 try { 1966 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 1967 mSubId0, mIFeatureProvisioningCallback0); 1968 } catch (Exception e) { 1969 throw new AssertionError("not expected exception", e); 1970 } 1971 processAllMessages(); 1972 1973 // clear interactions 1974 clearInvocations(mIFeatureProvisioningCallback0); 1975 1976 // ImsService connected 1977 mMmTelConnectorListener0.getValue().connectionReady(mImsManager, mSubId0); 1978 1979 for (int[] capa: mMmTelProvisioningStorage) { 1980 verify(mIFeatureProvisioningCallback0, times(1)) 1981 .onFeatureProvisioningChanged(eq(capa[0]), eq(capa[1]), eq(capa[2] == 1)); 1982 } 1983 1984 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 1985 } 1986 1987 @Test 1988 @SmallTest initialNotifyRcsProvisioningStatusWhenRcsServiceConnected()1989 public void initialNotifyRcsProvisioningStatusWhenRcsServiceConnected() throws Exception { 1990 when(mFeatureFlags.notifyInitialImsProvisioningStatus()).thenReturn(true); 1991 1992 createImsProvisioningController(); 1993 1994 // Provisioning required capability : PRESENCE, tech : all 1995 setCarrierConfig(mSubId0, 1996 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY, RADIO_TECHS); 1997 1998 // Stored provisioning Status 1999 mRcsProvisioningStorage = new int[][]{ 2000 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, 1}, 2001 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, 0}, 2002 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, 0}, 2003 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, 1} 2004 }; 2005 2006 try { 2007 mTestImsProvisioningController.addFeatureProvisioningChangedCallback( 2008 mSubId0, mIFeatureProvisioningCallback0); 2009 } catch (Exception e) { 2010 throw new AssertionError("not expected exception", e); 2011 } 2012 processAllMessages(); 2013 2014 // clear interactions 2015 clearInvocations(mIFeatureProvisioningCallback0); 2016 2017 // ImsService connected 2018 mRcsConnectorListener0.getValue().connectionReady(mRcsFeatureManager, mSubId0); 2019 2020 for (int[] capa: mRcsProvisioningStorage) { 2021 verify(mIFeatureProvisioningCallback0, times(1)) 2022 .onRcsFeatureProvisioningChanged(eq(capa[0]), eq(capa[1]), eq(capa[2] == 1)); 2023 } 2024 2025 verifyNoMoreInteractions(mIFeatureProvisioningCallback0); 2026 } 2027 createImsProvisioningController()2028 private void createImsProvisioningController() throws Exception { 2029 if (Looper.myLooper() == null) { 2030 Looper.prepare(); 2031 } 2032 2033 when(mMmTelFeatureConnector 2034 .create(any(), eq(0), any(), mMmTelConnectorListener0.capture(), any())) 2035 .thenReturn(mMmTelFeatureConnector0); 2036 when(mMmTelFeatureConnector 2037 .create(any(), eq(1), any(), mMmTelConnectorListener1.capture(), any())) 2038 .thenReturn(mMmTelFeatureConnector1); 2039 2040 when(mRcsFeatureConnector 2041 .create(any(), eq(0), mRcsConnectorListener0.capture(), any(), any())) 2042 .thenReturn(mRcsFeatureConnector0); 2043 when(mRcsFeatureConnector 2044 .create(any(), eq(1), mRcsConnectorListener1.capture(), any(), any())) 2045 .thenReturn(mRcsFeatureConnector1); 2046 2047 doNothing().when(mImsConfig).addConfigCallback(mIImsConfigCallback.capture()); 2048 doNothing().when(mImsConfig).removeConfigCallback(any()); 2049 2050 when(mImsConfig.getConfigInt(anyInt())) 2051 .thenAnswer(invocation -> { 2052 int i = (Integer) (invocation.getArguments()[0]); 2053 return getImsConfigValue(i); 2054 }); 2055 when(mImsConfig.setConfig(anyInt(), anyInt())) 2056 .thenAnswer(invocation -> { 2057 int i = (Integer) (invocation.getArguments()[0]); 2058 int j = (Integer) (invocation.getArguments()[1]); 2059 return setImsConfigValue(i, j); 2060 }); 2061 2062 when(mImsProvisioningLoader.getProvisioningStatus(anyInt(), eq(FEATURE_MMTEL), anyInt(), 2063 anyInt())) 2064 .thenAnswer(invocation -> { 2065 int i = (Integer) (invocation.getArguments()[2]); 2066 int j = (Integer) (invocation.getArguments()[3]); 2067 return getProvisionedValue(i, j); 2068 }); 2069 when(mImsProvisioningLoader.getProvisioningStatus(anyInt(), eq(FEATURE_RCS), anyInt(), 2070 anyInt())) 2071 .thenAnswer(invocation -> { 2072 int i = (Integer) (invocation.getArguments()[2]); 2073 int j = (Integer) (invocation.getArguments()[3]); 2074 return getRcsProvisionedValue(i, j); 2075 }); 2076 when(mImsProvisioningLoader 2077 .setProvisioningStatus(anyInt(), eq(FEATURE_MMTEL), anyInt(), anyInt(), 2078 anyBoolean())) 2079 .thenAnswer(invocation -> { 2080 int i = (Integer) (invocation.getArguments()[2]); 2081 int j = (Integer) (invocation.getArguments()[3]); 2082 int k = (Boolean) (invocation.getArguments()[4]) ? 1 : 0; 2083 return setProvisionedValue(i, j, k); 2084 }); 2085 when(mImsProvisioningLoader 2086 .setProvisioningStatus(anyInt(), eq(FEATURE_RCS), anyInt(), anyInt(), 2087 anyBoolean())) 2088 .thenAnswer(invocation -> { 2089 int i = (Integer) (invocation.getArguments()[2]); 2090 int j = (Integer) (invocation.getArguments()[3]); 2091 int k = (Boolean) (invocation.getArguments()[4]) ? 1 : 0; 2092 return setRcsProvisionedValue(i, j, k); 2093 }); 2094 2095 when(mIFeatureProvisioningCallback0.asBinder()).thenReturn(mIbinder0); 2096 when(mIFeatureProvisioningCallback1.asBinder()).thenReturn(mIbinder1); 2097 2098 doNothing().when(mIFeatureProvisioningCallback0) 2099 .onFeatureProvisioningChanged(anyInt(), anyInt(), anyBoolean()); 2100 doNothing().when(mIFeatureProvisioningCallback0) 2101 .onRcsFeatureProvisioningChanged(anyInt(), anyInt(), anyBoolean()); 2102 doNothing().when(mIFeatureProvisioningCallback1) 2103 .onFeatureProvisioningChanged(anyInt(), anyInt(), anyBoolean()); 2104 doNothing().when(mIFeatureProvisioningCallback1) 2105 .onRcsFeatureProvisioningChanged(anyInt(), anyInt(), anyBoolean()); 2106 2107 mTestImsProvisioningController = new TestImsProvisioningController(); 2108 2109 mHandler = mTestImsProvisioningController.getHandler(); 2110 try { 2111 mLooper = new TestableLooper(mHandler.getLooper()); 2112 } catch (Exception e) { 2113 logd("create looper from handler failed"); 2114 } 2115 2116 verify(mRcsFeatureConnector0, atLeastOnce()).connect(); 2117 verify(mMmTelFeatureConnector0, atLeastOnce()).connect(); 2118 2119 verify(mRcsFeatureConnector1, atLeastOnce()).connect(); 2120 verify(mMmTelFeatureConnector1, atLeastOnce()).connect(); 2121 } 2122 initializeDefaultData()2123 private void initializeDefaultData() throws Exception { 2124 mPersistableBundle0.clear(); 2125 mPersistableBundle0.putPersistableBundle( 2126 CarrierConfigManager.Ims.KEY_MMTEL_REQUIRES_PROVISIONING_BUNDLE, 2127 new PersistableBundle()); 2128 mPersistableBundle0.putPersistableBundle( 2129 CarrierConfigManager.Ims.KEY_RCS_REQUIRES_PROVISIONING_BUNDLE, 2130 new PersistableBundle()); 2131 2132 mPersistableBundle1.clear(); 2133 mPersistableBundle1.putPersistableBundle( 2134 CarrierConfigManager.Ims.KEY_MMTEL_REQUIRES_PROVISIONING_BUNDLE, 2135 new PersistableBundle()); 2136 mPersistableBundle1.putPersistableBundle( 2137 CarrierConfigManager.Ims.KEY_RCS_REQUIRES_PROVISIONING_BUNDLE, 2138 new PersistableBundle()); 2139 2140 mMmTelProvisioningStorage = new int[][]{ 2141 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE, 1}, 2142 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN, 1}, 2143 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_CROSS_SIM, 1}, 2144 {CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_NR, 1}, 2145 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE, 1}, 2146 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_IWLAN, 1}, 2147 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_CROSS_SIM, 1}, 2148 {CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_NR, 1}, 2149 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_LTE, 1}, 2150 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_IWLAN, 1}, 2151 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_CROSS_SIM, 1}, 2152 {CAPABILITY_TYPE_UT, REGISTRATION_TECH_NR, 1}, 2153 {CAPABILITY_TYPE_SMS, REGISTRATION_TECH_LTE, 1}, 2154 {CAPABILITY_TYPE_SMS, REGISTRATION_TECH_IWLAN, 1}, 2155 {CAPABILITY_TYPE_SMS, REGISTRATION_TECH_CROSS_SIM, 1}, 2156 {CAPABILITY_TYPE_SMS, REGISTRATION_TECH_NR, 1}, 2157 {CAPABILITY_TYPE_CALL_COMPOSER, REGISTRATION_TECH_LTE, 1}, 2158 {CAPABILITY_TYPE_CALL_COMPOSER, REGISTRATION_TECH_IWLAN, 1}, 2159 {CAPABILITY_TYPE_CALL_COMPOSER, REGISTRATION_TECH_CROSS_SIM, 1}, 2160 {CAPABILITY_TYPE_CALL_COMPOSER, REGISTRATION_TECH_NR, 1} 2161 }; 2162 2163 mRcsProvisioningStorage = new int[][]{ 2164 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_LTE, 1}, 2165 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_IWLAN, 1}, 2166 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_CROSS_SIM, 1}, 2167 {CAPABILITY_TYPE_PRESENCE_UCE, REGISTRATION_TECH_NR, 1} 2168 }; 2169 2170 mImsConfigStorage = new int[][] { 2171 {KEY_VOLTE_PROVISIONING_STATUS, 1}, 2172 {KEY_VT_PROVISIONING_STATUS, 1}, 2173 {KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE, 1}, 2174 {KEY_EAB_PROVISIONING_STATUS, 1} 2175 }; 2176 } 2177 setCarrierConfig(int subId, String capabilityKey, int... techs)2178 private void setCarrierConfig(int subId, String capabilityKey, int... techs) { 2179 PersistableBundle imsCarrierConfig = mPersistableBundle0; 2180 if (subId == mSubId1) { 2181 imsCarrierConfig = mPersistableBundle1; 2182 } 2183 2184 PersistableBundle requiredBundle; 2185 if (capabilityKey.equals( 2186 CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY)) { 2187 requiredBundle = imsCarrierConfig.getPersistableBundle( 2188 CarrierConfigManager.Ims.KEY_RCS_REQUIRES_PROVISIONING_BUNDLE); 2189 } else { 2190 requiredBundle = imsCarrierConfig.getPersistableBundle( 2191 CarrierConfigManager.Ims.KEY_MMTEL_REQUIRES_PROVISIONING_BUNDLE); 2192 } 2193 2194 requiredBundle.putIntArray(capabilityKey, techs); 2195 } 2196 setDeprecatedCarrierConfig(String key, boolean value)2197 private void setDeprecatedCarrierConfig(String key, boolean value) { 2198 mPersistableBundle0.putBoolean(key, value); 2199 } 2200 getProvisionedValue(int i, int j)2201 private int getProvisionedValue(int i, int j) { 2202 for (int[] data : mMmTelProvisioningStorage) { 2203 if (data[0] == i && data[1] == j) { 2204 return data[2]; 2205 } 2206 } 2207 return 0; 2208 } 2209 getRcsProvisionedValue(int i, int j)2210 private int getRcsProvisionedValue(int i, int j) { 2211 for (int[] data : mRcsProvisioningStorage) { 2212 if (data[0] == i && data[1] == j) { 2213 return data[2]; 2214 } 2215 } 2216 return 0; 2217 } 2218 setProvisionedValue(int i, int j, int k)2219 private boolean setProvisionedValue(int i, int j, int k) { 2220 boolean retVal = false; 2221 for (int[] data : mMmTelProvisioningStorage) { 2222 if (data[0] == i && data[1] == j) { 2223 if (data[2] != k) { 2224 data[2] = k; 2225 return true; 2226 } 2227 return false; 2228 } 2229 } 2230 return retVal; 2231 } 2232 setRcsProvisionedValue(int i, int j, int k)2233 private boolean setRcsProvisionedValue(int i, int j, int k) { 2234 boolean retVal = false; 2235 for (int[] data : mRcsProvisioningStorage) { 2236 if (data[0] == i && data[1] == j) { 2237 if (data[2] != k) { 2238 data[2] = k; 2239 return true; 2240 } 2241 return false; 2242 } 2243 } 2244 return retVal; 2245 } 2246 getImsConfigValue(int i)2247 private int getImsConfigValue(int i) { 2248 for (int[] data : mImsConfigStorage) { 2249 if (data[0] == i) { 2250 return data[1]; 2251 } 2252 } 2253 return -1; 2254 } 2255 setImsConfigValue(int i, int j)2256 private int setImsConfigValue(int i, int j) { 2257 for (int[] data : mImsConfigStorage) { 2258 if (data[0] == i) { 2259 data[1] = j; 2260 return ImsConfig.OperationStatusConstants.SUCCESS; 2261 } 2262 } 2263 return ImsConfig.OperationStatusConstants.SUCCESS; 2264 } 2265 processAllMessages()2266 private void processAllMessages() { 2267 while (!mLooper.getLooper().getQueue().isIdle()) { 2268 mLooper.processAllMessages(); 2269 } 2270 } 2271 logd(String str)2272 private static void logd(String str) { 2273 Log.d(TAG, str); 2274 } 2275 } 2276