1 /* 2 * Copyright (C) 2014 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.cts.devicepolicy; 18 19 import com.android.ddmlib.Log.LogLevel; 20 import com.android.tradefed.device.DeviceNotAvailableException; 21 import com.android.tradefed.log.LogUtil.CLog; 22 23 import junit.framework.AssertionFailedError; 24 25 import java.util.concurrent.Callable; 26 import java.util.concurrent.TimeUnit; 27 import java.util.regex.Matcher; 28 import java.util.regex.Pattern; 29 30 /** 31 * Set of tests for Managed Profile use cases. 32 */ 33 public class ManagedProfileTest extends BaseDevicePolicyTest { 34 35 private static final String MANAGED_PROFILE_PKG = "com.android.cts.managedprofile"; 36 private static final String MANAGED_PROFILE_APK = "CtsManagedProfileApp.apk"; 37 38 private static final String DEVICE_OWNER_PKG = "com.android.cts.deviceowner"; 39 private static final String DEVICE_OWNER_APK = "CtsDeviceOwnerApp.apk"; 40 private static final String DEVICE_OWNER_ADMIN = 41 DEVICE_OWNER_PKG + ".BaseDeviceOwnerTest$BasicAdminReceiver"; 42 43 private static final String INTENT_SENDER_PKG = "com.android.cts.intent.sender"; 44 private static final String INTENT_SENDER_APK = "CtsIntentSenderApp.apk"; 45 46 private static final String INTENT_RECEIVER_PKG = "com.android.cts.intent.receiver"; 47 private static final String INTENT_RECEIVER_APK = "CtsIntentReceiverApp.apk"; 48 49 private static final String WIFI_CONFIG_CREATOR_PKG = "com.android.cts.wificonfigcreator"; 50 private static final String WIFI_CONFIG_CREATOR_APK = "CtsWifiConfigCreator.apk"; 51 52 private static final String WIDGET_PROVIDER_APK = "CtsWidgetProviderApp.apk"; 53 private static final String WIDGET_PROVIDER_PKG = "com.android.cts.widgetprovider"; 54 55 private static final String DIRECTORY_PROVIDER_APK = "CtsContactDirectoryProvider.apk"; 56 private static final String DIRECTORY_PROVIDER_PKG 57 = "com.android.cts.contactdirectoryprovider"; 58 private static final String PRIMARY_DIRECTORY_PREFIX = "Primary"; 59 private static final String MANAGED_DIRECTORY_PREFIX = "Managed"; 60 private static final String DIRECTORY_PRIVOIDER_URI 61 = "content://com.android.cts.contact.directory.provider/"; 62 private static final String SET_CUSTOM_DIRECTORY_PREFIX_METHOD = "set_prefix"; 63 64 private static final String ADMIN_RECEIVER_TEST_CLASS = 65 MANAGED_PROFILE_PKG + ".BaseManagedProfileTest$BasicAdminReceiver"; 66 67 private static final String FEATURE_BLUETOOTH = "android.hardware.bluetooth"; 68 private static final String FEATURE_CAMERA = "android.hardware.camera"; 69 private static final String FEATURE_WIFI = "android.hardware.wifi"; 70 private static final String FEATURE_TELEPHONY = "android.hardware.telephony"; 71 private static final String FEATURE_CONNECTION_SERVICE = "android.software.connectionservice"; 72 73 private static final String SIMPLE_APP_APK = "CtsSimpleApp.apk"; 74 private static final String SIMPLE_APP_PKG = "com.android.cts.launcherapps.simpleapp"; 75 76 private static final long TIMEOUT_USER_LOCKED_MILLIS = TimeUnit.SECONDS.toMillis(15); 77 78 private int mParentUserId; 79 80 // ID of the profile we'll create. This will always be a profile of the parent. 81 private int mProfileUserId; 82 private String mPackageVerifier; 83 84 private boolean mHasNfcFeature; 85 86 @Override 87 protected void setUp() throws Exception { 88 super.setUp(); 89 90 // We need multi user to be supported in order to create a profile of the user owner. 91 mHasFeature = mHasFeature && hasDeviceFeature( 92 "android.software.managed_users"); 93 mHasNfcFeature = hasDeviceFeature("android.hardware.nfc"); 94 95 if (mHasFeature) { 96 removeTestUsers(); 97 mParentUserId = mPrimaryUserId; 98 mProfileUserId = createManagedProfile(mParentUserId); 99 100 installAppAsUser(MANAGED_PROFILE_APK, mParentUserId); 101 installAppAsUser(MANAGED_PROFILE_APK, mProfileUserId); 102 setProfileOwnerOrFail(MANAGED_PROFILE_PKG + "/" + ADMIN_RECEIVER_TEST_CLASS, 103 mProfileUserId); 104 startUser(mProfileUserId); 105 } 106 } 107 108 @Override 109 protected void tearDown() throws Exception { 110 if (mHasFeature) { 111 removeUser(mProfileUserId); 112 getDevice().uninstallPackage(MANAGED_PROFILE_PKG); 113 getDevice().uninstallPackage(INTENT_SENDER_PKG); 114 getDevice().uninstallPackage(INTENT_RECEIVER_PKG); 115 } 116 super.tearDown(); 117 } 118 119 public void testManagedProfileSetup() throws Exception { 120 if (!mHasFeature) { 121 return; 122 } 123 runDeviceTestsAsUser( 124 MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".ManagedProfileSetupTest", 125 mProfileUserId); 126 } 127 128 /** 129 * wipeData() test removes the managed profile, so it needs to separated from other tests. 130 */ 131 public void testWipeData() throws Exception { 132 if (!mHasFeature) { 133 return; 134 } 135 assertTrue(listUsers().contains(mProfileUserId)); 136 runDeviceTestsAsUser( 137 MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".WipeDataTest", mProfileUserId); 138 // Note: the managed profile is removed by this test, which will make removeUserCommand in 139 // tearDown() to complain, but that should be OK since its result is not asserted. 140 assertUserGetsRemoved(mProfileUserId); 141 } 142 143 public void testLockNowWithKeyEviction() throws Exception { 144 if (!mHasFeature || !mSupportsFbe) { 145 return; 146 } 147 changeUserCredential("1234", null, mProfileUserId); 148 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".LockNowTest", 149 "testLockNowWithKeyEviction", mProfileUserId); 150 final String cmd = "dumpsys activity | grep 'User #" + mProfileUserId + ": state='"; 151 final Pattern p = Pattern.compile("state=([\\p{Upper}_]+)$"); 152 SuccessCondition userLocked = () -> { 153 final String activityDump = getDevice().executeShellCommand(cmd); 154 final Matcher m = p.matcher(activityDump); 155 return m.find() && m.group(1).equals("RUNNING_LOCKED"); 156 }; 157 tryWaitForSuccess( 158 userLocked, 159 "The managed profile has not been locked after calling " 160 + "lockNow(FLAG_SECURE_USER_DATA)", 161 TIMEOUT_USER_LOCKED_MILLIS); 162 } 163 164 public void testMaxOneManagedProfile() throws Exception { 165 int newUserId = -1; 166 try { 167 newUserId = createManagedProfile(mParentUserId); 168 } catch (AssertionFailedError expected) { 169 } 170 if (newUserId > 0) { 171 removeUser(newUserId); 172 fail(mHasFeature ? "Device must allow creating only one managed profile" 173 : "Device must not allow creating a managed profile"); 174 } 175 } 176 177 /** 178 * Verify that removing a managed profile will remove all networks owned by that profile. 179 */ 180 public void testProfileWifiCleanup() throws Exception { 181 if (!mHasFeature || !hasDeviceFeature(FEATURE_WIFI)) { 182 return; 183 } 184 installAppAsUser(WIFI_CONFIG_CREATOR_APK, mProfileUserId); 185 186 runDeviceTestsAsUser( 187 MANAGED_PROFILE_PKG, ".WifiTest", "testRemoveWifiNetworkIfExists", mParentUserId); 188 189 runDeviceTestsAsUser( 190 MANAGED_PROFILE_PKG, ".WifiTest", "testAddWifiNetwork", mProfileUserId); 191 192 // Now delete the user - should undo the effect of testAddWifiNetwork. 193 removeUser(mProfileUserId); 194 runDeviceTestsAsUser( 195 MANAGED_PROFILE_PKG, ".WifiTest", "testWifiNetworkDoesNotExist", 196 mParentUserId); 197 } 198 199 public void testWifiMacAddress() throws Exception { 200 if (!mHasFeature || !hasDeviceFeature(FEATURE_WIFI)) { 201 return; 202 } 203 runDeviceTestsAsUser( 204 MANAGED_PROFILE_PKG, ".WifiTest", "testCannotGetWifiMacAddress", mProfileUserId); 205 } 206 207 public void testCrossProfileIntentFilters() throws Exception { 208 if (!mHasFeature) { 209 return; 210 } 211 // Set up activities: ManagedProfileActivity will only be enabled in the managed profile and 212 // PrimaryUserActivity only in the primary one 213 disableActivityForUser("ManagedProfileActivity", mParentUserId); 214 disableActivityForUser("PrimaryUserActivity", mProfileUserId); 215 216 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, 217 MANAGED_PROFILE_PKG + ".ManagedProfileTest", mProfileUserId); 218 219 // Set up filters from primary to managed profile 220 String command = "am start -W --user " + mProfileUserId + " " + MANAGED_PROFILE_PKG 221 + "/.PrimaryUserFilterSetterActivity"; 222 CLog.d("Output for command " + command + ": " 223 + getDevice().executeShellCommand(command)); 224 runDeviceTestsAsUser( 225 MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".PrimaryUserTest", mParentUserId); 226 // TODO: Test with startActivity 227 } 228 229 public void testAppLinks_verificationStatus() throws Exception { 230 if (!mHasFeature) { 231 return; 232 } 233 // Disable all pre-existing browsers in the managed profile so they don't interfere with 234 // intents resolution. 235 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 236 "testDisableAllBrowsers", mProfileUserId); 237 installAppAsUser(INTENT_RECEIVER_APK, mParentUserId); 238 installAppAsUser(INTENT_SENDER_APK, mParentUserId); 239 installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId); 240 installAppAsUser(INTENT_SENDER_APK, mProfileUserId); 241 242 changeVerificationStatus(mParentUserId, INTENT_RECEIVER_PKG, "ask"); 243 changeVerificationStatus(mProfileUserId, INTENT_RECEIVER_PKG, "ask"); 244 // We should have two receivers: IntentReceiverActivity and BrowserActivity in the 245 // managed profile 246 assertAppLinkResult("testTwoReceivers"); 247 248 changeUserRestrictionOrFail("allow_parent_profile_app_linking", true, mProfileUserId); 249 // Now we should also have one receiver in the primary user, so three receivers in total. 250 assertAppLinkResult("testThreeReceivers"); 251 252 changeVerificationStatus(mParentUserId, INTENT_RECEIVER_PKG, "never"); 253 // The primary user one has been set to never: we should only have the managed profile ones. 254 assertAppLinkResult("testTwoReceivers"); 255 256 changeVerificationStatus(mProfileUserId, INTENT_RECEIVER_PKG, "never"); 257 // Now there's only the browser in the managed profile left 258 assertAppLinkResult("testReceivedByBrowserActivityInManaged"); 259 260 changeVerificationStatus(mProfileUserId, INTENT_RECEIVER_PKG, "always"); 261 changeVerificationStatus(mParentUserId, INTENT_RECEIVER_PKG, "always"); 262 // We have one always in the primary user and one always in the managed profile: the managed 263 // profile one should have precedence. 264 assertAppLinkResult("testReceivedByAppLinkActivityInManaged"); 265 } 266 267 public void testAppLinks_enabledStatus() throws Exception { 268 if (!mHasFeature) { 269 return; 270 } 271 // Disable all pre-existing browsers in the managed profile so they don't interfere with 272 // intents resolution. 273 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 274 "testDisableAllBrowsers", mProfileUserId); 275 installAppAsUser(INTENT_RECEIVER_APK, mParentUserId); 276 installAppAsUser(INTENT_SENDER_APK, mParentUserId); 277 installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId); 278 installAppAsUser(INTENT_SENDER_APK, mProfileUserId); 279 280 final String APP_HANDLER_COMPONENT = "com.android.cts.intent.receiver/.AppLinkActivity"; 281 282 // allow_parent_profile_app_linking is not set, try different enabled state combinations. 283 // We should not have app link handler in parent user no matter whether it is enabled. 284 285 disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT); 286 disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT); 287 assertAppLinkResult("testReceivedByBrowserActivityInManaged"); 288 289 enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT); 290 disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT); 291 assertAppLinkResult("testReceivedByBrowserActivityInManaged"); 292 293 disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT); 294 enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT); 295 assertAppLinkResult("testTwoReceivers"); 296 297 enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT); 298 enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT); 299 assertAppLinkResult("testTwoReceivers"); 300 301 // We now set allow_parent_profile_app_linking, and hence we should have the app handler 302 // in parent user if it is enabled. 303 changeUserRestrictionOrFail("allow_parent_profile_app_linking", true, mProfileUserId); 304 305 disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT); 306 disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT); 307 assertAppLinkResult("testReceivedByBrowserActivityInManaged"); 308 309 enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT); 310 disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT); 311 assertAppLinkResult("testTwoReceivers"); 312 313 disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT); 314 enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT); 315 assertAppLinkResult("testTwoReceivers"); 316 317 enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT); 318 enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT); 319 assertAppLinkResult("testThreeReceivers"); 320 } 321 322 public void testSettingsIntents() throws Exception { 323 if (!mHasFeature) { 324 return; 325 } 326 327 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".SettingsIntentsTest", 328 mProfileUserId); 329 } 330 331 public void testCrossProfileContent() throws Exception { 332 if (!mHasFeature) { 333 return; 334 } 335 installAppAsUser(INTENT_RECEIVER_APK, mParentUserId); 336 installAppAsUser(INTENT_SENDER_APK, mParentUserId); 337 installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId); 338 installAppAsUser(INTENT_SENDER_APK, mProfileUserId); 339 340 // Test from parent to managed 341 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 342 "testRemoveAllFilters", mProfileUserId); 343 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 344 "testAddManagedCanAccessParentFilters", mProfileUserId); 345 runDeviceTestsAsUser(INTENT_SENDER_PKG, ".ContentTest", mParentUserId); 346 347 // Test from managed to parent 348 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 349 "testRemoveAllFilters", mProfileUserId); 350 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 351 "testAddParentCanAccessManagedFilters", mProfileUserId); 352 runDeviceTestsAsUser(INTENT_SENDER_PKG, ".ContentTest", mProfileUserId); 353 354 } 355 356 public void testCrossProfileCopyPaste() throws Exception { 357 if (!mHasFeature) { 358 return; 359 } 360 installAppAsUser(INTENT_RECEIVER_APK, mParentUserId); 361 installAppAsUser(INTENT_SENDER_APK, mParentUserId); 362 installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId); 363 installAppAsUser(INTENT_SENDER_APK, mProfileUserId); 364 365 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 366 "testAllowCrossProfileCopyPaste", mProfileUserId); 367 // Test that managed can see what is copied in the parent. 368 testCrossProfileCopyPasteInternal(mProfileUserId, true); 369 // Test that the parent can see what is copied in managed. 370 testCrossProfileCopyPasteInternal(mParentUserId, true); 371 372 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 373 "testDisallowCrossProfileCopyPaste", mProfileUserId); 374 // Test that managed can still see what is copied in the parent. 375 testCrossProfileCopyPasteInternal(mProfileUserId, true); 376 // Test that the parent cannot see what is copied in managed. 377 testCrossProfileCopyPasteInternal(mParentUserId, false); 378 } 379 380 private void testCrossProfileCopyPasteInternal(int userId, boolean shouldSucceed) 381 throws DeviceNotAvailableException { 382 final String direction = (userId == mParentUserId) 383 ? "testAddManagedCanAccessParentFilters" 384 : "testAddParentCanAccessManagedFilters"; 385 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 386 "testRemoveAllFilters", mProfileUserId); 387 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils", 388 direction, mProfileUserId); 389 if (shouldSucceed) { 390 runDeviceTestsAsUser(INTENT_SENDER_PKG, ".CopyPasteTest", 391 "testCanReadAcrossProfiles", userId); 392 runDeviceTestsAsUser(INTENT_SENDER_PKG, ".CopyPasteTest", 393 "testIsNotified", userId); 394 } else { 395 runDeviceTestsAsUser(INTENT_SENDER_PKG, ".CopyPasteTest", 396 "testCannotReadAcrossProfiles", userId); 397 } 398 } 399 400 /** Tests for the API helper class. */ 401 public void testCurrentApiHelper() throws Exception { 402 if (!mHasFeature) { 403 return; 404 } 405 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CurrentApiHelperTest", 406 mProfileUserId); 407 } 408 409 /** Test: unsupported public APIs are disabled on a parent profile. */ 410 public void testParentProfileApiDisabled() throws Exception { 411 if (!mHasFeature) { 412 return; 413 } 414 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ParentProfileTest", 415 "testParentProfileApiDisabled", mProfileUserId); 416 } 417 418 // TODO: This test is not specific to managed profiles, but applies to multi-user in general. 419 // Move it to a MultiUserTest class when there is one. Should probably move 420 // SetPolicyActivity to a more generic apk too as it might be useful for different kinds 421 // of tests (same applies to ComponentDisablingActivity). 422 public void testNoDebuggingFeaturesRestriction() throws Exception { 423 if (!mHasFeature) { 424 return; 425 } 426 // If adb is running as root, then the adb uid is 0 instead of SHELL_UID, 427 // so the DISALLOW_DEBUGGING_FEATURES restriction does not work and this test 428 // fails. 429 if (getDevice().isAdbRoot()) { 430 CLog.logAndDisplay(LogLevel.WARN, 431 "Cannot test testNoDebuggingFeaturesRestriction() in eng/userdebug build"); 432 return; 433 } 434 String restriction = "no_debugging_features"; // UserManager.DISALLOW_DEBUGGING_FEATURES 435 436 changeUserRestrictionOrFail(restriction, true, mProfileUserId); 437 438 439 // This should now fail, as the shell is not available to start activities under a different 440 // user once the restriction is in place. 441 String addRestrictionCommandOutput = 442 changeUserRestriction(restriction, true, mProfileUserId); 443 assertTrue( 444 "Expected SecurityException when starting the activity " 445 + addRestrictionCommandOutput, 446 addRestrictionCommandOutput.contains("SecurityException")); 447 } 448 449 // Test the bluetooth API from a managed profile. 450 public void testBluetooth() throws Exception { 451 boolean hasBluetooth = hasDeviceFeature(FEATURE_BLUETOOTH); 452 if (!mHasFeature || !hasBluetooth) { 453 return ; 454 } 455 456 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest", 457 "testEnableDisable", mProfileUserId); 458 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest", 459 "testGetAddress", mProfileUserId); 460 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest", 461 "testListenUsingRfcommWithServiceRecord", mProfileUserId); 462 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest", 463 "testGetRemoteDevice", mProfileUserId); 464 } 465 466 public void testCameraPolicy() throws Exception { 467 boolean hasCamera = hasDeviceFeature(FEATURE_CAMERA); 468 if (!mHasFeature || !hasCamera) { 469 return; 470 } 471 try { 472 setDeviceAdmin(MANAGED_PROFILE_PKG + "/.PrimaryUserDeviceAdmin", mParentUserId); 473 474 // Disable managed profile camera. 475 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest", 476 "testDisableCameraInManagedProfile", 477 mProfileUserId); 478 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest", 479 "testIsCameraEnabledInPrimaryProfile", 480 mParentUserId); 481 482 // Enable managed profile camera. 483 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest", 484 "testEnableCameraInManagedProfile", 485 mProfileUserId); 486 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest", 487 "testIsCameraEnabledInPrimaryProfile", 488 mParentUserId); 489 490 // Disable primary profile camera. 491 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest", 492 "testDisableCameraInPrimaryProfile", 493 mParentUserId); 494 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest", 495 "testIsCameraEnabledInManagedProfile", 496 mProfileUserId); 497 498 // Enable primary profile camera. 499 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest", 500 "testEnableCameraInPrimaryProfile", 501 mParentUserId); 502 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest", 503 "testIsCameraEnabledInManagedProfile", 504 mProfileUserId); 505 } finally { 506 final String adminHelperClass = ".PrimaryUserAdminHelper"; 507 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, 508 adminHelperClass, "testClearDeviceAdmin", mParentUserId); 509 } 510 } 511 512 513 public void testManagedContactsUris() throws Exception { 514 runManagedContactsTest(new Callable<Void>() { 515 @Override 516 public Void call() throws Exception { 517 ContactsTestSet contactsTestSet = new ContactsTestSet(ManagedProfileTest.this, 518 MANAGED_PROFILE_PKG, mParentUserId, mProfileUserId); 519 520 contactsTestSet.setCallerIdEnabled(true); 521 contactsTestSet.setContactsSearchEnabled(true); 522 contactsTestSet.checkIfCanLookupEnterpriseContacts(true); 523 contactsTestSet.checkIfCanFilterEnterpriseContacts(true); 524 contactsTestSet.checkIfCanFilterSelfContacts(); 525 return null; 526 } 527 }); 528 } 529 530 public void testManagedQuickContacts() throws Exception { 531 runManagedContactsTest(new Callable<Void>() { 532 @Override 533 public Void call() throws Exception { 534 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 535 "testQuickContact", mParentUserId); 536 return null; 537 } 538 }); 539 } 540 541 public void testManagedContactsPolicies() throws Exception { 542 runManagedContactsTest(new Callable<Void>() { 543 @Override 544 public Void call() throws Exception { 545 ContactsTestSet contactsTestSet = new ContactsTestSet(ManagedProfileTest.this, 546 MANAGED_PROFILE_PKG, mParentUserId, mProfileUserId); 547 try { 548 contactsTestSet.setCallerIdEnabled(true); 549 contactsTestSet.setContactsSearchEnabled(false); 550 contactsTestSet.checkIfCanLookupEnterpriseContacts(true); 551 contactsTestSet.checkIfCanFilterEnterpriseContacts(false); 552 contactsTestSet.checkIfCanFilterSelfContacts(); 553 contactsTestSet.setCallerIdEnabled(false); 554 contactsTestSet.setContactsSearchEnabled(true); 555 contactsTestSet.checkIfCanLookupEnterpriseContacts(false); 556 contactsTestSet.checkIfCanFilterEnterpriseContacts(true); 557 contactsTestSet.checkIfCanFilterSelfContacts(); 558 contactsTestSet.setCallerIdEnabled(false); 559 contactsTestSet.setContactsSearchEnabled(false); 560 contactsTestSet.checkIfCanLookupEnterpriseContacts(false); 561 contactsTestSet.checkIfCanFilterEnterpriseContacts(false); 562 contactsTestSet.checkIfCanFilterSelfContacts(); 563 contactsTestSet.checkIfNoEnterpriseDirectoryFound(); 564 return null; 565 } finally { 566 // reset policies 567 contactsTestSet.setCallerIdEnabled(true); 568 contactsTestSet.setContactsSearchEnabled(true); 569 } 570 } 571 }); 572 } 573 574 public void testOrganizationInfo() throws Exception { 575 if (!mHasFeature) { 576 return; 577 } 578 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".OrganizationInfoTest", 579 "testDefaultOrganizationColor", mProfileUserId); 580 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".OrganizationInfoTest", 581 "testDefaultOrganizationNameIsNull", mProfileUserId); 582 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".OrganizationInfoTest", 583 mProfileUserId); 584 } 585 586 public void testPasswordMinimumRestrictions() throws Exception { 587 if (!mHasFeature) { 588 return; 589 } 590 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PasswordMinimumRestrictionsTest", 591 mProfileUserId); 592 } 593 594 public void testBluetoothContactSharingDisabled() throws Exception { 595 if (!mHasFeature) { 596 return; 597 } 598 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 599 "testSetBluetoothContactSharingDisabled_setterAndGetter", mProfileUserId); 600 } 601 602 public void testCannotSetProfileOwnerAgain() throws Exception { 603 if (!mHasFeature) { 604 return; 605 } 606 // verify that we can't set the same admin receiver as profile owner again 607 assertFalse(setProfileOwner( 608 MANAGED_PROFILE_PKG + "/" + ADMIN_RECEIVER_TEST_CLASS, mProfileUserId, 609 /*expectFailure*/ true)); 610 611 // verify that we can't set a different admin receiver as profile owner 612 installAppAsUser(DEVICE_OWNER_APK, mProfileUserId); 613 assertFalse(setProfileOwner(DEVICE_OWNER_PKG + "/" + DEVICE_OWNER_ADMIN, mProfileUserId, 614 /*expectFailure*/ true)); 615 } 616 617 public void testCannotSetDeviceOwnerWhenProfilePresent() throws Exception { 618 if (!mHasFeature) { 619 return; 620 } 621 622 try { 623 installAppAsUser(DEVICE_OWNER_APK, mParentUserId); 624 assertFalse(setDeviceOwner(DEVICE_OWNER_PKG + "/" + DEVICE_OWNER_ADMIN, mParentUserId, 625 /*expectFailure*/ true)); 626 } finally { 627 // make sure we clean up in case we succeeded in setting the device owner 628 removeAdmin(DEVICE_OWNER_PKG + "/" + DEVICE_OWNER_ADMIN, mParentUserId); 629 getDevice().uninstallPackage(DEVICE_OWNER_PKG); 630 } 631 } 632 633 public void testNfcRestriction() throws Exception { 634 if (!mHasFeature || !mHasNfcFeature) { 635 return; 636 } 637 638 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest", 639 "testNfcShareEnabled", mProfileUserId); 640 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest", 641 "testNfcShareEnabled", mParentUserId); 642 643 changeUserRestrictionOrFail("no_outgoing_beam" /* UserManager.DISALLOW_OUTGOING_BEAM */, 644 true, mProfileUserId); 645 646 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest", 647 "testNfcShareDisabled", mProfileUserId); 648 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest", 649 "testNfcShareEnabled", mParentUserId); 650 } 651 652 public void testCrossProfileWidgets() throws Exception { 653 if (!mHasFeature) { 654 return; 655 } 656 657 try { 658 installAppAsUser(WIDGET_PROVIDER_APK, mProfileUserId); 659 installAppAsUser(WIDGET_PROVIDER_APK, mParentUserId); 660 getDevice().executeShellCommand("appwidget grantbind --user " + mParentUserId 661 + " --package " + WIDGET_PROVIDER_PKG); 662 setIdleWhitelist(WIDGET_PROVIDER_PKG, true); 663 startWidgetHostService(); 664 665 String commandOutput = changeCrossProfileWidgetForUser(WIDGET_PROVIDER_PKG, 666 "add-cross-profile-widget", mProfileUserId); 667 assertTrue("Command was expected to succeed " + commandOutput, 668 commandOutput.contains("Status: ok")); 669 670 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileWidgetTest", 671 "testCrossProfileWidgetProviderAdded", mProfileUserId); 672 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, 673 ".CrossProfileWidgetPrimaryUserTest", 674 "testHasCrossProfileWidgetProvider_true", mParentUserId); 675 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, 676 ".CrossProfileWidgetPrimaryUserTest", 677 "testHostReceivesWidgetUpdates_true", mParentUserId); 678 679 commandOutput = changeCrossProfileWidgetForUser(WIDGET_PROVIDER_PKG, 680 "remove-cross-profile-widget", mProfileUserId); 681 assertTrue("Command was expected to succeed " + commandOutput, 682 commandOutput.contains("Status: ok")); 683 684 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileWidgetTest", 685 "testCrossProfileWidgetProviderRemoved", mProfileUserId); 686 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, 687 ".CrossProfileWidgetPrimaryUserTest", 688 "testHasCrossProfileWidgetProvider_false", mParentUserId); 689 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, 690 ".CrossProfileWidgetPrimaryUserTest", 691 "testHostReceivesWidgetUpdates_false", mParentUserId); 692 } finally { 693 changeCrossProfileWidgetForUser(WIDGET_PROVIDER_PKG, "remove-cross-profile-widget", 694 mProfileUserId); 695 getDevice().uninstallPackage(WIDGET_PROVIDER_PKG); 696 } 697 } 698 699 public void testIsProvisioningAllowed() throws DeviceNotAvailableException { 700 if (!mHasFeature) { 701 return; 702 } 703 // In Managed profile user when managed profile is provisioned 704 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PreManagedProfileTest", 705 "testIsProvisioningAllowedFalse", mProfileUserId); 706 707 // In parent user when managed profile is provisioned 708 // It's allowed to provision again by removing the previous profile 709 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PreManagedProfileTest", 710 "testIsProvisioningAllowedTrue", mParentUserId); 711 } 712 713 private void setDirectoryPrefix(String directoryName, int userId) 714 throws DeviceNotAvailableException { 715 String command = "content call --uri " + DIRECTORY_PRIVOIDER_URI 716 + " --user " + userId 717 + " --method " + SET_CUSTOM_DIRECTORY_PREFIX_METHOD 718 + " --arg " + directoryName; 719 CLog.d("Output for command " + command + ": " 720 + getDevice().executeShellCommand(command)); 721 } 722 723 public void testPhoneAccountVisibility() throws Exception { 724 if (!mHasFeature) { 725 return; 726 } 727 if (!shouldRunTelecomTest()) { 728 return; 729 } 730 try { 731 // Register phone account in parent user. 732 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 733 "testRegisterPhoneAccount", 734 mParentUserId); 735 // The phone account should not be visible in managed user. 736 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 737 "testPhoneAccountNotRegistered", 738 mProfileUserId); 739 } finally { 740 // Unregister the phone account. 741 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 742 "testUnregisterPhoneAccount", 743 mParentUserId); 744 } 745 746 try { 747 // Register phone account in profile user. 748 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 749 "testRegisterPhoneAccount", 750 mProfileUserId); 751 // The phone account should not be visible in parent user. 752 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 753 "testPhoneAccountNotRegistered", 754 mParentUserId); 755 } finally { 756 // Unregister the phone account. 757 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 758 "testUnregisterPhoneAccount", 759 mProfileUserId); 760 } 761 } 762 763 public void testManagedCall() throws Exception { 764 if (!mHasFeature) { 765 return; 766 } 767 if (!shouldRunTelecomTest()) { 768 return; 769 } 770 // Place a outgoing call through work phone account using TelecomManager and verify the 771 // call is inserted properly. 772 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 773 "testOutgoingCallUsingTelecomManager", 774 mProfileUserId); 775 // Make sure the call is not inserted into parent user. 776 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 777 "testEnsureCallNotInserted", 778 mParentUserId); 779 780 // Place a outgoing call through work phone account using ACTION_CALL and verify the call 781 // is inserted properly. 782 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 783 "testOutgoingCallUsingActionCall", 784 mProfileUserId); 785 // Make sure the call is not inserted into parent user. 786 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 787 "testEnsureCallNotInserted", 788 mParentUserId); 789 790 // Add an incoming call with parent user's phone account and verify the call is inserted 791 // properly. 792 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 793 "testIncomingCall", 794 mProfileUserId); 795 // Make sure the call is not inserted into parent user. 796 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest", 797 "testEnsureCallNotInserted", 798 mParentUserId); 799 } 800 801 private void givePackageWriteSettingsPermission(int userId, String pkg) throws Exception { 802 // Allow app to write to settings (for RingtoneManager.setActualDefaultUri to work) 803 String command = "appops set --user " + userId + " " + pkg 804 + " android:write_settings allow"; 805 CLog.d("Output for command " + command + ": " + getDevice().executeShellCommand(command)); 806 } 807 808 public void testRingtoneSync() throws Exception { 809 if (!mHasFeature) { 810 return; 811 } 812 givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG); 813 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest", 814 "testRingtoneSync", mProfileUserId); 815 } 816 817 // Test if setting RINGTONE disables sync 818 public void testRingtoneSyncAutoDisableRingtone() throws Exception { 819 if (!mHasFeature) { 820 return; 821 } 822 givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG); 823 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest", 824 "testRingtoneDisableSync", mProfileUserId); 825 } 826 827 // Test if setting NOTIFICATION disables sync 828 public void testRingtoneSyncAutoDisableNotification() throws Exception { 829 if (!mHasFeature) { 830 return; 831 } 832 givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG); 833 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest", 834 "testNotificationDisableSync", mProfileUserId); 835 } 836 837 // Test if setting ALARM disables sync 838 public void testRingtoneSyncAutoDisableAlarm() throws Exception { 839 if (!mHasFeature) { 840 return; 841 } 842 givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG); 843 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest", 844 "testAlarmDisableSync", mProfileUserId); 845 } 846 847 public void testTrustAgentInfo() throws Exception { 848 if (!mHasFeature) { 849 return; 850 } 851 // Set and get trust agent config using child dpm instance. 852 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest", 853 "testSetAndGetTrustAgentConfiguration_child", 854 mProfileUserId); 855 // Set and get trust agent config using parent dpm instance. 856 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest", 857 "testSetAndGetTrustAgentConfiguration_parent", 858 mProfileUserId); 859 // Unified case 860 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest", 861 "testSetTrustAgentConfiguration_bothHaveTrustAgentConfigAndUnified", 862 mProfileUserId); 863 // Non-unified case 864 try { 865 changeUserCredential("1234", null, mProfileUserId); 866 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest", 867 "testSetTrustAgentConfiguration_bothHaveTrustAgentConfigAndNonUnified", 868 mProfileUserId); 869 } finally { 870 changeUserCredential(null, "1234", mProfileUserId); 871 } 872 } 873 874 public void testSanityCheck() throws Exception { 875 if (!mHasFeature) { 876 return; 877 } 878 // Install SimpleApp in work profile only and check activity in it can be launched. 879 installAppAsUser(SIMPLE_APP_APK, mProfileUserId); 880 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".SanityTest", mProfileUserId); 881 } 882 883 public void testBluetoothSharingRestriction() throws Exception { 884 final boolean hasBluetooth = hasDeviceFeature(FEATURE_BLUETOOTH); 885 if (!mHasFeature || !hasBluetooth) { 886 return; 887 } 888 889 // Primary profile should be able to use bluetooth sharing. 890 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothSharingRestrictionPrimaryProfileTest", 891 "testBluetoothSharingAvailable", mPrimaryUserId); 892 893 // Managed profile owner should be able to control it via DISALLOW_BLUETOOTH_SHARING. 894 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothSharingRestrictionTest", 895 "testOppDisabledWhenRestrictionSet", mProfileUserId); 896 } 897 898 private void disableActivityForUser(String activityName, int userId) 899 throws DeviceNotAvailableException { 900 String command = "am start -W --user " + userId 901 + " --es extra-package " + MANAGED_PROFILE_PKG 902 + " --es extra-class-name " + MANAGED_PROFILE_PKG + "." + activityName 903 + " " + MANAGED_PROFILE_PKG + "/.ComponentDisablingActivity "; 904 CLog.d("Output for command " + command + ": " 905 + getDevice().executeShellCommand(command)); 906 } 907 908 private void changeUserRestrictionOrFail(String key, boolean value, int userId) 909 throws DeviceNotAvailableException { 910 changeUserRestrictionOrFail(key, value, userId, MANAGED_PROFILE_PKG); 911 } 912 913 private String changeUserRestriction(String key, boolean value, int userId) 914 throws DeviceNotAvailableException { 915 return changeUserRestriction(key, value, userId, MANAGED_PROFILE_PKG); 916 } 917 918 private void setIdleWhitelist(String packageName, boolean enabled) 919 throws DeviceNotAvailableException { 920 String command = "cmd deviceidle whitelist " + (enabled ? "+" : "-") + packageName; 921 CLog.d("Output for command " + command + ": " 922 + getDevice().executeShellCommand(command)); 923 } 924 925 private String changeCrossProfileWidgetForUser(String packageName, String command, int userId) 926 throws DeviceNotAvailableException { 927 String adbCommand = "am start -W --user " + userId 928 + " -c android.intent.category.DEFAULT " 929 + " --es extra-command " + command 930 + " --es extra-package-name " + packageName 931 + " " + MANAGED_PROFILE_PKG + "/.SetPolicyActivity"; 932 String commandOutput = getDevice().executeShellCommand(adbCommand); 933 CLog.d("Output for command " + adbCommand + ": " + commandOutput); 934 return commandOutput; 935 } 936 937 // status should be one of never, undefined, ask, always 938 private void changeVerificationStatus(int userId, String packageName, String status) 939 throws DeviceNotAvailableException { 940 String command = "pm set-app-link --user " + userId + " " + packageName + " " + status; 941 CLog.d("Output for command " + command + ": " 942 + getDevice().executeShellCommand(command)); 943 } 944 945 protected void startWidgetHostService() throws Exception { 946 String command = "am startservice --user " + mParentUserId 947 + " -a " + WIDGET_PROVIDER_PKG + ".REGISTER_CALLBACK " 948 + "--ei user-extra " + getUserSerialNumber(mProfileUserId) 949 + " " + WIDGET_PROVIDER_PKG + "/.SimpleAppWidgetHostService"; 950 CLog.d("Output for command " + command + ": " 951 + getDevice().executeShellCommand(command)); 952 } 953 954 private void assertAppLinkResult(String methodName) throws DeviceNotAvailableException { 955 runDeviceTestsAsUser(INTENT_SENDER_PKG, ".AppLinkTest", methodName, 956 mProfileUserId); 957 } 958 959 private boolean shouldRunTelecomTest() throws DeviceNotAvailableException { 960 return hasDeviceFeature(FEATURE_TELEPHONY) && hasDeviceFeature(FEATURE_CONNECTION_SERVICE); 961 } 962 963 private void runManagedContactsTest(Callable<Void> callable) throws Exception { 964 if (!mHasFeature) { 965 return; 966 } 967 968 try { 969 // Allow cross profile contacts search. 970 // TODO test both on and off. 971 getDevice().executeShellCommand( 972 "settings put --user " + mProfileUserId 973 + " secure managed_profile_contact_remote_search 1"); 974 975 // Add test account 976 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 977 "testAddTestAccount", mParentUserId); 978 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 979 "testAddTestAccount", mProfileUserId); 980 981 // Install directory provider to both primary and managed profile 982 installAppAsUser(DIRECTORY_PROVIDER_APK, mProfileUserId); 983 installAppAsUser(DIRECTORY_PROVIDER_APK, mParentUserId); 984 setDirectoryPrefix(PRIMARY_DIRECTORY_PREFIX, mParentUserId); 985 setDirectoryPrefix(MANAGED_DIRECTORY_PREFIX, mProfileUserId); 986 987 // Check enterprise directory API works 988 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 989 "testGetDirectoryListInPrimaryProfile", mParentUserId); 990 991 // Insert Primary profile Contacts 992 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 993 "testPrimaryProfilePhoneAndEmailLookup_insertedAndfound", mParentUserId); 994 // Insert Managed profile Contacts 995 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 996 "testManagedProfilePhoneAndEmailLookup_insertedAndfound", mProfileUserId); 997 // Insert a primary contact with same phone & email as other 998 // enterprise contacts 999 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 1000 "testPrimaryProfileDuplicatedPhoneEmailContact_insertedAndfound", 1001 mParentUserId); 1002 // Insert a enterprise contact with same phone & email as other 1003 // primary contacts 1004 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 1005 "testManagedProfileDuplicatedPhoneEmailContact_insertedAndfound", 1006 mProfileUserId); 1007 1008 callable.call(); 1009 1010 } finally { 1011 // Clean up in managed profile and primary profile 1012 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 1013 "testCurrentProfileContacts_removeContacts", mProfileUserId); 1014 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest", 1015 "testCurrentProfileContacts_removeContacts", mParentUserId); 1016 getDevice().uninstallPackage(DIRECTORY_PROVIDER_PKG); 1017 } 1018 } 1019 1020 1021 /* 1022 * Container for running ContactsTest under multi-user environment 1023 */ 1024 private static class ContactsTestSet { 1025 1026 private ManagedProfileTest mManagedProfileTest; 1027 private String mManagedProfilePackage; 1028 private int mParentUserId; 1029 private int mProfileUserId; 1030 1031 public ContactsTestSet(ManagedProfileTest managedProfileTest, String managedProfilePackage, 1032 int parentUserId, int profileUserId) { 1033 mManagedProfileTest = managedProfileTest; 1034 mManagedProfilePackage = managedProfilePackage; 1035 mParentUserId = parentUserId; 1036 mProfileUserId = profileUserId; 1037 } 1038 1039 private void runDeviceTestsAsUser(String pkgName, String testClassName, 1040 String testMethodName, Integer userId) throws DeviceNotAvailableException { 1041 mManagedProfileTest.runDeviceTestsAsUser(pkgName, testClassName, testMethodName, 1042 userId); 1043 } 1044 1045 // Enable / Disable cross profile caller id 1046 public void setCallerIdEnabled(boolean enabled) throws DeviceNotAvailableException { 1047 if (enabled) { 1048 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1049 "testSetCrossProfileCallerIdDisabled_false", mProfileUserId); 1050 } else { 1051 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1052 "testSetCrossProfileCallerIdDisabled_true", mProfileUserId); 1053 } 1054 } 1055 1056 // Enable / Disable cross profile contacts search 1057 public void setContactsSearchEnabled(boolean enabled) throws DeviceNotAvailableException { 1058 if (enabled) { 1059 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1060 "testSetCrossProfileContactsSearchDisabled_false", mProfileUserId); 1061 } else { 1062 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1063 "testSetCrossProfileContactsSearchDisabled_true", mProfileUserId); 1064 } 1065 } 1066 1067 public void checkIfCanLookupEnterpriseContacts(boolean expected) 1068 throws DeviceNotAvailableException { 1069 // Primary user cannot use ordinary phone/email lookup api to access 1070 // managed contacts 1071 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1072 "testPrimaryProfilePhoneLookup_canNotAccessEnterpriseContact", mParentUserId); 1073 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1074 "testPrimaryProfileEmailLookup_canNotAccessEnterpriseContact", mParentUserId); 1075 // Primary user can use ENTERPRISE_CONTENT_FILTER_URI to access 1076 // primary contacts 1077 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1078 "testPrimaryProfileEnterprisePhoneLookup_canAccessPrimaryContact", 1079 mParentUserId); 1080 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1081 "testPrimaryProfileEnterpriseEmailLookup_canAccessPrimaryContact", 1082 mParentUserId); 1083 // When there exist contacts with the same phone/email in primary & 1084 // enterprise, 1085 // primary user can use ENTERPRISE_CONTENT_FILTER_URI to access the 1086 // primary contact. 1087 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1088 "testPrimaryProfileEnterpriseEmailLookupDuplicated_canAccessPrimaryContact", 1089 mParentUserId); 1090 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1091 "testPrimaryProfileEnterprisePhoneLookupDuplicated_canAccessPrimaryContact", 1092 mParentUserId); 1093 1094 // Managed user cannot use ordinary phone/email lookup api to access 1095 // primary contacts 1096 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1097 "testManagedProfilePhoneLookup_canNotAccessPrimaryContact", mProfileUserId); 1098 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1099 "testManagedProfileEmailLookup_canNotAccessPrimaryContact", mProfileUserId); 1100 // Managed user can use ENTERPRISE_CONTENT_FILTER_URI to access 1101 // enterprise contacts 1102 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1103 "testManagedProfileEnterprisePhoneLookup_canAccessEnterpriseContact", 1104 mProfileUserId); 1105 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1106 "testManagedProfileEnterpriseEmailLookup_canAccessEnterpriseContact", 1107 mProfileUserId); 1108 // Managed user cannot use ENTERPRISE_CONTENT_FILTER_URI to access 1109 // primary contacts 1110 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1111 "testManagedProfileEnterprisePhoneLookup_canNotAccessPrimaryContact", 1112 mProfileUserId); 1113 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1114 "testManagedProfileEnterpriseEmailLookup_canNotAccessPrimaryContact", 1115 mProfileUserId); 1116 // When there exist contacts with the same phone/email in primary & 1117 // enterprise, 1118 // managed user can use ENTERPRISE_CONTENT_FILTER_URI to access the 1119 // enterprise contact. 1120 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1121 "testManagedProfileEnterpriseEmailLookupDuplicated_canAccessEnterpriseContact", 1122 mProfileUserId); 1123 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1124 "testManagedProfileEnterprisePhoneLookupDuplicated_canAccessEnterpriseContact", 1125 mProfileUserId); 1126 1127 // Check if phone lookup can access primary directories 1128 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1129 "testPrimaryProfileEnterprisePhoneLookup_canAccessPrimaryDirectories", 1130 mParentUserId); 1131 1132 // Check if email lookup can access primary directories 1133 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1134 "testPrimaryProfileEnterpriseEmailLookup_canAccessPrimaryDirectories", 1135 mParentUserId); 1136 1137 if (expected) { 1138 // Primary user can use ENTERPRISE_CONTENT_FILTER_URI to access 1139 // managed profile contacts 1140 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1141 "testPrimaryProfileEnterprisePhoneLookup_canAccessEnterpriseContact", 1142 mParentUserId); 1143 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1144 "testPrimaryProfileEnterpriseEmailLookup_canAccessEnterpriseContact", 1145 mParentUserId); 1146 1147 // Make sure SIP enterprise lookup works too. 1148 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1149 "testPrimaryProfileEnterpriseSipLookup_canAccessEnterpriseContact", 1150 mParentUserId); 1151 1152 // Check if phone lookup can access enterprise directories 1153 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1154 "testPrimaryProfileEnterprisePhoneLookup_canAccessManagedDirectories", 1155 mParentUserId); 1156 1157 // Check if email lookup can access enterprise directories 1158 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1159 "testPrimaryProfileEnterpriseEmailLookup_canAccessManagedDirectories", 1160 mParentUserId); 1161 } else { 1162 // Primary user cannot use ENTERPRISE_CONTENT_FILTER_URI to 1163 // access managed contacts 1164 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1165 "testPrimaryProfileEnterprisePhoneLookup_canNotAccessEnterpriseContact", 1166 mParentUserId); 1167 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1168 "testPrimaryProfileEnterprisePhoneLookup_canNotAccessManagedDirectories", 1169 mParentUserId); 1170 1171 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1172 "testPrimaryProfileEnterpriseEmailLookup_canNotAccessManagedDirectories", 1173 mParentUserId); 1174 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1175 "testPrimaryProfileEnterprisePhoneLookup_canNotAccessManagedDirectories", 1176 mParentUserId); 1177 } 1178 } 1179 1180 public void checkIfCanFilterSelfContacts() throws DeviceNotAvailableException { 1181 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1182 "testPrimaryProfileEnterpriseCallableFilter_canAccessPrimaryDirectories", 1183 mParentUserId); 1184 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1185 "testManagedProfileEnterpriseCallableFilter_canAccessManagedDirectories", 1186 mProfileUserId); 1187 1188 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1189 "testPrimaryProfileEnterpriseEmailFilter_canAccessPrimaryDirectories", 1190 mParentUserId); 1191 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1192 "testEnterpriseProfileEnterpriseEmailFilter_canAccessManagedDirectories", 1193 mProfileUserId); 1194 1195 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1196 "testPrimaryProfileEnterpriseContactFilter_canAccessPrimaryDirectories", 1197 mParentUserId); 1198 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1199 "testManagedProfileEnterpriseContactFilter_canAccessManagedDirectories", 1200 mProfileUserId); 1201 1202 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1203 "testPrimaryProfileEnterprisePhoneFilter_canAccessPrimaryDirectories", 1204 mParentUserId); 1205 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1206 "testManagedProfileEnterprisePhoneFilter_canAccessManagedDirectories", 1207 mProfileUserId); 1208 } 1209 1210 public void checkIfCanFilterEnterpriseContacts(boolean expected) 1211 throws DeviceNotAvailableException { 1212 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1213 "testFilterUriWhenDirectoryParamMissing", mParentUserId); 1214 if (expected) { 1215 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1216 "testPrimaryProfileEnterpriseCallableFilter_canAccessManagedDirectories", 1217 mParentUserId); 1218 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1219 "testPrimaryProfileEnterpriseEmailFilter_canAccessManagedDirectories", 1220 mParentUserId); 1221 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1222 "testPrimaryProfileEnterpriseContactFilter_canAccessManagedDirectories", 1223 mParentUserId); 1224 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1225 "testPrimaryProfileEnterprisePhoneFilter_canAccessManagedDirectories", 1226 mParentUserId); 1227 } else { 1228 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1229 "testPrimaryProfileEnterpriseCallableFilter_canNotAccessManagedDirectories", 1230 mParentUserId); 1231 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1232 "testPrimaryProfileEnterpriseEmailFilter_canNotAccessManagedDirectories", 1233 mParentUserId); 1234 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1235 "testPrimaryProfileEnterpriseContactFilter_canNotAccessManagedDirectories", 1236 mParentUserId); 1237 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1238 "testPrimaryProfileEnterprisePhoneFilter_canNotAccessManagedDirectories", 1239 mParentUserId); 1240 } 1241 } 1242 1243 public void checkIfNoEnterpriseDirectoryFound() throws DeviceNotAvailableException { 1244 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest", 1245 "testPrimaryProfileEnterpriseDirectories_canNotAccessManagedDirectories", 1246 mParentUserId); 1247 } 1248 } 1249 } 1250