1 /* 2 * Copyright (C) 2011 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.server.pm; 18 19 import static com.google.common.truth.Truth.assertThat; 20 import static com.google.common.truth.Truth.assertWithMessage; 21 22 import static org.junit.Assert.fail; 23 import static org.junit.Assume.assumeTrue; 24 import static org.testng.Assert.assertThrows; 25 26 import android.annotation.UserIdInt; 27 import android.app.ActivityManager; 28 import android.content.BroadcastReceiver; 29 import android.content.Context; 30 import android.content.Intent; 31 import android.content.IntentFilter; 32 import android.content.pm.PackageManager; 33 import android.content.pm.UserInfo; 34 import android.content.res.Resources; 35 import android.os.Bundle; 36 import android.os.UserHandle; 37 import android.os.UserManager; 38 import android.provider.Settings; 39 import android.test.suitebuilder.annotation.LargeTest; 40 import android.test.suitebuilder.annotation.MediumTest; 41 import android.test.suitebuilder.annotation.SmallTest; 42 import android.util.Slog; 43 44 import androidx.annotation.Nullable; 45 import androidx.test.InstrumentationRegistry; 46 import androidx.test.runner.AndroidJUnit4; 47 48 import com.google.common.collect.Range; 49 50 import org.junit.After; 51 import org.junit.Before; 52 import org.junit.Test; 53 import org.junit.runner.RunWith; 54 55 import java.util.ArrayList; 56 import java.util.List; 57 import java.util.concurrent.ExecutorService; 58 import java.util.concurrent.Executors; 59 import java.util.concurrent.TimeUnit; 60 import java.util.concurrent.atomic.AtomicInteger; 61 import java.util.stream.Collectors; 62 63 import javax.annotation.concurrent.GuardedBy; 64 65 /** Test {@link UserManager} functionality. */ 66 @RunWith(AndroidJUnit4.class) 67 public final class UserManagerTest { 68 // Taken from UserManagerService 69 private static final long EPOCH_PLUS_30_YEARS = 30L * 365 * 24 * 60 * 60 * 1000L; // 30 years 70 71 private static final int REMOVE_CHECK_INTERVAL_MILLIS = 500; // 0.5 seconds 72 private static final int REMOVE_TIMEOUT_MILLIS = 60 * 1000; // 60 seconds 73 private static final int SWITCH_USER_TIMEOUT_MILLIS = 40 * 1000; // 40 seconds 74 75 // Packages which are used during tests. 76 private static final String[] PACKAGES = new String[] { 77 "com.android.egg", 78 "com.google.android.webview" 79 }; 80 private static final String TAG = UserManagerTest.class.getSimpleName(); 81 82 private final Context mContext = InstrumentationRegistry.getInstrumentation().getContext(); 83 84 private final Object mUserRemoveLock = new Object(); 85 private final Object mUserSwitchLock = new Object(); 86 87 private UserManager mUserManager = null; 88 private PackageManager mPackageManager; 89 private List<Integer> usersToRemove; 90 91 @Before setUp()92 public void setUp() throws Exception { 93 mUserManager = UserManager.get(mContext); 94 mPackageManager = mContext.getPackageManager(); 95 96 IntentFilter filter = new IntentFilter(Intent.ACTION_USER_REMOVED); 97 filter.addAction(Intent.ACTION_USER_SWITCHED); 98 mContext.registerReceiver(new BroadcastReceiver() { 99 @Override 100 public void onReceive(Context context, Intent intent) { 101 switch (intent.getAction()) { 102 case Intent.ACTION_USER_REMOVED: 103 synchronized (mUserRemoveLock) { 104 mUserRemoveLock.notifyAll(); 105 } 106 break; 107 case Intent.ACTION_USER_SWITCHED: 108 synchronized (mUserSwitchLock) { 109 mUserSwitchLock.notifyAll(); 110 } 111 break; 112 } 113 } 114 }, filter); 115 116 removeExistingUsers(); 117 usersToRemove = new ArrayList<>(); 118 } 119 120 @After tearDown()121 public void tearDown() throws Exception { 122 for (Integer userId : usersToRemove) { 123 removeUser(userId); 124 } 125 } 126 removeExistingUsers()127 private void removeExistingUsers() { 128 int currentUser = ActivityManager.getCurrentUser(); 129 List<UserInfo> list = mUserManager.getUsers(); 130 for (UserInfo user : list) { 131 // Keep system and current user 132 if (user.id != UserHandle.USER_SYSTEM && user.id != currentUser) { 133 removeUser(user.id); 134 } 135 } 136 } 137 138 @SmallTest 139 @Test testHasSystemUser()140 public void testHasSystemUser() throws Exception { 141 assertThat(hasUser(UserHandle.USER_SYSTEM)).isTrue(); 142 } 143 144 @MediumTest 145 @Test testAddGuest()146 public void testAddGuest() throws Exception { 147 UserInfo userInfo = createUser("Guest 1", UserInfo.FLAG_GUEST); 148 assertThat(userInfo).isNotNull(); 149 150 List<UserInfo> list = mUserManager.getUsers(); 151 for (UserInfo user : list) { 152 if (user.id == userInfo.id && user.name.equals("Guest 1") 153 && user.isGuest() 154 && !user.isAdmin() 155 && !user.isPrimary()) { 156 return; 157 } 158 } 159 fail("Didn't find a guest: " + list); 160 } 161 162 @Test testCloneUser()163 public void testCloneUser() throws Exception { 164 // Test that only one clone user can be created 165 final int primaryUserId = mUserManager.getPrimaryUser().id; 166 UserInfo userInfo = createProfileForUser("Clone user1", 167 UserManager.USER_TYPE_PROFILE_CLONE, 168 primaryUserId); 169 assertThat(userInfo).isNotNull(); 170 UserInfo userInfo2 = createProfileForUser("Clone user2", 171 UserManager.USER_TYPE_PROFILE_CLONE, 172 primaryUserId); 173 assertThat(userInfo2).isNull(); 174 175 final Context userContext = mContext.createPackageContextAsUser("system", 0, 176 UserHandle.of(userInfo.id)); 177 assertThat(userContext.getSystemService( 178 UserManager.class).isMediaSharedWithParent()).isTrue(); 179 180 List<UserInfo> list = mUserManager.getUsers(); 181 List<UserInfo> cloneUsers = list.stream().filter( 182 user -> (user.id == userInfo.id && user.name.equals("Clone user1") 183 && user.isCloneProfile())) 184 .collect(Collectors.toList()); 185 assertThat(cloneUsers.size()).isEqualTo(1); 186 187 // Verify clone user parent 188 assertThat(mUserManager.getProfileParent(primaryUserId)).isNull(); 189 UserInfo parentProfileInfo = mUserManager.getProfileParent(userInfo.id); 190 assertThat(parentProfileInfo).isNotNull(); 191 assertThat(primaryUserId).isEqualTo(parentProfileInfo.id); 192 removeUser(userInfo.id); 193 assertThat(mUserManager.getProfileParent(primaryUserId)).isNull(); 194 } 195 196 @MediumTest 197 @Test testAdd2Users()198 public void testAdd2Users() throws Exception { 199 UserInfo user1 = createUser("Guest 1", UserInfo.FLAG_GUEST); 200 UserInfo user2 = createUser("User 2", UserInfo.FLAG_ADMIN); 201 202 assertThat(user1).isNotNull(); 203 assertThat(user2).isNotNull(); 204 205 assertThat(hasUser(UserHandle.USER_SYSTEM)).isTrue(); 206 assertThat(hasUser(user1.id)).isTrue(); 207 assertThat(hasUser(user2.id)).isTrue(); 208 } 209 210 @MediumTest 211 @Test testRemoveUser()212 public void testRemoveUser() throws Exception { 213 UserInfo userInfo = createUser("Guest 1", UserInfo.FLAG_GUEST); 214 removeUser(userInfo.id); 215 216 assertThat(hasUser(userInfo.id)).isFalse(); 217 } 218 219 @MediumTest 220 @Test testRemoveUserByHandle()221 public void testRemoveUserByHandle() { 222 UserInfo userInfo = createUser("Guest 1", UserInfo.FLAG_GUEST); 223 final UserHandle user = userInfo.getUserHandle(); 224 synchronized (mUserRemoveLock) { 225 mUserManager.removeUser(user); 226 long time = System.currentTimeMillis(); 227 while (mUserManager.getUserInfo(user.getIdentifier()) != null) { 228 try { 229 mUserRemoveLock.wait(REMOVE_CHECK_INTERVAL_MILLIS); 230 } catch (InterruptedException ie) { 231 Thread.currentThread().interrupt(); 232 return; 233 } 234 if (System.currentTimeMillis() - time > REMOVE_TIMEOUT_MILLIS) { 235 fail("Timeout waiting for removeUser. userId = " + user.getIdentifier()); 236 } 237 } 238 } 239 240 assertThat(hasUser(userInfo.id)).isFalse(); 241 } 242 243 @MediumTest 244 @Test testRemoveUserByHandle_ThrowsException()245 public void testRemoveUserByHandle_ThrowsException() { 246 assertThrows(IllegalArgumentException.class, () -> mUserManager.removeUser(null)); 247 } 248 249 @MediumTest 250 @Test testRemoveUserOrSetEphemeral_restrictedReturnsError()251 public void testRemoveUserOrSetEphemeral_restrictedReturnsError() throws Exception { 252 final int currentUser = ActivityManager.getCurrentUser(); 253 final UserInfo user1 = createUser("User 1", /* flags= */ 0); 254 mUserManager.setUserRestriction(UserManager.DISALLOW_REMOVE_USER, /* value= */ true, 255 asHandle(currentUser)); 256 try { 257 assertThat(mUserManager.removeUserOrSetEphemeral(user1.id, 258 /* evenWhenDisallowed= */ false)).isEqualTo(UserManager.REMOVE_RESULT_ERROR); 259 } finally { 260 mUserManager.setUserRestriction(UserManager.DISALLOW_REMOVE_USER, /* value= */ false, 261 asHandle(currentUser)); 262 } 263 264 assertThat(hasUser(user1.id)).isTrue(); 265 assertThat(getUser(user1.id).isEphemeral()).isFalse(); 266 } 267 268 @MediumTest 269 @Test testRemoveUserOrSetEphemeral_evenWhenRestricted()270 public void testRemoveUserOrSetEphemeral_evenWhenRestricted() throws Exception { 271 final int currentUser = ActivityManager.getCurrentUser(); 272 final UserInfo user1 = createUser("User 1", /* flags= */ 0); 273 mUserManager.setUserRestriction(UserManager.DISALLOW_REMOVE_USER, /* value= */ true, 274 asHandle(currentUser)); 275 try { 276 synchronized (mUserRemoveLock) { 277 assertThat(mUserManager.removeUserOrSetEphemeral(user1.id, 278 /* evenWhenDisallowed= */ true)) 279 .isEqualTo(UserManager.REMOVE_RESULT_REMOVED); 280 waitForUserRemovalLocked(user1.id); 281 } 282 283 } finally { 284 mUserManager.setUserRestriction(UserManager.DISALLOW_REMOVE_USER, /* value= */ false, 285 asHandle(currentUser)); 286 } 287 288 assertThat(hasUser(user1.id)).isFalse(); 289 } 290 291 @MediumTest 292 @Test testRemoveUserOrSetEphemeral_systemUserReturnsError()293 public void testRemoveUserOrSetEphemeral_systemUserReturnsError() throws Exception { 294 assertThat(mUserManager.removeUserOrSetEphemeral(UserHandle.USER_SYSTEM, 295 /* evenWhenDisallowed= */ false)).isEqualTo(UserManager.REMOVE_RESULT_ERROR); 296 297 assertThat(hasUser(UserHandle.USER_SYSTEM)).isTrue(); 298 } 299 300 @MediumTest 301 @Test testRemoveUserOrSetEphemeral_invalidUserReturnsError()302 public void testRemoveUserOrSetEphemeral_invalidUserReturnsError() throws Exception { 303 assertThat(hasUser(Integer.MAX_VALUE)).isFalse(); 304 assertThat(mUserManager.removeUserOrSetEphemeral(Integer.MAX_VALUE, 305 /* evenWhenDisallowed= */ false)).isEqualTo(UserManager.REMOVE_RESULT_ERROR); 306 } 307 308 @MediumTest 309 @Test testRemoveUserOrSetEphemeral_currentUserSetEphemeral()310 public void testRemoveUserOrSetEphemeral_currentUserSetEphemeral() throws Exception { 311 final int startUser = ActivityManager.getCurrentUser(); 312 final UserInfo user1 = createUser("User 1", /* flags= */ 0); 313 // Switch to the user just created. 314 switchUser(user1.id, null, /* ignoreHandle= */ true); 315 316 assertThat(mUserManager.removeUserOrSetEphemeral(user1.id, /* evenWhenDisallowed= */ false)) 317 .isEqualTo(UserManager.REMOVE_RESULT_SET_EPHEMERAL); 318 319 assertThat(hasUser(user1.id)).isTrue(); 320 assertThat(getUser(user1.id).isEphemeral()).isTrue(); 321 322 // Switch back to the starting user. 323 switchUser(startUser, null, /* ignoreHandle= */ true); 324 325 // User is removed once switch is complete 326 synchronized (mUserRemoveLock) { 327 waitForUserRemovalLocked(user1.id); 328 } 329 assertThat(hasUser(user1.id)).isFalse(); 330 } 331 332 @MediumTest 333 @Test testRemoveUserOrSetEphemeral_nonCurrentUserRemoved()334 public void testRemoveUserOrSetEphemeral_nonCurrentUserRemoved() throws Exception { 335 final UserInfo user1 = createUser("User 1", /* flags= */ 0); 336 synchronized (mUserRemoveLock) { 337 assertThat(mUserManager.removeUserOrSetEphemeral(user1.id, 338 /* evenWhenDisallowed= */ false)).isEqualTo(UserManager.REMOVE_RESULT_REMOVED); 339 waitForUserRemovalLocked(user1.id); 340 } 341 342 assertThat(hasUser(user1.id)).isFalse(); 343 } 344 345 /** Tests creating a FULL user via specifying userType. */ 346 @MediumTest 347 @Test testCreateUserViaTypes()348 public void testCreateUserViaTypes() throws Exception { 349 createUserWithTypeAndCheckFlags(UserManager.USER_TYPE_FULL_GUEST, 350 UserInfo.FLAG_GUEST | UserInfo.FLAG_FULL); 351 352 createUserWithTypeAndCheckFlags(UserManager.USER_TYPE_FULL_DEMO, 353 UserInfo.FLAG_DEMO | UserInfo.FLAG_FULL); 354 355 createUserWithTypeAndCheckFlags(UserManager.USER_TYPE_FULL_SECONDARY, 356 UserInfo.FLAG_FULL); 357 } 358 359 /** Tests creating a FULL user via specifying user flags. */ 360 @MediumTest 361 @Test testCreateUserViaFlags()362 public void testCreateUserViaFlags() throws Exception { 363 createUserWithFlagsAndCheckType(UserInfo.FLAG_GUEST, UserManager.USER_TYPE_FULL_GUEST, 364 UserInfo.FLAG_FULL); 365 366 createUserWithFlagsAndCheckType(0, UserManager.USER_TYPE_FULL_SECONDARY, 367 UserInfo.FLAG_FULL); 368 369 createUserWithFlagsAndCheckType(UserInfo.FLAG_FULL, UserManager.USER_TYPE_FULL_SECONDARY, 370 0); 371 372 createUserWithFlagsAndCheckType(UserInfo.FLAG_DEMO, UserManager.USER_TYPE_FULL_DEMO, 373 UserInfo.FLAG_FULL); 374 } 375 376 /** Creates a user of the given user type and checks that the result has the requiredFlags. */ createUserWithTypeAndCheckFlags(String userType, @UserIdInt int requiredFlags)377 private void createUserWithTypeAndCheckFlags(String userType, 378 @UserIdInt int requiredFlags) { 379 final UserInfo userInfo = createUser("Name", userType, 0); 380 assertWithMessage("Wrong user type").that(userInfo.userType).isEqualTo(userType); 381 assertWithMessage("Flags %s did not contain expected %s", userInfo.flags, requiredFlags) 382 .that(userInfo.flags & requiredFlags).isEqualTo(requiredFlags); 383 removeUser(userInfo.id); 384 } 385 386 /** 387 * Creates a user of the given flags and checks that the result is of the expectedUserType type 388 * and that it has the expected flags (including both flags and any additionalRequiredFlags). 389 */ createUserWithFlagsAndCheckType(@serIdInt int flags, String expectedUserType, @UserIdInt int additionalRequiredFlags)390 private void createUserWithFlagsAndCheckType(@UserIdInt int flags, String expectedUserType, 391 @UserIdInt int additionalRequiredFlags) { 392 final UserInfo userInfo = createUser("Name", flags); 393 assertWithMessage("Wrong user type").that(userInfo.userType).isEqualTo(expectedUserType); 394 additionalRequiredFlags |= flags; 395 assertWithMessage("Flags %s did not contain expected %s", userInfo.flags, 396 additionalRequiredFlags).that(userInfo.flags & additionalRequiredFlags) 397 .isEqualTo(additionalRequiredFlags); 398 removeUser(userInfo.id); 399 } 400 401 402 @MediumTest 403 @Test testThereCanBeOnlyOneGuest()404 public void testThereCanBeOnlyOneGuest() throws Exception { 405 UserInfo userInfo1 = createUser("Guest 1", UserInfo.FLAG_GUEST); 406 assertThat(userInfo1).isNotNull(); 407 UserInfo userInfo2 = createUser("Guest 2", UserInfo.FLAG_GUEST); 408 assertThat(userInfo2).isNull(); 409 } 410 411 @MediumTest 412 @Test testFindExistingGuest_guestExists()413 public void testFindExistingGuest_guestExists() throws Exception { 414 UserInfo userInfo1 = createUser("Guest", UserInfo.FLAG_GUEST); 415 assertThat(userInfo1).isNotNull(); 416 UserInfo foundGuest = mUserManager.findCurrentGuestUser(); 417 assertThat(foundGuest).isNotNull(); 418 } 419 420 @SmallTest 421 @Test testFindExistingGuest_guestDoesNotExist()422 public void testFindExistingGuest_guestDoesNotExist() throws Exception { 423 UserInfo foundGuest = mUserManager.findCurrentGuestUser(); 424 assertThat(foundGuest).isNull(); 425 } 426 427 @MediumTest 428 @Test testSetUserAdmin()429 public void testSetUserAdmin() throws Exception { 430 UserInfo userInfo = createUser("SecondaryUser", /*flags=*/ 0); 431 assertThat(userInfo.isAdmin()).isFalse(); 432 433 mUserManager.setUserAdmin(userInfo.id); 434 435 userInfo = mUserManager.getUserInfo(userInfo.id); 436 assertThat(userInfo.isAdmin()).isTrue(); 437 } 438 439 @MediumTest 440 @Test testGetProfileParent()441 public void testGetProfileParent() throws Exception { 442 assumeManagedUsersSupported(); 443 final int primaryUserId = mUserManager.getPrimaryUser().id; 444 445 UserInfo userInfo = createProfileForUser("Profile", 446 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 447 assertThat(userInfo).isNotNull(); 448 assertThat(mUserManager.getProfileParent(primaryUserId)).isNull(); 449 UserInfo parentProfileInfo = mUserManager.getProfileParent(userInfo.id); 450 assertThat(parentProfileInfo).isNotNull(); 451 assertThat(primaryUserId).isEqualTo(parentProfileInfo.id); 452 removeUser(userInfo.id); 453 assertThat(mUserManager.getProfileParent(primaryUserId)).isNull(); 454 } 455 456 /** Test that UserManager returns the correct badge information for a managed profile. */ 457 @MediumTest 458 @Test testProfileTypeInformation()459 public void testProfileTypeInformation() throws Exception { 460 assumeManagedUsersSupported(); 461 final UserTypeDetails userTypeDetails = 462 UserTypeFactory.getUserTypes().get(UserManager.USER_TYPE_PROFILE_MANAGED); 463 assertWithMessage("No %s type on device", UserManager.USER_TYPE_PROFILE_MANAGED) 464 .that(userTypeDetails).isNotNull(); 465 assertThat(userTypeDetails.getName()).isEqualTo(UserManager.USER_TYPE_PROFILE_MANAGED); 466 467 final int primaryUserId = mUserManager.getPrimaryUser().id; 468 UserInfo userInfo = createProfileForUser("Managed", 469 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 470 assertThat(userInfo).isNotNull(); 471 final int userId = userInfo.id; 472 473 assertThat(mUserManager.hasBadge(userId)).isEqualTo(userTypeDetails.hasBadge()); 474 assertThat(mUserManager.getUserIconBadgeResId(userId)) 475 .isEqualTo(userTypeDetails.getIconBadge()); 476 assertThat(mUserManager.getUserBadgeResId(userId)) 477 .isEqualTo(userTypeDetails.getBadgePlain()); 478 assertThat(mUserManager.getUserBadgeNoBackgroundResId(userId)) 479 .isEqualTo(userTypeDetails.getBadgeNoBackground()); 480 481 final int badgeIndex = userInfo.profileBadge; 482 assertThat(mUserManager.getUserBadgeColor(userId)).isEqualTo( 483 Resources.getSystem().getColor(userTypeDetails.getBadgeColor(badgeIndex), null)); 484 assertThat(mUserManager.getUserBadgeDarkColor(userId)).isEqualTo( 485 Resources.getSystem().getColor(userTypeDetails.getDarkThemeBadgeColor(badgeIndex), 486 null)); 487 488 assertThat(mUserManager.getBadgedLabelForUser("Test", asHandle(userId))).isEqualTo( 489 Resources.getSystem().getString(userTypeDetails.getBadgeLabel(badgeIndex), "Test")); 490 491 // Test @UserHandleAware methods 492 final UserManager userManagerForUser = UserManager.get(mContext.createPackageContextAsUser( 493 "android", 0, asHandle(userId))); 494 assertThat(userManagerForUser.isUserOfType(userTypeDetails.getName())).isTrue(); 495 assertThat(userManagerForUser.isProfile()).isEqualTo(userTypeDetails.isProfile()); 496 } 497 498 // Make sure only max managed profiles can be created 499 @MediumTest 500 @Test testAddManagedProfile()501 public void testAddManagedProfile() throws Exception { 502 assumeManagedUsersSupported(); 503 final int primaryUserId = mUserManager.getPrimaryUser().id; 504 UserInfo userInfo1 = createProfileForUser("Managed 1", 505 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 506 UserInfo userInfo2 = createProfileForUser("Managed 2", 507 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 508 509 assertThat(userInfo1).isNotNull(); 510 assertThat(userInfo2).isNull(); 511 512 assertThat(userInfo1.userType).isEqualTo(UserManager.USER_TYPE_PROFILE_MANAGED); 513 int requiredFlags = UserInfo.FLAG_MANAGED_PROFILE | UserInfo.FLAG_PROFILE; 514 assertWithMessage("Wrong flags %s", userInfo1.flags).that(userInfo1.flags & requiredFlags) 515 .isEqualTo(requiredFlags); 516 517 // Verify that current user is not a managed profile 518 assertThat(mUserManager.isManagedProfile()).isFalse(); 519 } 520 521 // Verify that disallowed packages are not installed in the managed profile. 522 @MediumTest 523 @Test testAddManagedProfile_withDisallowedPackages()524 public void testAddManagedProfile_withDisallowedPackages() throws Exception { 525 assumeManagedUsersSupported(); 526 final int primaryUserId = mUserManager.getPrimaryUser().id; 527 UserInfo userInfo1 = createProfileForUser("Managed1", 528 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 529 // Verify that the packagesToVerify are installed by default. 530 for (String pkg : PACKAGES) { 531 if (!mPackageManager.isPackageAvailable(pkg)) { 532 Slog.w(TAG, "Package is not available " + pkg); 533 continue; 534 } 535 536 assertWithMessage("Package should be installed in managed profile: %s", pkg) 537 .that(isPackageInstalledForUser(pkg, userInfo1.id)).isTrue(); 538 } 539 removeUser(userInfo1.id); 540 541 UserInfo userInfo2 = createProfileForUser("Managed2", 542 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId, PACKAGES); 543 // Verify that the packagesToVerify are not installed by default. 544 for (String pkg : PACKAGES) { 545 if (!mPackageManager.isPackageAvailable(pkg)) { 546 Slog.w(TAG, "Package is not available " + pkg); 547 continue; 548 } 549 550 assertWithMessage( 551 "Package should not be installed in managed profile when disallowed: %s", pkg) 552 .that(isPackageInstalledForUser(pkg, userInfo2.id)).isFalse(); 553 } 554 } 555 556 // Verify that if any packages are disallowed to install during creation of managed profile can 557 // still be installed later. 558 @MediumTest 559 @Test testAddManagedProfile_disallowedPackagesInstalledLater()560 public void testAddManagedProfile_disallowedPackagesInstalledLater() throws Exception { 561 assumeManagedUsersSupported(); 562 final int primaryUserId = mUserManager.getPrimaryUser().id; 563 UserInfo userInfo = createProfileForUser("Managed", 564 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId, PACKAGES); 565 // Verify that the packagesToVerify are not installed by default. 566 for (String pkg : PACKAGES) { 567 if (!mPackageManager.isPackageAvailable(pkg)) { 568 Slog.w(TAG, "Package is not available " + pkg); 569 continue; 570 } 571 572 assertWithMessage("Pkg should not be installed in managed profile when disallowed: %s", 573 pkg).that(isPackageInstalledForUser(pkg, userInfo.id)).isFalse(); 574 } 575 576 // Verify that the disallowed packages during profile creation can be installed now. 577 for (String pkg : PACKAGES) { 578 if (!mPackageManager.isPackageAvailable(pkg)) { 579 Slog.w(TAG, "Package is not available " + pkg); 580 continue; 581 } 582 583 assertWithMessage("Package could not be installed: %s", pkg) 584 .that(mPackageManager.installExistingPackageAsUser(pkg, userInfo.id)) 585 .isEqualTo(PackageManager.INSTALL_SUCCEEDED); 586 } 587 } 588 589 // Make sure createUser would fail if we have DISALLOW_ADD_USER. 590 @MediumTest 591 @Test testCreateUser_disallowAddUser()592 public void testCreateUser_disallowAddUser() throws Exception { 593 final int creatorId = ActivityManager.getCurrentUser(); 594 final UserHandle creatorHandle = asHandle(creatorId); 595 mUserManager.setUserRestriction(UserManager.DISALLOW_ADD_USER, true, creatorHandle); 596 try { 597 UserInfo createadInfo = createUser("SecondaryUser", /*flags=*/ 0); 598 assertThat(createadInfo).isNull(); 599 } finally { 600 mUserManager.setUserRestriction(UserManager.DISALLOW_ADD_USER, false, 601 creatorHandle); 602 } 603 } 604 605 // Make sure createProfile would fail if we have DISALLOW_ADD_MANAGED_PROFILE. 606 @MediumTest 607 @Test testCreateProfileForUser_disallowAddManagedProfile()608 public void testCreateProfileForUser_disallowAddManagedProfile() throws Exception { 609 assumeManagedUsersSupported(); 610 final int primaryUserId = mUserManager.getPrimaryUser().id; 611 final UserHandle primaryUserHandle = asHandle(primaryUserId); 612 mUserManager.setUserRestriction(UserManager.DISALLOW_ADD_MANAGED_PROFILE, true, 613 primaryUserHandle); 614 try { 615 UserInfo userInfo = createProfileForUser("Managed", 616 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 617 assertThat(userInfo).isNull(); 618 } finally { 619 mUserManager.setUserRestriction(UserManager.DISALLOW_ADD_MANAGED_PROFILE, false, 620 primaryUserHandle); 621 } 622 } 623 624 // Make sure createProfileEvenWhenDisallowedForUser bypass DISALLOW_ADD_MANAGED_PROFILE. 625 @MediumTest 626 @Test testCreateProfileForUserEvenWhenDisallowed()627 public void testCreateProfileForUserEvenWhenDisallowed() throws Exception { 628 assumeManagedUsersSupported(); 629 final int primaryUserId = mUserManager.getPrimaryUser().id; 630 final UserHandle primaryUserHandle = asHandle(primaryUserId); 631 mUserManager.setUserRestriction(UserManager.DISALLOW_ADD_MANAGED_PROFILE, true, 632 primaryUserHandle); 633 try { 634 UserInfo userInfo = createProfileEvenWhenDisallowedForUser("Managed", 635 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 636 assertThat(userInfo).isNotNull(); 637 } finally { 638 mUserManager.setUserRestriction(UserManager.DISALLOW_ADD_MANAGED_PROFILE, false, 639 primaryUserHandle); 640 } 641 } 642 643 // createProfile succeeds even if DISALLOW_ADD_USER is set 644 @MediumTest 645 @Test testCreateProfileForUser_disallowAddUser()646 public void testCreateProfileForUser_disallowAddUser() throws Exception { 647 assumeManagedUsersSupported(); 648 final int primaryUserId = mUserManager.getPrimaryUser().id; 649 final UserHandle primaryUserHandle = asHandle(primaryUserId); 650 mUserManager.setUserRestriction(UserManager.DISALLOW_ADD_USER, true, primaryUserHandle); 651 try { 652 UserInfo userInfo = createProfileForUser("Managed", 653 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 654 assertThat(userInfo).isNotNull(); 655 } finally { 656 mUserManager.setUserRestriction(UserManager.DISALLOW_ADD_USER, false, 657 primaryUserHandle); 658 } 659 } 660 661 @MediumTest 662 @Test testAddRestrictedProfile()663 public void testAddRestrictedProfile() throws Exception { 664 if (isAutomotive()) return; 665 assertWithMessage("There should be no associated restricted profiles before the test") 666 .that(mUserManager.hasRestrictedProfiles()).isFalse(); 667 UserInfo userInfo = createRestrictedProfile("Profile"); 668 assertThat(userInfo).isNotNull(); 669 670 Bundle restrictions = mUserManager.getUserRestrictions(UserHandle.of(userInfo.id)); 671 assertWithMessage( 672 "Restricted profile should have DISALLOW_MODIFY_ACCOUNTS restriction by default") 673 .that(restrictions.getBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS)) 674 .isTrue(); 675 assertWithMessage( 676 "Restricted profile should have DISALLOW_SHARE_LOCATION restriction by default") 677 .that(restrictions.getBoolean(UserManager.DISALLOW_SHARE_LOCATION)) 678 .isTrue(); 679 680 int locationMode = Settings.Secure.getIntForUser(mContext.getContentResolver(), 681 Settings.Secure.LOCATION_MODE, 682 Settings.Secure.LOCATION_MODE_HIGH_ACCURACY, 683 userInfo.id); 684 assertWithMessage("Restricted profile should have setting LOCATION_MODE set to " 685 + "LOCATION_MODE_OFF by default").that(locationMode) 686 .isEqualTo(Settings.Secure.LOCATION_MODE_OFF); 687 688 assertWithMessage("Newly created profile should be associated with the current user") 689 .that(mUserManager.hasRestrictedProfiles()).isTrue(); 690 } 691 692 @MediumTest 693 @Test testGetManagedProfileCreationTime()694 public void testGetManagedProfileCreationTime() throws Exception { 695 assumeManagedUsersSupported(); 696 final int primaryUserId = mUserManager.getPrimaryUser().id; 697 final long startTime = System.currentTimeMillis(); 698 UserInfo profile = createProfileForUser("Managed 1", 699 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 700 final long endTime = System.currentTimeMillis(); 701 assertThat(profile).isNotNull(); 702 if (System.currentTimeMillis() > EPOCH_PLUS_30_YEARS) { 703 assertWithMessage("creationTime must be set when the profile is created") 704 .that(profile.creationTime).isIn(Range.closed(startTime, endTime)); 705 } else { 706 assertWithMessage("creationTime must be 0 if the time is not > EPOCH_PLUS_30_years") 707 .that(profile.creationTime).isEqualTo(0); 708 } 709 assertThat(mUserManager.getUserCreationTime(asHandle(profile.id))) 710 .isEqualTo(profile.creationTime); 711 712 long ownerCreationTime = mUserManager.getUserInfo(primaryUserId).creationTime; 713 assertThat(mUserManager.getUserCreationTime(asHandle(primaryUserId))) 714 .isEqualTo(ownerCreationTime); 715 } 716 717 @MediumTest 718 @Test testGetUserCreationTime()719 public void testGetUserCreationTime() throws Exception { 720 long startTime = System.currentTimeMillis(); 721 UserInfo user = createUser("User", /* flags= */ 0); 722 long endTime = System.currentTimeMillis(); 723 assertThat(user).isNotNull(); 724 assertWithMessage("creationTime must be set when the user is created") 725 .that(user.creationTime).isIn(Range.closed(startTime, endTime)); 726 } 727 728 @SmallTest 729 @Test testGetUserCreationTime_nonExistentUser()730 public void testGetUserCreationTime_nonExistentUser() throws Exception { 731 int noSuchUserId = 100500; 732 assertThrows(SecurityException.class, 733 () -> mUserManager.getUserCreationTime(asHandle(noSuchUserId))); 734 } 735 736 @SmallTest 737 @Test testGetUserCreationTime_otherUser()738 public void testGetUserCreationTime_otherUser() throws Exception { 739 UserInfo user = createUser("User 1", 0); 740 assertThat(user).isNotNull(); 741 assertThrows(SecurityException.class, 742 () -> mUserManager.getUserCreationTime(asHandle(user.id))); 743 } 744 745 @Nullable getUser(int id)746 private UserInfo getUser(int id) { 747 List<UserInfo> list = mUserManager.getUsers(); 748 749 for (UserInfo user : list) { 750 if (user.id == id) { 751 return user; 752 } 753 } 754 return null; 755 } 756 hasUser(int id)757 private boolean hasUser(int id) { 758 return getUser(id) != null; 759 } 760 761 @MediumTest 762 @Test testSerialNumber()763 public void testSerialNumber() { 764 UserInfo user1 = createUser("User 1", 0); 765 int serialNumber1 = user1.serialNumber; 766 assertThat(mUserManager.getUserSerialNumber(user1.id)).isEqualTo(serialNumber1); 767 assertThat(mUserManager.getUserHandle(serialNumber1)).isEqualTo(user1.id); 768 UserInfo user2 = createUser("User 2", 0); 769 int serialNumber2 = user2.serialNumber; 770 assertThat(serialNumber1 == serialNumber2).isFalse(); 771 assertThat(mUserManager.getUserSerialNumber(user2.id)).isEqualTo(serialNumber2); 772 assertThat(mUserManager.getUserHandle(serialNumber2)).isEqualTo(user2.id); 773 } 774 775 @MediumTest 776 @Test testGetSerialNumbersOfUsers()777 public void testGetSerialNumbersOfUsers() { 778 UserInfo user1 = createUser("User 1", 0); 779 UserInfo user2 = createUser("User 2", 0); 780 long[] serialNumbersOfUsers = mUserManager.getSerialNumbersOfUsers(false); 781 assertThat(serialNumbersOfUsers).asList().containsAtLeast( 782 (long) user1.serialNumber, (long) user2.serialNumber); 783 } 784 785 @MediumTest 786 @Test testMaxUsers()787 public void testMaxUsers() { 788 int N = UserManager.getMaxSupportedUsers(); 789 int count = mUserManager.getUsers().size(); 790 // Create as many users as permitted and make sure creation passes 791 while (count < N) { 792 UserInfo ui = createUser("User " + count, 0); 793 assertThat(ui).isNotNull(); 794 count++; 795 } 796 // Try to create one more user and make sure it fails 797 UserInfo extra = createUser("One more", 0); 798 assertThat(extra).isNull(); 799 } 800 801 @MediumTest 802 @Test testGetUserCount()803 public void testGetUserCount() { 804 int count = mUserManager.getUsers().size(); 805 UserInfo user1 = createUser("User 1", 0); 806 assertThat(user1).isNotNull(); 807 UserInfo user2 = createUser("User 2", 0); 808 assertThat(user2).isNotNull(); 809 assertThat(mUserManager.getUserCount()).isEqualTo(count + 2); 810 } 811 812 @MediumTest 813 @Test testRestrictions()814 public void testRestrictions() { 815 UserInfo testUser = createUser("User 1", 0); 816 817 mUserManager.setUserRestriction( 818 UserManager.DISALLOW_INSTALL_APPS, true, asHandle(testUser.id)); 819 mUserManager.setUserRestriction( 820 UserManager.DISALLOW_CONFIG_WIFI, false, asHandle(testUser.id)); 821 822 Bundle stored = mUserManager.getUserRestrictions(asHandle(testUser.id)); 823 // Note this will fail if DO already sets those restrictions. 824 assertThat(stored.getBoolean(UserManager.DISALLOW_CONFIG_WIFI)).isFalse(); 825 assertThat(stored.getBoolean(UserManager.DISALLOW_UNINSTALL_APPS)).isFalse(); 826 assertThat(stored.getBoolean(UserManager.DISALLOW_INSTALL_APPS)).isTrue(); 827 } 828 829 @MediumTest 830 @Test testDefaultRestrictionsApplied()831 public void testDefaultRestrictionsApplied() throws Exception { 832 final UserInfo userInfo = createUser("Useroid", UserManager.USER_TYPE_FULL_SECONDARY, 0); 833 final UserTypeDetails userTypeDetails = 834 UserTypeFactory.getUserTypes().get(UserManager.USER_TYPE_FULL_SECONDARY); 835 final Bundle expectedRestrictions = userTypeDetails.getDefaultRestrictions(); 836 // Note this can fail if DO unset those restrictions. 837 for (String restriction : expectedRestrictions.keySet()) { 838 if (expectedRestrictions.getBoolean(restriction)) { 839 assertThat(mUserManager.hasUserRestriction(restriction, UserHandle.of(userInfo.id))) 840 .isTrue(); 841 } 842 } 843 } 844 845 @MediumTest 846 @Test testSetDefaultGuestRestrictions()847 public void testSetDefaultGuestRestrictions() { 848 final Bundle origGuestRestrictions = mUserManager.getDefaultGuestRestrictions(); 849 Bundle restrictions = new Bundle(); 850 restrictions.putBoolean(UserManager.DISALLOW_FUN, true); 851 mUserManager.setDefaultGuestRestrictions(restrictions); 852 853 try { 854 UserInfo guest = createUser("Guest", UserInfo.FLAG_GUEST); 855 assertThat(guest).isNotNull(); 856 assertThat(mUserManager.hasUserRestriction(UserManager.DISALLOW_FUN, 857 guest.getUserHandle())).isTrue(); 858 } finally { 859 mUserManager.setDefaultGuestRestrictions(origGuestRestrictions); 860 } 861 } 862 863 @Test testGetUserSwitchability()864 public void testGetUserSwitchability() { 865 int userSwitchable = mUserManager.getUserSwitchability(); 866 assertWithMessage("Expected users to be switchable").that(userSwitchable) 867 .isEqualTo(UserManager.SWITCHABILITY_STATUS_OK); 868 } 869 870 @LargeTest 871 @Test testSwitchUser()872 public void testSwitchUser() { 873 ActivityManager am = mContext.getSystemService(ActivityManager.class); 874 final int startUser = am.getCurrentUser(); 875 UserInfo user = createUser("User", 0); 876 assertThat(user).isNotNull(); 877 // Switch to the user just created. 878 switchUser(user.id, null, true); 879 // Switch back to the starting user. 880 switchUser(startUser, null, true); 881 } 882 883 @LargeTest 884 @Test testSwitchUserByHandle()885 public void testSwitchUserByHandle() { 886 ActivityManager am = mContext.getSystemService(ActivityManager.class); 887 final int startUser = am.getCurrentUser(); 888 UserInfo user = createUser("User", 0); 889 assertThat(user).isNotNull(); 890 // Switch to the user just created. 891 switchUser(-1, user.getUserHandle(), false); 892 // Switch back to the starting user. 893 switchUser(-1, UserHandle.of(startUser), false); 894 } 895 896 @Test testSwitchUserByHandle_ThrowsException()897 public void testSwitchUserByHandle_ThrowsException() { 898 ActivityManager am = mContext.getSystemService(ActivityManager.class); 899 assertThrows(IllegalArgumentException.class, () -> am.switchUser(null)); 900 } 901 902 @MediumTest 903 @Test testConcurrentUserCreate()904 public void testConcurrentUserCreate() throws Exception { 905 int userCount = mUserManager.getUserCount(); 906 int maxSupportedUsers = UserManager.getMaxSupportedUsers(); 907 int canBeCreatedCount = maxSupportedUsers - userCount; 908 // Test exceeding the limit while running in parallel 909 int createUsersCount = canBeCreatedCount + 5; 910 ExecutorService es = Executors.newCachedThreadPool(); 911 AtomicInteger created = new AtomicInteger(); 912 for (int i = 0; i < createUsersCount; i++) { 913 final String userName = "testConcUser" + i; 914 es.submit(() -> { 915 UserInfo user = mUserManager.createUser(userName, 0); 916 if (user != null) { 917 created.incrementAndGet(); 918 synchronized (mUserRemoveLock) { 919 usersToRemove.add(user.id); 920 } 921 } 922 }); 923 } 924 es.shutdown(); 925 es.awaitTermination(20, TimeUnit.SECONDS); 926 assertThat(mUserManager.getUserCount()).isEqualTo(maxSupportedUsers); 927 assertThat(created.get()).isEqualTo(canBeCreatedCount); 928 } 929 930 @MediumTest 931 @Test testGetUserHandles_createNewUser_shouldFindNewUser()932 public void testGetUserHandles_createNewUser_shouldFindNewUser() { 933 UserInfo user = createUser("Guest 1", UserManager.USER_TYPE_FULL_GUEST, /*flags*/ 0); 934 935 boolean found = false; 936 List<UserHandle> userHandles = mUserManager.getUserHandles(/* excludeDying= */ true); 937 for (UserHandle userHandle: userHandles) { 938 if (userHandle.getIdentifier() == user.id) { 939 found = true; 940 } 941 } 942 943 assertThat(found).isTrue(); 944 } 945 946 @Test testCreateProfile_withContextUserId()947 public void testCreateProfile_withContextUserId() throws Exception { 948 assumeManagedUsersSupported(); 949 final int primaryUserId = mUserManager.getPrimaryUser().id; 950 951 UserInfo userProfile = createProfileForUser("Managed 1", 952 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 953 assertThat(userProfile).isNotNull(); 954 955 UserManager um = (UserManager) mContext.createPackageContextAsUser( 956 "android", 0, mUserManager.getPrimaryUser().getUserHandle()) 957 .getSystemService(Context.USER_SERVICE); 958 959 List<UserHandle> profiles = um.getAllProfiles(); 960 assertThat(profiles.size()).isEqualTo(2); 961 assertThat(profiles.get(0).equals(userProfile.getUserHandle()) 962 || profiles.get(1).equals(userProfile.getUserHandle())).isTrue(); 963 } 964 965 @Test testSetUserName_withContextUserId()966 public void testSetUserName_withContextUserId() throws Exception { 967 assumeManagedUsersSupported(); 968 final int primaryUserId = mUserManager.getPrimaryUser().id; 969 970 UserInfo userInfo1 = createProfileForUser("Managed 1", 971 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 972 assertThat(userInfo1).isNotNull(); 973 974 UserManager um = (UserManager) mContext.createPackageContextAsUser( 975 "android", 0, userInfo1.getUserHandle()) 976 .getSystemService(Context.USER_SERVICE); 977 978 final String newName = "Managed_user 1"; 979 um.setUserName(newName); 980 981 UserInfo userInfo = mUserManager.getUserInfo(userInfo1.id); 982 assertThat(userInfo.name).isEqualTo(newName); 983 984 // get user name from getUserName using context.getUserId 985 assertThat(um.getUserName()).isEqualTo(newName); 986 } 987 988 @Test testGetUserName_withContextUserId()989 public void testGetUserName_withContextUserId() throws Exception { 990 final String userName = "User 2"; 991 UserInfo user2 = createUser(userName, 0); 992 assertThat(user2).isNotNull(); 993 994 UserManager um = (UserManager) mContext.createPackageContextAsUser( 995 "android", 0, user2.getUserHandle()) 996 .getSystemService(Context.USER_SERVICE); 997 998 assertThat(um.getUserName()).isEqualTo(userName); 999 } 1000 1001 @Test testGetUserIcon_withContextUserId()1002 public void testGetUserIcon_withContextUserId() throws Exception { 1003 assumeManagedUsersSupported(); 1004 final int primaryUserId = mUserManager.getPrimaryUser().id; 1005 1006 UserInfo userInfo1 = createProfileForUser("Managed 1", 1007 UserManager.USER_TYPE_PROFILE_MANAGED, primaryUserId); 1008 assertThat(userInfo1).isNotNull(); 1009 1010 UserManager um = (UserManager) mContext.createPackageContextAsUser( 1011 "android", 0, userInfo1.getUserHandle()) 1012 .getSystemService(Context.USER_SERVICE); 1013 1014 final String newName = "Managed_user 1"; 1015 um.setUserName(newName); 1016 1017 UserInfo userInfo = mUserManager.getUserInfo(userInfo1.id); 1018 assertThat(userInfo.name).isEqualTo(newName); 1019 } 1020 isPackageInstalledForUser(String packageName, int userId)1021 private boolean isPackageInstalledForUser(String packageName, int userId) { 1022 try { 1023 return mPackageManager.getPackageInfoAsUser(packageName, 0, userId) != null; 1024 } catch (PackageManager.NameNotFoundException e) { 1025 return false; 1026 } 1027 } 1028 1029 /** 1030 * @param userId value will be used to call switchUser(int) only if ignoreHandle is false. 1031 * @param user value will be used to call switchUser(UserHandle) only if ignoreHandle is true. 1032 * @param ignoreHandle if true, switchUser(int) will be called with the provided userId, 1033 * else, switchUser(UserHandle) will be called with the provided user. 1034 */ switchUser(int userId, UserHandle user, boolean ignoreHandle)1035 private void switchUser(int userId, UserHandle user, boolean ignoreHandle) { 1036 synchronized (mUserSwitchLock) { 1037 ActivityManager am = mContext.getSystemService(ActivityManager.class); 1038 if (ignoreHandle) { 1039 am.switchUser(userId); 1040 } else { 1041 am.switchUser(user); 1042 } 1043 long time = System.currentTimeMillis(); 1044 try { 1045 mUserSwitchLock.wait(SWITCH_USER_TIMEOUT_MILLIS); 1046 } catch (InterruptedException ie) { 1047 Thread.currentThread().interrupt(); 1048 return; 1049 } 1050 if (System.currentTimeMillis() - time > SWITCH_USER_TIMEOUT_MILLIS) { 1051 fail("Timeout waiting for the user switch to u" 1052 + (ignoreHandle ? userId : user.getIdentifier())); 1053 } 1054 } 1055 } 1056 removeUser(int userId)1057 private void removeUser(int userId) { 1058 synchronized (mUserRemoveLock) { 1059 mUserManager.removeUser(userId); 1060 waitForUserRemovalLocked(userId); 1061 } 1062 } 1063 1064 @GuardedBy("mUserRemoveLock") waitForUserRemovalLocked(int userId)1065 private void waitForUserRemovalLocked(int userId) { 1066 long time = System.currentTimeMillis(); 1067 while (mUserManager.getUserInfo(userId) != null) { 1068 try { 1069 mUserRemoveLock.wait(REMOVE_CHECK_INTERVAL_MILLIS); 1070 } catch (InterruptedException ie) { 1071 Thread.currentThread().interrupt(); 1072 return; 1073 } 1074 if (System.currentTimeMillis() - time > REMOVE_TIMEOUT_MILLIS) { 1075 fail("Timeout waiting for removeUser. userId = " + userId); 1076 } 1077 } 1078 } 1079 createUser(String name, int flags)1080 private UserInfo createUser(String name, int flags) { 1081 UserInfo user = mUserManager.createUser(name, flags); 1082 if (user != null) { 1083 usersToRemove.add(user.id); 1084 } 1085 return user; 1086 } 1087 createUser(String name, String userType, int flags)1088 private UserInfo createUser(String name, String userType, int flags) { 1089 UserInfo user = mUserManager.createUser(name, userType, flags); 1090 if (user != null) { 1091 usersToRemove.add(user.id); 1092 } 1093 return user; 1094 } 1095 createProfileForUser(String name, String userType, int userHandle)1096 private UserInfo createProfileForUser(String name, String userType, int userHandle) { 1097 return createProfileForUser(name, userType, userHandle, null); 1098 } 1099 createProfileForUser(String name, String userType, int userHandle, String[] disallowedPackages)1100 private UserInfo createProfileForUser(String name, String userType, int userHandle, 1101 String[] disallowedPackages) { 1102 UserInfo profile = mUserManager.createProfileForUser( 1103 name, userType, 0, userHandle, disallowedPackages); 1104 if (profile != null) { 1105 usersToRemove.add(profile.id); 1106 } 1107 return profile; 1108 } 1109 createProfileEvenWhenDisallowedForUser(String name, String userType, int userHandle)1110 private UserInfo createProfileEvenWhenDisallowedForUser(String name, String userType, 1111 int userHandle) { 1112 UserInfo profile = mUserManager.createProfileForUserEvenWhenDisallowed( 1113 name, userType, 0, userHandle, null); 1114 if (profile != null) { 1115 usersToRemove.add(profile.id); 1116 } 1117 return profile; 1118 } 1119 createRestrictedProfile(String name)1120 private UserInfo createRestrictedProfile(String name) { 1121 UserInfo profile = mUserManager.createRestrictedProfile(name); 1122 if (profile != null) { 1123 usersToRemove.add(profile.id); 1124 } 1125 return profile; 1126 } 1127 assumeManagedUsersSupported()1128 private void assumeManagedUsersSupported() { 1129 // In Automotive, if headless system user is enabled, a managed user cannot be created 1130 // under a primary user. 1131 assumeTrue("device doesn't support managed users", 1132 mPackageManager.hasSystemFeature(PackageManager.FEATURE_MANAGED_USERS) 1133 && (!isAutomotive() || !UserManager.isHeadlessSystemUserMode())); 1134 } 1135 isAutomotive()1136 private boolean isAutomotive() { 1137 return mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE); 1138 } 1139 asHandle(int userId)1140 private static UserHandle asHandle(int userId) { 1141 return new UserHandle(userId); 1142 } 1143 } 1144