1/* 2 * Copyright (C) 2015 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 17package com.android.server.telecom.tests; 18 19import static android.Manifest.permission.CALL_PHONE; 20import static android.Manifest.permission.MODIFY_PHONE_STATE; 21import static android.Manifest.permission.READ_PHONE_STATE; 22import static android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE; 23 24import android.app.AppOpsManager; 25import android.content.ComponentName; 26import android.content.Context; 27import android.content.Intent; 28import android.content.pm.ApplicationInfo; 29import android.content.pm.PackageManager; 30import android.net.Uri; 31import android.os.Binder; 32import android.os.Bundle; 33import android.os.RemoteException; 34import android.os.UserHandle; 35import android.os.UserManager; 36import android.telecom.PhoneAccount; 37import android.telecom.PhoneAccountHandle; 38import android.telecom.TelecomManager; 39import android.telecom.VideoProfile; 40import android.telephony.TelephonyManager; 41import android.test.suitebuilder.annotation.SmallTest; 42 43import com.android.internal.telecom.ITelecomService; 44import com.android.server.telecom.Call; 45import com.android.server.telecom.CallIntentProcessor; 46import com.android.server.telecom.CallState; 47import com.android.server.telecom.CallsManager; 48import com.android.server.telecom.PhoneAccountRegistrar; 49import com.android.server.telecom.TelecomServiceImpl; 50import com.android.server.telecom.TelecomSystem; 51import com.android.server.telecom.components.UserCallIntentProcessor; 52import com.android.server.telecom.components.UserCallIntentProcessorFactory; 53 54import org.mockito.ArgumentCaptor; 55import org.mockito.ArgumentMatcher; 56import org.mockito.Matchers; 57import org.mockito.Mock; 58import org.mockito.internal.matchers.VarargMatcher; 59 60import java.util.ArrayList; 61import java.util.Collection; 62import java.util.List; 63 64import static android.Manifest.permission.REGISTER_SIM_SUBSCRIPTION; 65import static android.Manifest.permission.WRITE_SECURE_SETTINGS; 66import static org.mockito.Matchers.any; 67import static org.mockito.Matchers.anyBoolean; 68import static org.mockito.Matchers.anyInt; 69import static org.mockito.Matchers.anyString; 70import static org.mockito.Matchers.argThat; 71import static org.mockito.Matchers.eq; 72import static org.mockito.Matchers.isNull; 73import static org.mockito.Mockito.doNothing; 74import static org.mockito.Mockito.doReturn; 75import static org.mockito.Mockito.doThrow; 76import static org.mockito.Mockito.mock; 77import static org.mockito.Mockito.never; 78import static org.mockito.Mockito.spy; 79import static org.mockito.Mockito.verify; 80import static org.mockito.Mockito.when; 81 82public class TelecomServiceImplTest extends TelecomTestCase { 83 public static class CallIntentProcessAdapterFake implements CallIntentProcessor.Adapter { 84 @Override 85 public void processOutgoingCallIntent(Context context, CallsManager callsManager, 86 Intent intent) { 87 88 } 89 90 @Override 91 public void processIncomingCallIntent(CallsManager callsManager, Intent intent) { 92 93 } 94 95 @Override 96 public void processUnknownCallIntent(CallsManager callsManager, Intent intent) { 97 98 } 99 } 100 101 public static class DefaultDialerManagerAdapterFake 102 implements TelecomServiceImpl.DefaultDialerManagerAdapter { 103 @Override 104 public String getDefaultDialerApplication(Context context) { 105 return null; 106 } 107 108 @Override 109 public String getDefaultDialerApplication(Context context, int userId) { 110 return null; 111 } 112 113 @Override 114 public boolean setDefaultDialerApplication(Context context, String packageName) { 115 return false; 116 } 117 118 @Override 119 public boolean isDefaultOrSystemDialer(Context context, String packageName) { 120 return false; 121 } 122 } 123 124 public static class SubscriptionManagerAdapterFake 125 implements TelecomServiceImpl.SubscriptionManagerAdapter { 126 @Override 127 public int getDefaultVoiceSubId() { 128 return 0; 129 } 130 } 131 132 private static class AnyStringIn extends ArgumentMatcher<String> { 133 private Collection<String> mStrings; 134 public AnyStringIn(Collection<String> strings) { 135 this.mStrings = strings; 136 } 137 138 @Override 139 public boolean matches(Object string) { 140 return mStrings.contains(string); 141 } 142 } 143 144 private static class IntVarArgMatcher extends ArgumentMatcher<int[]> implements VarargMatcher { 145 @Override 146 public boolean matches(Object argument) { 147 return true; 148 } 149 } 150 151 private ITelecomService.Stub mTSIBinder; 152 private AppOpsManager mAppOpsManager; 153 private UserManager mUserManager; 154 155 @Mock private CallsManager mFakeCallsManager; 156 @Mock private PhoneAccountRegistrar mFakePhoneAccountRegistrar; 157 @Mock private TelecomManager mTelecomManager; 158 private CallIntentProcessor.Adapter mCallIntentProcessorAdapter = 159 spy(new CallIntentProcessAdapterFake()); 160 private TelecomServiceImpl.DefaultDialerManagerAdapter mDefaultDialerManagerAdapter = 161 spy(new DefaultDialerManagerAdapterFake()); 162 private TelecomServiceImpl.SubscriptionManagerAdapter mSubscriptionManagerAdapter = 163 spy(new SubscriptionManagerAdapterFake()); 164 @Mock private UserCallIntentProcessor mUserCallIntentProcessor; 165 166 private final TelecomSystem.SyncRoot mLock = new TelecomSystem.SyncRoot() { }; 167 168 private static final String DEFAULT_DIALER_PACKAGE = "com.google.android.dialer"; 169 private static final UserHandle USER_HANDLE_16 = new UserHandle(16); 170 private static final UserHandle USER_HANDLE_17 = new UserHandle(17); 171 private static final PhoneAccountHandle TEL_PA_HANDLE_16 = new PhoneAccountHandle( 172 new ComponentName("test", "telComponentName"), "0", USER_HANDLE_16); 173 private static final PhoneAccountHandle SIP_PA_HANDLE_17 = new PhoneAccountHandle( 174 new ComponentName("test", "sipComponentName"), "1", USER_HANDLE_17); 175 private static final PhoneAccountHandle TEL_PA_HANDLE_CURRENT = new PhoneAccountHandle( 176 new ComponentName("test", "telComponentName"), "2", Binder.getCallingUserHandle()); 177 private static final PhoneAccountHandle SIP_PA_HANDLE_CURRENT = new PhoneAccountHandle( 178 new ComponentName("test", "sipComponentName"), "3", Binder.getCallingUserHandle()); 179 180 @Override 181 public void setUp() throws Exception { 182 super.setUp(); 183 mContext = mComponentContextFixture.getTestDouble().getApplicationContext(); 184 mComponentContextFixture.putBooleanResource( 185 com.android.internal.R.bool.config_voice_capable, true); 186 187 doReturn(mContext).when(mContext).getApplicationContext(); 188 doNothing().when(mContext).sendBroadcastAsUser(any(Intent.class), any(UserHandle.class), 189 anyString()); 190 TelecomServiceImpl telecomServiceImpl = new TelecomServiceImpl( 191 mContext, 192 mFakeCallsManager, 193 mFakePhoneAccountRegistrar, 194 mCallIntentProcessorAdapter, 195 new UserCallIntentProcessorFactory() { 196 @Override 197 public UserCallIntentProcessor create(Context context, UserHandle userHandle) { 198 return mUserCallIntentProcessor; 199 } 200 }, 201 mDefaultDialerManagerAdapter, 202 mSubscriptionManagerAdapter, 203 mLock); 204 mTSIBinder = telecomServiceImpl.getBinder(); 205 mComponentContextFixture.setTelecomManager(mTelecomManager); 206 when(mTelecomManager.getDefaultDialerPackage()).thenReturn(DEFAULT_DIALER_PACKAGE); 207 when(mTelecomManager.getSystemDialerPackage()).thenReturn(DEFAULT_DIALER_PACKAGE); 208 209 mAppOpsManager = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE); 210 mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE); 211 212 doReturn(DEFAULT_DIALER_PACKAGE) 213 .when(mDefaultDialerManagerAdapter) 214 .getDefaultDialerApplication(any(Context.class)); 215 216 doReturn(true) 217 .when(mDefaultDialerManagerAdapter) 218 .isDefaultOrSystemDialer(any(Context.class), eq(DEFAULT_DIALER_PACKAGE)); 219 } 220 221 @SmallTest 222 public void testGetDefaultOutgoingPhoneAccount() throws RemoteException { 223 when(mFakePhoneAccountRegistrar 224 .getOutgoingPhoneAccountForScheme(eq("tel"), any(UserHandle.class))) 225 .thenReturn(TEL_PA_HANDLE_16); 226 when(mFakePhoneAccountRegistrar 227 .getOutgoingPhoneAccountForScheme(eq("sip"), any(UserHandle.class))) 228 .thenReturn(SIP_PA_HANDLE_17); 229 makeAccountsVisibleToAllUsers(TEL_PA_HANDLE_16, SIP_PA_HANDLE_17); 230 231 PhoneAccountHandle returnedHandleTel 232 = mTSIBinder.getDefaultOutgoingPhoneAccount("tel", DEFAULT_DIALER_PACKAGE); 233 assertEquals(TEL_PA_HANDLE_16, returnedHandleTel); 234 235 PhoneAccountHandle returnedHandleSip 236 = mTSIBinder.getDefaultOutgoingPhoneAccount("sip", DEFAULT_DIALER_PACKAGE); 237 assertEquals(SIP_PA_HANDLE_17, returnedHandleSip); 238 } 239 240 @SmallTest 241 public void testGetDefaultOutgoingPhoneAccountFailure() throws RemoteException { 242 // make sure that the list of user profiles doesn't include anything the PhoneAccountHandles 243 // are associated with 244 245 when(mFakePhoneAccountRegistrar 246 .getOutgoingPhoneAccountForScheme(eq("tel"), any(UserHandle.class))) 247 .thenReturn(TEL_PA_HANDLE_16); 248 when(mFakePhoneAccountRegistrar.getPhoneAccountUnchecked(TEL_PA_HANDLE_16)).thenReturn( 249 makePhoneAccount(TEL_PA_HANDLE_16).build()); 250 when(mAppOpsManager.noteOp(eq(AppOpsManager.OP_READ_PHONE_STATE), anyInt(), anyString())) 251 .thenReturn(AppOpsManager.MODE_IGNORED); 252 doThrow(new SecurityException()).when(mContext) 253 .enforceCallingOrSelfPermission(eq(READ_PRIVILEGED_PHONE_STATE), anyString()); 254 255 PhoneAccountHandle returnedHandleTel 256 = mTSIBinder.getDefaultOutgoingPhoneAccount("tel", ""); 257 assertNull(returnedHandleTel); 258 } 259 260 @SmallTest 261 public void testGetUserSelectedOutgoingPhoneAccount() throws RemoteException { 262 when(mFakePhoneAccountRegistrar.getUserSelectedOutgoingPhoneAccount(any(UserHandle.class))) 263 .thenReturn(TEL_PA_HANDLE_16); 264 when(mFakePhoneAccountRegistrar.getPhoneAccountUnchecked(TEL_PA_HANDLE_16)).thenReturn( 265 makeMultiUserPhoneAccount(TEL_PA_HANDLE_16).build()); 266 267 PhoneAccountHandle returnedHandle 268 = mTSIBinder.getUserSelectedOutgoingPhoneAccount(); 269 assertEquals(TEL_PA_HANDLE_16, returnedHandle); 270 } 271 272 @SmallTest 273 public void testSetUserSelectedOutgoingPhoneAccount() throws RemoteException { 274 mTSIBinder.setUserSelectedOutgoingPhoneAccount(TEL_PA_HANDLE_16); 275 verify(mFakePhoneAccountRegistrar) 276 .setUserSelectedOutgoingPhoneAccount(eq(TEL_PA_HANDLE_16), any(UserHandle.class)); 277 } 278 279 @SmallTest 280 public void testSetUserSelectedOutgoingPhoneAccountFailure() throws RemoteException { 281 doThrow(new SecurityException()).when(mContext).enforceCallingOrSelfPermission( 282 anyString(), anyString()); 283 try { 284 mTSIBinder.setUserSelectedOutgoingPhoneAccount(TEL_PA_HANDLE_16); 285 } catch (SecurityException e) { 286 // desired result 287 } 288 verify(mFakePhoneAccountRegistrar, never()) 289 .setUserSelectedOutgoingPhoneAccount( 290 any(PhoneAccountHandle.class), any(UserHandle.class)); 291 } 292 293 @SmallTest 294 public void testGetCallCapablePhoneAccounts() throws RemoteException { 295 List<PhoneAccountHandle> fullPHList = new ArrayList<PhoneAccountHandle>() {{ 296 add(TEL_PA_HANDLE_16); 297 add(SIP_PA_HANDLE_17); 298 }}; 299 300 List<PhoneAccountHandle> smallPHList = new ArrayList<PhoneAccountHandle>() {{ 301 add(SIP_PA_HANDLE_17); 302 }}; 303 // Returns all phone accounts when getCallCapablePhoneAccounts is called. 304 when(mFakePhoneAccountRegistrar 305 .getCallCapablePhoneAccounts(anyString(), eq(true), any(UserHandle.class))) 306 .thenReturn(fullPHList); 307 // Returns only enabled phone accounts when getCallCapablePhoneAccounts is called. 308 when(mFakePhoneAccountRegistrar 309 .getCallCapablePhoneAccounts(anyString(), eq(false), any(UserHandle.class))) 310 .thenReturn(smallPHList); 311 makeAccountsVisibleToAllUsers(TEL_PA_HANDLE_16, SIP_PA_HANDLE_17); 312 313 assertEquals(fullPHList, 314 mTSIBinder.getCallCapablePhoneAccounts(true, DEFAULT_DIALER_PACKAGE)); 315 assertEquals(smallPHList, 316 mTSIBinder.getCallCapablePhoneAccounts(false, DEFAULT_DIALER_PACKAGE)); 317 } 318 319 @SmallTest 320 public void testGetCallCapablePhoneAccountsFailure() throws RemoteException { 321 List<String> enforcedPermissions = new ArrayList<String>() {{ 322 add(READ_PHONE_STATE); 323 add(READ_PRIVILEGED_PHONE_STATE); 324 }}; 325 doThrow(new SecurityException()).when(mContext).enforceCallingOrSelfPermission( 326 argThat(new AnyStringIn(enforcedPermissions)), anyString()); 327 328 List<PhoneAccountHandle> result = null; 329 try { 330 result = mTSIBinder.getCallCapablePhoneAccounts(true, ""); 331 } catch (SecurityException e) { 332 // intended behavior 333 } 334 assertNull(result); 335 verify(mFakePhoneAccountRegistrar, never()) 336 .getCallCapablePhoneAccounts(anyString(), anyBoolean(), any(UserHandle.class)); 337 } 338 339 @SmallTest 340 public void testGetPhoneAccountsSupportingScheme() throws RemoteException { 341 List<PhoneAccountHandle> sipPHList = new ArrayList<PhoneAccountHandle>() {{ 342 add(SIP_PA_HANDLE_17); 343 }}; 344 345 List<PhoneAccountHandle> telPHList = new ArrayList<PhoneAccountHandle>() {{ 346 add(TEL_PA_HANDLE_16); 347 }}; 348 when(mFakePhoneAccountRegistrar 349 .getCallCapablePhoneAccounts(eq("tel"), anyBoolean(), any(UserHandle.class))) 350 .thenReturn(telPHList); 351 when(mFakePhoneAccountRegistrar 352 .getCallCapablePhoneAccounts(eq("sip"), anyBoolean(), any(UserHandle.class))) 353 .thenReturn(sipPHList); 354 makeAccountsVisibleToAllUsers(TEL_PA_HANDLE_16, SIP_PA_HANDLE_17); 355 356 assertEquals(telPHList, 357 mTSIBinder.getPhoneAccountsSupportingScheme("tel", DEFAULT_DIALER_PACKAGE)); 358 assertEquals(sipPHList, 359 mTSIBinder.getPhoneAccountsSupportingScheme("sip", DEFAULT_DIALER_PACKAGE)); 360 } 361 362 @SmallTest 363 public void testGetPhoneAccountsForPackage() throws RemoteException { 364 List<PhoneAccountHandle> phoneAccountHandleList = new ArrayList<PhoneAccountHandle>() {{ 365 add(TEL_PA_HANDLE_16); 366 add(SIP_PA_HANDLE_17); 367 }}; 368 when(mFakePhoneAccountRegistrar 369 .getPhoneAccountsForPackage(anyString(), any(UserHandle.class))) 370 .thenReturn(phoneAccountHandleList); 371 makeAccountsVisibleToAllUsers(TEL_PA_HANDLE_16, SIP_PA_HANDLE_17); 372 assertEquals(phoneAccountHandleList, 373 mTSIBinder.getPhoneAccountsForPackage( 374 TEL_PA_HANDLE_16.getComponentName().getPackageName())); 375 } 376 377 @SmallTest 378 public void testGetPhoneAccount() throws RemoteException { 379 makeAccountsVisibleToAllUsers(TEL_PA_HANDLE_16, SIP_PA_HANDLE_17); 380 assertEquals(TEL_PA_HANDLE_16, mTSIBinder.getPhoneAccount(TEL_PA_HANDLE_16) 381 .getAccountHandle()); 382 assertEquals(SIP_PA_HANDLE_17, mTSIBinder.getPhoneAccount(SIP_PA_HANDLE_17) 383 .getAccountHandle()); 384 } 385 386 @SmallTest 387 public void testGetAllPhoneAccounts() throws RemoteException { 388 List<PhoneAccount> phoneAccountList = new ArrayList<PhoneAccount>() {{ 389 add(makePhoneAccount(TEL_PA_HANDLE_16).build()); 390 add(makePhoneAccount(SIP_PA_HANDLE_17).build()); 391 }}; 392 when(mFakePhoneAccountRegistrar.getAllPhoneAccounts(any(UserHandle.class))) 393 .thenReturn(phoneAccountList); 394 395 assertEquals(2, mTSIBinder.getAllPhoneAccounts().size()); 396 } 397 398 @SmallTest 399 public void testRegisterPhoneAccount() throws RemoteException { 400 String packageNameToUse = "com.android.officialpackage"; 401 PhoneAccountHandle phHandle = new PhoneAccountHandle(new ComponentName( 402 packageNameToUse, "cs"), "test", Binder.getCallingUserHandle()); 403 PhoneAccount phoneAccount = makePhoneAccount(phHandle).build(); 404 doReturn(PackageManager.PERMISSION_GRANTED) 405 .when(mContext).checkCallingOrSelfPermission(MODIFY_PHONE_STATE); 406 407 registerPhoneAccountTestHelper(phoneAccount, true); 408 } 409 410 @SmallTest 411 public void testRegisterPhoneAccountWithoutModifyPermission() throws RemoteException { 412 // tests the case where the package does not have MODIFY_PHONE_STATE but is 413 // registering its own phone account as a third-party connection service 414 String packageNameToUse = "com.thirdparty.connectionservice"; 415 PhoneAccountHandle phHandle = new PhoneAccountHandle(new ComponentName( 416 packageNameToUse, "cs"), "asdf", Binder.getCallingUserHandle()); 417 PhoneAccount phoneAccount = makePhoneAccount(phHandle).build(); 418 419 doReturn(PackageManager.PERMISSION_DENIED) 420 .when(mContext).checkCallingOrSelfPermission(MODIFY_PHONE_STATE); 421 PackageManager pm = mContext.getPackageManager(); 422 when(pm.hasSystemFeature(PackageManager.FEATURE_CONNECTION_SERVICE)).thenReturn(true); 423 424 registerPhoneAccountTestHelper(phoneAccount, true); 425 } 426 427 @SmallTest 428 public void testRegisterPhoneAccountWithoutModifyPermissionFailure() throws RemoteException { 429 // tests the case where the third party package should not be allowed to register a phone 430 // account due to the lack of modify permission. 431 String packageNameToUse = "com.thirdparty.connectionservice"; 432 PhoneAccountHandle phHandle = new PhoneAccountHandle(new ComponentName( 433 packageNameToUse, "cs"), "asdf", Binder.getCallingUserHandle()); 434 PhoneAccount phoneAccount = makePhoneAccount(phHandle).build(); 435 436 doReturn(PackageManager.PERMISSION_DENIED) 437 .when(mContext).checkCallingOrSelfPermission(MODIFY_PHONE_STATE); 438 PackageManager pm = mContext.getPackageManager(); 439 when(pm.hasSystemFeature(PackageManager.FEATURE_CONNECTION_SERVICE)).thenReturn(false); 440 441 registerPhoneAccountTestHelper(phoneAccount, false); 442 } 443 444 @SmallTest 445 public void testRegisterPhoneAccountWithoutSimSubscriptionPermissionFailure() 446 throws RemoteException { 447 String packageNameToUse = "com.thirdparty.connectionservice"; 448 PhoneAccountHandle phHandle = new PhoneAccountHandle(new ComponentName( 449 packageNameToUse, "cs"), "asdf", Binder.getCallingUserHandle()); 450 PhoneAccount phoneAccount = makePhoneAccount(phHandle) 451 .setCapabilities(PhoneAccount.CAPABILITY_SIM_SUBSCRIPTION).build(); 452 453 doReturn(PackageManager.PERMISSION_GRANTED) 454 .when(mContext).checkCallingOrSelfPermission(MODIFY_PHONE_STATE); 455 doThrow(new SecurityException()) 456 .when(mContext) 457 .enforceCallingOrSelfPermission(eq(REGISTER_SIM_SUBSCRIPTION), anyString()); 458 459 registerPhoneAccountTestHelper(phoneAccount, false); 460 } 461 462 @SmallTest 463 public void testRegisterPhoneAccountWithoutMultiUserPermissionFailure() 464 throws Exception { 465 String packageNameToUse = "com.thirdparty.connectionservice"; 466 PhoneAccountHandle phHandle = new PhoneAccountHandle(new ComponentName( 467 packageNameToUse, "cs"), "asdf", Binder.getCallingUserHandle()); 468 PhoneAccount phoneAccount = makeMultiUserPhoneAccount(phHandle).build(); 469 470 doReturn(PackageManager.PERMISSION_GRANTED) 471 .when(mContext).checkCallingOrSelfPermission(MODIFY_PHONE_STATE); 472 473 PackageManager packageManager = mContext.getPackageManager(); 474 when(packageManager.getApplicationInfo(packageNameToUse, PackageManager.GET_META_DATA)) 475 .thenReturn(new ApplicationInfo()); 476 477 registerPhoneAccountTestHelper(phoneAccount, false); 478 } 479 480 private void registerPhoneAccountTestHelper(PhoneAccount testPhoneAccount, 481 boolean shouldSucceed) throws RemoteException { 482 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 483 boolean didExceptionOccur = false; 484 try { 485 mTSIBinder.registerPhoneAccount(testPhoneAccount); 486 } catch (Exception e) { 487 didExceptionOccur = true; 488 } 489 490 if (shouldSucceed) { 491 assertFalse(didExceptionOccur); 492 verify(mFakePhoneAccountRegistrar).registerPhoneAccount(testPhoneAccount); 493 verify(mContext).sendBroadcastAsUser(intentCaptor.capture(), eq(UserHandle.ALL), 494 anyString()); 495 496 Intent capturedIntent = intentCaptor.getValue(); 497 assertEquals(TelecomManager.ACTION_PHONE_ACCOUNT_REGISTERED, 498 capturedIntent.getAction()); 499 Bundle intentExtras = capturedIntent.getExtras(); 500 assertEquals(1, intentExtras.size()); 501 assertEquals(testPhoneAccount.getAccountHandle(), 502 intentExtras.get(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE)); 503 } else { 504 assertTrue(didExceptionOccur); 505 verify(mFakePhoneAccountRegistrar, never()) 506 .registerPhoneAccount(any(PhoneAccount.class)); 507 verify(mContext, never()) 508 .sendBroadcastAsUser(any(Intent.class), any(UserHandle.class), anyString()); 509 } 510 } 511 512 @SmallTest 513 public void testUnregisterPhoneAccount() throws RemoteException { 514 String packageNameToUse = "com.android.officialpackage"; 515 PhoneAccountHandle phHandle = new PhoneAccountHandle(new ComponentName( 516 packageNameToUse, "cs"), "test", Binder.getCallingUserHandle()); 517 518 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 519 doReturn(PackageManager.PERMISSION_GRANTED) 520 .when(mContext).checkCallingOrSelfPermission(MODIFY_PHONE_STATE); 521 522 mTSIBinder.unregisterPhoneAccount(phHandle); 523 verify(mFakePhoneAccountRegistrar).unregisterPhoneAccount(phHandle); 524 verify(mContext).sendBroadcastAsUser(intentCaptor.capture(), eq(UserHandle.ALL), 525 anyString()); 526 Intent capturedIntent = intentCaptor.getValue(); 527 assertEquals(TelecomManager.ACTION_PHONE_ACCOUNT_UNREGISTERED, 528 capturedIntent.getAction()); 529 Bundle intentExtras = capturedIntent.getExtras(); 530 assertEquals(1, intentExtras.size()); 531 assertEquals(phHandle, intentExtras.get(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE)); 532 } 533 534 @SmallTest 535 public void testUnregisterPhoneAccountFailure() throws RemoteException { 536 String packageNameToUse = "com.thirdparty.connectionservice"; 537 PhoneAccountHandle phHandle = new PhoneAccountHandle(new ComponentName( 538 packageNameToUse, "cs"), "asdf", Binder.getCallingUserHandle()); 539 540 doReturn(PackageManager.PERMISSION_DENIED) 541 .when(mContext).checkCallingOrSelfPermission(MODIFY_PHONE_STATE); 542 PackageManager pm = mContext.getPackageManager(); 543 when(pm.hasSystemFeature(PackageManager.FEATURE_CONNECTION_SERVICE)).thenReturn(false); 544 545 try { 546 mTSIBinder.unregisterPhoneAccount(phHandle); 547 } catch (UnsupportedOperationException e) { 548 // expected behavior 549 } 550 verify(mFakePhoneAccountRegistrar, never()) 551 .unregisterPhoneAccount(any(PhoneAccountHandle.class)); 552 verify(mContext, never()) 553 .sendBroadcastAsUser(any(Intent.class), any(UserHandle.class), anyString()); 554 } 555 556 @SmallTest 557 public void testAddNewIncomingCall() throws Exception { 558 PhoneAccount phoneAccount = makePhoneAccount(TEL_PA_HANDLE_CURRENT).build(); 559 phoneAccount.setIsEnabled(true); 560 doReturn(phoneAccount).when(mFakePhoneAccountRegistrar).getPhoneAccount( 561 eq(TEL_PA_HANDLE_CURRENT), any(UserHandle.class)); 562 doNothing().when(mAppOpsManager).checkPackage(anyInt(), anyString()); 563 Bundle extras = createSampleExtras(); 564 565 mTSIBinder.addNewIncomingCall(TEL_PA_HANDLE_CURRENT, extras); 566 567 addCallTestHelper(TelecomManager.ACTION_INCOMING_CALL, 568 CallIntentProcessor.KEY_IS_INCOMING_CALL, extras, false); 569 } 570 571 @SmallTest 572 public void testAddNewIncomingCallFailure() throws Exception { 573 try { 574 mTSIBinder.addNewIncomingCall(TEL_PA_HANDLE_16, null); 575 } catch (SecurityException e) { 576 // expected 577 } 578 579 doThrow(new SecurityException()).when(mAppOpsManager).checkPackage(anyInt(), anyString()); 580 581 try { 582 mTSIBinder.addNewIncomingCall(TEL_PA_HANDLE_CURRENT, null); 583 } catch (SecurityException e) { 584 // expected 585 } 586 587 // Verify that neither of these attempts got through 588 verify(mCallIntentProcessorAdapter, never()) 589 .processIncomingCallIntent(any(CallsManager.class), any(Intent.class)); 590 } 591 592 @SmallTest 593 public void testAddNewUnknownCall() throws Exception { 594 PhoneAccount phoneAccount = makePhoneAccount(TEL_PA_HANDLE_CURRENT).build(); 595 phoneAccount.setIsEnabled(true); 596 doReturn(phoneAccount).when(mFakePhoneAccountRegistrar).getPhoneAccount( 597 eq(TEL_PA_HANDLE_CURRENT), any(UserHandle.class)); 598 doNothing().when(mAppOpsManager).checkPackage(anyInt(), anyString()); 599 Bundle extras = createSampleExtras(); 600 601 mTSIBinder.addNewUnknownCall(TEL_PA_HANDLE_CURRENT, extras); 602 603 addCallTestHelper(TelecomManager.ACTION_NEW_UNKNOWN_CALL, 604 CallIntentProcessor.KEY_IS_UNKNOWN_CALL, extras, true); 605 } 606 607 @SmallTest 608 public void testAddNewUnknownCallFailure() throws Exception { 609 try { 610 mTSIBinder.addNewUnknownCall(TEL_PA_HANDLE_16, null); 611 } catch (SecurityException e) { 612 // expected 613 } 614 615 doThrow(new SecurityException()).when(mAppOpsManager).checkPackage(anyInt(), anyString()); 616 617 try { 618 mTSIBinder.addNewUnknownCall(TEL_PA_HANDLE_CURRENT, null); 619 } catch (SecurityException e) { 620 // expected 621 } 622 623 // Verify that neither of these attempts got through 624 verify(mCallIntentProcessorAdapter, never()) 625 .processIncomingCallIntent(any(CallsManager.class), any(Intent.class)); 626 } 627 628 private void addCallTestHelper(String expectedAction, String extraCallKey, 629 Bundle expectedExtras, boolean isUnknown) { 630 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 631 if (isUnknown) { 632 verify(mCallIntentProcessorAdapter).processUnknownCallIntent(any(CallsManager.class), 633 intentCaptor.capture()); 634 } else { 635 verify(mCallIntentProcessorAdapter).processIncomingCallIntent(any(CallsManager.class), 636 intentCaptor.capture()); 637 } 638 Intent capturedIntent = intentCaptor.getValue(); 639 assertEquals(expectedAction, capturedIntent.getAction()); 640 Bundle intentExtras = capturedIntent.getExtras(); 641 assertEquals(TEL_PA_HANDLE_CURRENT, 642 intentExtras.get(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE)); 643 assertTrue(intentExtras.getBoolean(extraCallKey)); 644 645 if (isUnknown) { 646 for (String expectedKey : expectedExtras.keySet()) { 647 assertTrue(intentExtras.containsKey(expectedKey)); 648 assertEquals(expectedExtras.get(expectedKey), intentExtras.get(expectedKey)); 649 } 650 } 651 else { 652 assertTrue(areBundlesEqual(expectedExtras, 653 (Bundle) intentExtras.get(TelecomManager.EXTRA_INCOMING_CALL_EXTRAS))); 654 } 655 } 656 657 @SmallTest 658 public void testPlaceCallWithNonEmergencyPermission() throws Exception { 659 Uri handle = Uri.parse("tel:6505551234"); 660 Bundle extras = createSampleExtras(); 661 662 when(mAppOpsManager.noteOp(eq(AppOpsManager.OP_CALL_PHONE), anyInt(), anyString())) 663 .thenReturn(AppOpsManager.MODE_ALLOWED); 664 doReturn(PackageManager.PERMISSION_GRANTED) 665 .when(mContext).checkCallingPermission(CALL_PHONE); 666 667 mTSIBinder.placeCall(handle, extras, DEFAULT_DIALER_PACKAGE); 668 placeCallTestHelper(handle, extras, true); 669 } 670 671 @SmallTest 672 public void testPlaceCallWithAppOpsOff() throws Exception { 673 Uri handle = Uri.parse("tel:6505551234"); 674 Bundle extras = createSampleExtras(); 675 676 when(mAppOpsManager.noteOp(eq(AppOpsManager.OP_CALL_PHONE), anyInt(), anyString())) 677 .thenReturn(AppOpsManager.MODE_IGNORED); 678 doReturn(PackageManager.PERMISSION_GRANTED) 679 .when(mContext).checkCallingPermission(CALL_PHONE); 680 681 mTSIBinder.placeCall(handle, extras, DEFAULT_DIALER_PACKAGE); 682 placeCallTestHelper(handle, extras, false); 683 } 684 685 @SmallTest 686 public void testPlaceCallWithNoCallingPermission() throws Exception { 687 Uri handle = Uri.parse("tel:6505551234"); 688 Bundle extras = createSampleExtras(); 689 690 when(mAppOpsManager.noteOp(eq(AppOpsManager.OP_CALL_PHONE), anyInt(), anyString())) 691 .thenReturn(AppOpsManager.MODE_ALLOWED); 692 doReturn(PackageManager.PERMISSION_DENIED) 693 .when(mContext).checkCallingPermission(CALL_PHONE); 694 695 mTSIBinder.placeCall(handle, extras, DEFAULT_DIALER_PACKAGE); 696 placeCallTestHelper(handle, extras, false); 697 } 698 699 private void placeCallTestHelper(Uri expectedHandle, Bundle expectedExtras, 700 boolean shouldNonEmergencyBeAllowed) { 701 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 702 verify(mUserCallIntentProcessor).processIntent(intentCaptor.capture(), anyString(), 703 eq(shouldNonEmergencyBeAllowed)); 704 Intent capturedIntent = intentCaptor.getValue(); 705 assertEquals(Intent.ACTION_CALL, capturedIntent.getAction()); 706 assertEquals(expectedHandle, capturedIntent.getData()); 707 assertTrue(areBundlesEqual(expectedExtras, capturedIntent.getExtras())); 708 } 709 710 @SmallTest 711 public void testPlaceCallFailure() throws Exception { 712 Uri handle = Uri.parse("tel:6505551234"); 713 Bundle extras = createSampleExtras(); 714 715 doThrow(new SecurityException()) 716 .when(mContext).enforceCallingOrSelfPermission(eq(CALL_PHONE), anyString()); 717 718 try { 719 mTSIBinder.placeCall(handle, extras, "arbitrary_package_name"); 720 } catch (SecurityException e) { 721 // expected 722 } 723 724 verify(mUserCallIntentProcessor, never()) 725 .processIntent(any(Intent.class), anyString(), anyBoolean()); 726 } 727 728 @SmallTest 729 public void testSetDefaultDialer() throws Exception { 730 String packageName = "sample.package"; 731 732 doReturn(true) 733 .when(mDefaultDialerManagerAdapter) 734 .setDefaultDialerApplication(any(Context.class), eq(packageName)); 735 736 mTSIBinder.setDefaultDialer(packageName); 737 738 verify(mDefaultDialerManagerAdapter).setDefaultDialerApplication(any(Context.class), 739 eq(packageName)); 740 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 741 verify(mContext).sendBroadcastAsUser(intentCaptor.capture(), any(UserHandle.class)); 742 Intent capturedIntent = intentCaptor.getValue(); 743 assertEquals(TelecomManager.ACTION_DEFAULT_DIALER_CHANGED, capturedIntent.getAction()); 744 String packageNameExtra = capturedIntent.getStringExtra( 745 TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME); 746 assertEquals(packageName, packageNameExtra); 747 } 748 749 @SmallTest 750 public void testSetDefaultDialerNoModifyPhoneStatePermission() throws Exception { 751 doThrow(new SecurityException()).when(mContext).enforceCallingOrSelfPermission( 752 eq(MODIFY_PHONE_STATE), anyString()); 753 setDefaultDialerFailureTestHelper(); 754 } 755 756 @SmallTest 757 public void testSetDefaultDialerNoWriteSecureSettingsPermission() throws Exception { 758 doThrow(new SecurityException()).when(mContext).enforceCallingOrSelfPermission( 759 eq(WRITE_SECURE_SETTINGS), anyString()); 760 setDefaultDialerFailureTestHelper(); 761 } 762 763 private void setDefaultDialerFailureTestHelper() throws Exception { 764 boolean exceptionThrown = false; 765 try { 766 mTSIBinder.setDefaultDialer(DEFAULT_DIALER_PACKAGE); 767 } catch (SecurityException e) { 768 exceptionThrown = true; 769 } 770 assertTrue(exceptionThrown); 771 verify(mDefaultDialerManagerAdapter, never()).setDefaultDialerApplication( 772 any(Context.class), anyString()); 773 verify(mContext, never()).sendBroadcastAsUser(any(Intent.class), any(UserHandle.class)); 774 } 775 776 @SmallTest 777 public void testIsVoicemailNumber() throws Exception { 778 String vmNumber = "010"; 779 makeAccountsVisibleToAllUsers(TEL_PA_HANDLE_CURRENT); 780 781 doReturn(true).when(mFakePhoneAccountRegistrar).isVoiceMailNumber(TEL_PA_HANDLE_CURRENT, 782 vmNumber); 783 assertTrue(mTSIBinder.isVoiceMailNumber(TEL_PA_HANDLE_CURRENT, 784 vmNumber, DEFAULT_DIALER_PACKAGE)); 785 } 786 787 @SmallTest 788 public void testIsVoicemailNumberAccountNotVisibleFailure() throws Exception { 789 String vmNumber = "010"; 790 791 doReturn(true).when(mFakePhoneAccountRegistrar).isVoiceMailNumber(TEL_PA_HANDLE_CURRENT, 792 vmNumber); 793 794 when(mFakePhoneAccountRegistrar.getPhoneAccount(TEL_PA_HANDLE_CURRENT, 795 Binder.getCallingUserHandle())).thenReturn(null); 796 assertFalse(mTSIBinder 797 .isVoiceMailNumber(TEL_PA_HANDLE_CURRENT, vmNumber, DEFAULT_DIALER_PACKAGE)); 798 } 799 800 @SmallTest 801 public void testGetVoicemailNumberWithNullAccountHandle() throws Exception { 802 when(mFakePhoneAccountRegistrar.getPhoneAccount(isNull(PhoneAccountHandle.class), 803 eq(Binder.getCallingUserHandle()))) 804 .thenReturn(makePhoneAccount(TEL_PA_HANDLE_CURRENT).build()); 805 int subId = 58374; 806 String vmNumber = "543"; 807 doReturn(subId).when(mSubscriptionManagerAdapter).getDefaultVoiceSubId(); 808 809 TelephonyManager mockTelephonyManager = 810 (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); 811 when(mockTelephonyManager.getVoiceMailNumber(subId)).thenReturn(vmNumber); 812 813 assertEquals(vmNumber, mTSIBinder.getVoiceMailNumber(null, DEFAULT_DIALER_PACKAGE)); 814 } 815 816 @SmallTest 817 public void testGetVoicemailNumberWithNonNullAccountHandle() throws Exception { 818 when(mFakePhoneAccountRegistrar.getPhoneAccount(eq(TEL_PA_HANDLE_CURRENT), 819 eq(Binder.getCallingUserHandle()))) 820 .thenReturn(makePhoneAccount(TEL_PA_HANDLE_CURRENT).build()); 821 int subId = 58374; 822 String vmNumber = "543"; 823 824 TelephonyManager mockTelephonyManager = 825 (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); 826 when(mockTelephonyManager.getVoiceMailNumber(subId)).thenReturn(vmNumber); 827 when(mFakePhoneAccountRegistrar.getSubscriptionIdForPhoneAccount(TEL_PA_HANDLE_CURRENT)) 828 .thenReturn(subId); 829 830 assertEquals(vmNumber, 831 mTSIBinder.getVoiceMailNumber(TEL_PA_HANDLE_CURRENT, DEFAULT_DIALER_PACKAGE)); 832 } 833 834 @SmallTest 835 public void testGetLine1Number() throws Exception { 836 int subId = 58374; 837 String line1Number = "9482752023479"; 838 makeAccountsVisibleToAllUsers(TEL_PA_HANDLE_CURRENT); 839 when(mFakePhoneAccountRegistrar.getSubscriptionIdForPhoneAccount(TEL_PA_HANDLE_CURRENT)) 840 .thenReturn(subId); 841 TelephonyManager mockTelephonyManager = 842 (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); 843 when(mockTelephonyManager.getLine1Number(subId)).thenReturn(line1Number); 844 845 assertEquals(line1Number, 846 mTSIBinder.getLine1Number(TEL_PA_HANDLE_CURRENT, DEFAULT_DIALER_PACKAGE)); 847 } 848 849 @SmallTest 850 public void testEndCallWithRingingForegroundCall() throws Exception { 851 Call call = mock(Call.class); 852 when(call.getState()).thenReturn(CallState.RINGING); 853 when(mFakeCallsManager.getForegroundCall()).thenReturn(call); 854 assertTrue(mTSIBinder.endCall()); 855 verify(call).reject(false, null); 856 } 857 858 @SmallTest 859 public void testEndCallWithNonRingingForegroundCall() throws Exception { 860 Call call = mock(Call.class); 861 when(call.getState()).thenReturn(CallState.ACTIVE); 862 when(mFakeCallsManager.getForegroundCall()).thenReturn(call); 863 assertTrue(mTSIBinder.endCall()); 864 verify(call).disconnect(); 865 } 866 867 @SmallTest 868 public void testEndCallWithNoForegroundCall() throws Exception { 869 Call call = mock(Call.class); 870 when(call.getState()).thenReturn(CallState.ACTIVE); 871 when(mFakeCallsManager.getFirstCallWithState(argThat(new IntVarArgMatcher()))) 872 .thenReturn(call); 873 assertTrue(mTSIBinder.endCall()); 874 verify(call).disconnect(); 875 } 876 877 @SmallTest 878 public void testEndCallWithNoCalls() throws Exception { 879 assertFalse(mTSIBinder.endCall()); 880 } 881 882 @SmallTest 883 public void testAcceptRingingCall() throws Exception { 884 Call call = mock(Call.class); 885 when(mFakeCallsManager.getFirstCallWithState(any(int[].class))) 886 .thenReturn(call); 887 // Not intended to be a real video state. Here to ensure that the call will be answered 888 // with whatever video state it's currently in. 889 int fakeVideoState = 29578215; 890 when(call.getVideoState()).thenReturn(fakeVideoState); 891 mTSIBinder.acceptRingingCall(); 892 verify(call).answer(fakeVideoState); 893 } 894 895 @SmallTest 896 public void testAcceptRingingCallWithValidVideoState() throws Exception { 897 Call call = mock(Call.class); 898 when(mFakeCallsManager.getFirstCallWithState(any(int[].class))) 899 .thenReturn(call); 900 // Not intended to be a real video state. Here to ensure that the call will be answered 901 // with the video state passed in to acceptRingingCallWithVideoState 902 int fakeVideoState = 29578215; 903 int realVideoState = VideoProfile.STATE_RX_ENABLED | VideoProfile.STATE_TX_ENABLED; 904 when(call.getVideoState()).thenReturn(fakeVideoState); 905 mTSIBinder.acceptRingingCallWithVideoState(realVideoState); 906 verify(call).answer(realVideoState); 907 } 908 909 /** 910 * Register phone accounts for the supplied PhoneAccountHandles to make them 911 * visible to all users (via the isVisibleToCaller method in TelecomServiceImpl. 912 * @param handles the handles for which phone accounts should be created for. 913 */ 914 private void makeAccountsVisibleToAllUsers(PhoneAccountHandle... handles) { 915 for (PhoneAccountHandle ph : handles) { 916 when(mFakePhoneAccountRegistrar.getPhoneAccountUnchecked(eq(ph))).thenReturn( 917 makeMultiUserPhoneAccount(ph).build()); 918 when(mFakePhoneAccountRegistrar 919 .getPhoneAccount(eq(ph), any(UserHandle.class), anyBoolean())) 920 .thenReturn(makeMultiUserPhoneAccount(ph).build()); 921 when(mFakePhoneAccountRegistrar 922 .getPhoneAccount(eq(ph), any(UserHandle.class))) 923 .thenReturn(makeMultiUserPhoneAccount(ph).build()); 924 } 925 } 926 927 private PhoneAccount.Builder makeMultiUserPhoneAccount(PhoneAccountHandle paHandle) { 928 PhoneAccount.Builder paBuilder = makePhoneAccount(paHandle); 929 paBuilder.setCapabilities(PhoneAccount.CAPABILITY_MULTI_USER); 930 return paBuilder; 931 } 932 933 private PhoneAccount.Builder makePhoneAccount(PhoneAccountHandle paHandle) { 934 return new PhoneAccount.Builder(paHandle, "testLabel"); 935 } 936 937 private Bundle createSampleExtras() { 938 Bundle extras = new Bundle(); 939 extras.putString("test_key", "test_value"); 940 return extras; 941 } 942 943 private static boolean areBundlesEqual(Bundle b1, Bundle b2) { 944 for (String key1 : b1.keySet()) { 945 if (!b1.get(key1).equals(b2.get(key1))) { 946 return false; 947 } 948 } 949 950 for (String key2 : b2.keySet()) { 951 if (!b2.get(key2).equals(b1.get(key2))) { 952 return false; 953 } 954 } 955 return true; 956 } 957} 958