1 /* 2 * Copyright (C) 2016 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.deviceowner; 18 19 import android.app.ActivityManager; 20 import android.app.Service; 21 import android.app.admin.DeviceAdminReceiver; 22 import android.app.admin.DevicePolicyManager; 23 import android.content.BroadcastReceiver; 24 import android.content.ComponentName; 25 import android.content.Context; 26 import android.content.Intent; 27 import android.content.IntentFilter; 28 import android.content.ServiceConnection; 29 import android.content.pm.PackageManager; 30 import android.os.IBinder; 31 import android.os.PersistableBundle; 32 import android.os.Process; 33 import android.os.RemoteException; 34 import android.os.UserHandle; 35 import android.os.UserManager; 36 import android.provider.Settings; 37 import androidx.localbroadcastmanager.content.LocalBroadcastManager; 38 import android.util.Log; 39 40 import java.lang.reflect.InvocationTargetException; 41 import java.lang.reflect.Method; 42 import java.util.Collections; 43 import java.util.List; 44 import java.util.Set; 45 import java.util.concurrent.Semaphore; 46 import java.util.concurrent.LinkedBlockingQueue; 47 import java.util.concurrent.TimeUnit; 48 import java.util.function.Predicate; 49 import java.util.stream.Collectors; 50 51 /** 52 * Test {@link DevicePolicyManager#createAndManageUser}. 53 */ 54 public class CreateAndManageUserTest extends BaseDeviceOwnerTest { 55 private static final String TAG = "CreateAndManageUserTest"; 56 57 private static final String BROADCAST_EXTRA = "broadcastExtra"; 58 private static final String ACTION_EXTRA = "actionExtra"; 59 private static final String SERIAL_EXTRA = "serialExtra"; 60 private static final String PROFILE_OWNER_EXTRA = "profileOwnerExtra"; 61 private static final String SETUP_COMPLETE_EXTRA = "setupCompleteExtra"; 62 private static final int BROADCAST_TIMEOUT = 15_000; 63 private static final int USER_SWITCH_DELAY = 10_000; 64 65 private static final String AFFILIATION_ID = "affiliation.id"; 66 private static final String EXTRA_AFFILIATION_ID = "affiliationIdExtra"; 67 private static final String EXTRA_METHOD_NAME = "methodName"; 68 private static final long ON_ENABLED_TIMEOUT_SECONDS = 120; 69 70 71 private PackageManager mPackageManager; 72 private ActivityManager mActivityManager; 73 private volatile boolean mReceived; 74 private volatile boolean mTestProfileOwnerWasUsed; 75 private volatile boolean mSetupComplete; 76 77 @Override 78 protected void setUp() throws Exception { 79 super.setUp(); 80 mPackageManager = mContext.getPackageManager(); 81 mActivityManager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE); 82 } 83 84 @Override 85 protected void tearDown() throws Exception { 86 mDevicePolicyManager.clearUserRestriction(getWho(), UserManager.DISALLOW_ADD_USER); 87 mDevicePolicyManager.clearUserRestriction(getWho(), UserManager.DISALLOW_REMOVE_USER); 88 super.tearDown(); 89 } 90 91 // This class is used by createAndManageUserTest as profile owner for the new user. When 92 // enabled, it sends a broadcast to signal success. 93 public static class TestProfileOwner extends DeviceAdminReceiver { 94 @Override 95 public void onEnabled(Context context, Intent intent) { 96 if (intent.getBooleanExtra(BROADCAST_EXTRA, false)) { 97 Intent i = new Intent(intent.getStringExtra(ACTION_EXTRA)); 98 UserManager userManager = (UserManager) 99 context.getSystemService(Context.USER_SERVICE); 100 long serial = intent.getLongExtra(SERIAL_EXTRA, 0); 101 UserHandle handle = userManager.getUserForSerialNumber(serial); 102 i.putExtra(PROFILE_OWNER_EXTRA, true); 103 // find value of user_setup_complete on new user, and send the result back 104 try { 105 boolean setupComplete = (Settings.Secure.getInt(context.getContentResolver(), 106 "user_setup_complete") == 1); 107 i.putExtra(SETUP_COMPLETE_EXTRA, setupComplete); 108 } catch (Settings.SettingNotFoundException e) { 109 fail("Did not find settings user_setup_complete"); 110 } 111 112 context.sendBroadcastAsUser(i, handle); 113 } 114 } 115 116 public static ComponentName getComponentName() { 117 return new ComponentName(CreateAndManageUserTest.class.getPackage().getName(), 118 TestProfileOwner.class.getName()); 119 } 120 } 121 122 private void waitForBroadcastLocked() { 123 // Wait for broadcast. Time is measured in a while loop because of spurious wakeups. 124 final long initTime = System.currentTimeMillis(); 125 while (!mReceived) { 126 try { 127 wait(BROADCAST_TIMEOUT - (System.currentTimeMillis() - initTime)); 128 } catch (InterruptedException e) { 129 fail("InterruptedException: " + e.getMessage()); 130 } 131 if (!mReceived && System.currentTimeMillis() - initTime > BROADCAST_TIMEOUT) { 132 fail("Timeout while waiting for broadcast after createAndManageUser."); 133 } 134 } 135 } 136 137 // This test will create a user that will get passed a bundle that we specify. The bundle will 138 // contain an action and a serial (for user handle) to broadcast to notify the test that the 139 // configuration was triggered. 140 private void createAndManageUserTest(final int flags) { 141 // This test sets a profile owner on the user, which requires the managed_users feature. 142 if (!mPackageManager.hasSystemFeature(PackageManager.FEATURE_MANAGED_USERS)) { 143 return; 144 } 145 146 final boolean expectedSetupComplete = (flags & DevicePolicyManager.SKIP_SETUP_WIZARD) != 0; 147 UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE); 148 149 UserHandle firstUser = Process.myUserHandle(); 150 final String testUserName = "TestUser_" + System.currentTimeMillis(); 151 String action = "com.android.cts.TEST_USER_ACTION"; 152 PersistableBundle bundle = new PersistableBundle(); 153 bundle.putBoolean(BROADCAST_EXTRA, true); 154 bundle.putLong(SERIAL_EXTRA, userManager.getSerialNumberForUser(firstUser)); 155 bundle.putString(ACTION_EXTRA, action); 156 157 mReceived = false; 158 mTestProfileOwnerWasUsed = false; 159 mSetupComplete = !expectedSetupComplete; 160 BroadcastReceiver receiver = new BroadcastReceiver() { 161 @Override 162 public void onReceive(Context context, Intent intent) { 163 mReceived = true; 164 if (intent.getBooleanExtra(PROFILE_OWNER_EXTRA, false)) { 165 mTestProfileOwnerWasUsed = true; 166 } 167 mSetupComplete = intent.getBooleanExtra(SETUP_COMPLETE_EXTRA, 168 !expectedSetupComplete); 169 synchronized (CreateAndManageUserTest.this) { 170 CreateAndManageUserTest.this.notify(); 171 } 172 } 173 }; 174 175 IntentFilter filter = new IntentFilter(); 176 filter.addAction(action); 177 mContext.registerReceiver(receiver, filter); 178 179 synchronized (this) { 180 UserHandle userHandle = mDevicePolicyManager.createAndManageUser(getWho(), testUserName, 181 TestProfileOwner.getComponentName(), bundle, flags); 182 assertNotNull(userHandle); 183 184 mDevicePolicyManager.switchUser(getWho(), userHandle); 185 try { 186 wait(USER_SWITCH_DELAY); 187 } catch (InterruptedException e) { 188 fail("InterruptedException: " + e.getMessage()); 189 } 190 mDevicePolicyManager.switchUser(getWho(), firstUser); 191 192 waitForBroadcastLocked(); 193 194 assertTrue(mReceived); 195 assertTrue(mTestProfileOwnerWasUsed); 196 assertEquals(expectedSetupComplete, mSetupComplete); 197 198 assertTrue(mDevicePolicyManager.removeUser(getWho(), userHandle)); 199 200 userHandle = null; 201 } 202 203 mContext.unregisterReceiver(receiver); 204 } 205 206 public void testCreateAndManageUser() throws Exception { 207 String testUserName = "TestUser_" + System.currentTimeMillis(); 208 209 UserHandle userHandle = mDevicePolicyManager.createAndManageUser( 210 getWho(), 211 testUserName, 212 getWho(), 213 null, 214 /* flags */ 0); 215 Log.d(TAG, "User create: " + userHandle); 216 } 217 218 public void testCreateAndManageUser_LowStorage() throws Exception { 219 String testUserName = "TestUser_" + System.currentTimeMillis(); 220 221 try { 222 mDevicePolicyManager.createAndManageUser( 223 getWho(), 224 testUserName, 225 getWho(), 226 null, 227 /* flags */ 0); 228 fail("createAndManageUser should throw UserOperationException"); 229 } catch (UserManager.UserOperationException e) { 230 assertEquals(UserManager.USER_OPERATION_ERROR_LOW_STORAGE, e.getUserOperationResult()); 231 } 232 } 233 234 public void testCreateAndManageUser_MaxUsers() throws Exception { 235 String testUserName = "TestUser_" + System.currentTimeMillis(); 236 237 try { 238 mDevicePolicyManager.createAndManageUser( 239 getWho(), 240 testUserName, 241 getWho(), 242 null, 243 /* flags */ 0); 244 fail("createAndManageUser should throw UserOperationException"); 245 } catch (UserManager.UserOperationException e) { 246 assertEquals(UserManager.USER_OPERATION_ERROR_MAX_USERS, e.getUserOperationResult()); 247 } 248 } 249 250 public void testCreateAndManageUser_GetSecondaryUsers() throws Exception { 251 String testUserName = "TestUser_" + System.currentTimeMillis(); 252 253 UserHandle userHandle = mDevicePolicyManager.createAndManageUser( 254 getWho(), 255 testUserName, 256 getWho(), 257 null, 258 /* flags */ 0); 259 Log.d(TAG, "User create: " + userHandle); 260 261 List<UserHandle> secondaryUsers = mDevicePolicyManager.getSecondaryUsers(getWho()); 262 assertEquals(1, secondaryUsers.size()); 263 assertEquals(userHandle, secondaryUsers.get(0)); 264 } 265 266 public void testCreateAndManageUser_SwitchUser() throws Exception { 267 LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance( 268 getContext()); 269 270 String testUserName = "TestUser_" + System.currentTimeMillis(); 271 272 UserHandle userHandle = mDevicePolicyManager.createAndManageUser( 273 getWho(), 274 testUserName, 275 getWho(), 276 null, 277 /* flags */ 0); 278 Log.d(TAG, "User create: " + userHandle); 279 280 LocalBroadcastReceiver broadcastReceiver = new LocalBroadcastReceiver(); 281 localBroadcastManager.registerReceiver(broadcastReceiver, 282 new IntentFilter(BasicAdminReceiver.ACTION_USER_SWITCHED)); 283 try { 284 assertTrue(mDevicePolicyManager.switchUser(getWho(), userHandle)); 285 assertEquals(userHandle, broadcastReceiver.waitForBroadcastReceived()); 286 } finally { 287 localBroadcastManager.unregisterReceiver(broadcastReceiver); 288 } 289 } 290 291 public void testCreateAndManageUser_CannotStopCurrentUser() throws Exception { 292 LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance( 293 getContext()); 294 295 String testUserName = "TestUser_" + System.currentTimeMillis(); 296 297 UserHandle userHandle = mDevicePolicyManager.createAndManageUser( 298 getWho(), 299 testUserName, 300 getWho(), 301 null, 302 /* flags */ 0); 303 Log.d(TAG, "User create: " + userHandle); 304 305 LocalBroadcastReceiver broadcastReceiver = new LocalBroadcastReceiver(); 306 localBroadcastManager.registerReceiver(broadcastReceiver, 307 new IntentFilter(BasicAdminReceiver.ACTION_USER_SWITCHED)); 308 try { 309 assertTrue(mDevicePolicyManager.switchUser(getWho(), userHandle)); 310 assertEquals(userHandle, broadcastReceiver.waitForBroadcastReceived()); 311 assertEquals(UserManager.USER_OPERATION_ERROR_CURRENT_USER, 312 mDevicePolicyManager.stopUser(getWho(), userHandle)); 313 } finally { 314 localBroadcastManager.unregisterReceiver(broadcastReceiver); 315 } 316 } 317 318 public void testCreateAndManageUser_StartInBackground() throws Exception { 319 LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance( 320 getContext()); 321 322 String testUserName = "TestUser_" + System.currentTimeMillis(); 323 324 UserHandle userHandle = mDevicePolicyManager.createAndManageUser( 325 getWho(), 326 testUserName, 327 getWho(), 328 null, 329 /* flags */ 0); 330 Log.d(TAG, "User create: " + userHandle); 331 332 LocalBroadcastReceiver broadcastReceiver = new LocalBroadcastReceiver(); 333 localBroadcastManager.registerReceiver(broadcastReceiver, 334 new IntentFilter(BasicAdminReceiver.ACTION_USER_STARTED)); 335 336 try { 337 // Start user in background and wait for onUserStarted 338 assertEquals(UserManager.USER_OPERATION_SUCCESS, 339 mDevicePolicyManager.startUserInBackground(getWho(), userHandle)); 340 assertEquals(userHandle, broadcastReceiver.waitForBroadcastReceived()); 341 } finally { 342 localBroadcastManager.unregisterReceiver(broadcastReceiver); 343 } 344 } 345 346 public void testCreateAndManageUser_StartInBackground_MaxRunningUsers() throws Exception { 347 String testUserName = "TestUser_" + System.currentTimeMillis(); 348 349 UserHandle userHandle = mDevicePolicyManager.createAndManageUser( 350 getWho(), 351 testUserName, 352 getWho(), 353 null, 354 /* flags */ 0); 355 Log.d(TAG, "User create: " + userHandle); 356 357 // Start user in background and should receive max running users error 358 assertEquals(UserManager.USER_OPERATION_ERROR_MAX_RUNNING_USERS, 359 mDevicePolicyManager.startUserInBackground(getWho(), userHandle)); 360 } 361 362 public void testCreateAndManageUser_StopUser() throws Exception { 363 LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance( 364 getContext()); 365 366 String testUserName = "TestUser_" + System.currentTimeMillis(); 367 368 UserHandle userHandle = mDevicePolicyManager.createAndManageUser( 369 getWho(), 370 testUserName, 371 getWho(), 372 null, 373 /* flags */ 0); 374 Log.d(TAG, "User create: " + userHandle); 375 assertEquals(UserManager.USER_OPERATION_SUCCESS, 376 mDevicePolicyManager.startUserInBackground(getWho(), userHandle)); 377 378 LocalBroadcastReceiver broadcastReceiver = new LocalBroadcastReceiver(); 379 localBroadcastManager.registerReceiver(broadcastReceiver, 380 new IntentFilter(BasicAdminReceiver.ACTION_USER_STOPPED)); 381 382 try { 383 assertEquals(UserManager.USER_OPERATION_SUCCESS, 384 mDevicePolicyManager.stopUser(getWho(), userHandle)); 385 assertEquals(userHandle, broadcastReceiver.waitForBroadcastReceived()); 386 } finally { 387 localBroadcastManager.unregisterReceiver(broadcastReceiver); 388 } 389 } 390 391 public void testCreateAndManageUser_StopEphemeralUser_DisallowRemoveUser() throws Exception { 392 LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance( 393 getContext()); 394 395 String testUserName = "TestUser_" + System.currentTimeMillis(); 396 397 // Set DISALLOW_REMOVE_USER restriction 398 mDevicePolicyManager.addUserRestriction(getWho(), UserManager.DISALLOW_REMOVE_USER); 399 400 UserHandle userHandle = mDevicePolicyManager.createAndManageUser( 401 getWho(), 402 testUserName, 403 getWho(), 404 null, 405 DevicePolicyManager.MAKE_USER_EPHEMERAL); 406 Log.d(TAG, "User create: " + userHandle); 407 assertEquals(UserManager.USER_OPERATION_SUCCESS, 408 mDevicePolicyManager.startUserInBackground(getWho(), userHandle)); 409 410 LocalBroadcastReceiver broadcastReceiver = new LocalBroadcastReceiver(); 411 localBroadcastManager.registerReceiver(broadcastReceiver, 412 new IntentFilter(BasicAdminReceiver.ACTION_USER_REMOVED)); 413 414 try { 415 assertEquals(UserManager.USER_OPERATION_SUCCESS, 416 mDevicePolicyManager.stopUser(getWho(), userHandle)); 417 assertEquals(userHandle, broadcastReceiver.waitForBroadcastReceived()); 418 } finally { 419 localBroadcastManager.unregisterReceiver(broadcastReceiver); 420 // Clear DISALLOW_REMOVE_USER restriction 421 mDevicePolicyManager.clearUserRestriction(getWho(), UserManager.DISALLOW_REMOVE_USER); 422 } 423 } 424 425 @SuppressWarnings("unused") 426 private static void logoutUser(Context context, DevicePolicyManager devicePolicyManager, 427 ComponentName componentName) { 428 assertEquals("cannot logout user", UserManager.USER_OPERATION_SUCCESS, 429 devicePolicyManager.logoutUser(componentName)); 430 } 431 432 public void testCreateAndManageUser_LogoutUser() throws Exception { 433 LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance( 434 getContext()); 435 436 LocalBroadcastReceiver broadcastReceiver = new LocalBroadcastReceiver(); 437 localBroadcastManager.registerReceiver(broadcastReceiver, 438 new IntentFilter(BasicAdminReceiver.ACTION_USER_STOPPED)); 439 440 try { 441 UserHandle userHandle = runCrossUserVerification( 442 /* createAndManageUserFlags */ 0, "logoutUser"); 443 assertEquals(userHandle, broadcastReceiver.waitForBroadcastReceived()); 444 } finally { 445 localBroadcastManager.unregisterReceiver(broadcastReceiver); 446 } 447 } 448 449 @SuppressWarnings("unused") 450 private static void assertAffiliatedUser(Context context, 451 DevicePolicyManager devicePolicyManager, ComponentName componentName) { 452 assertTrue("not affiliated user", devicePolicyManager.isAffiliatedUser()); 453 } 454 455 public void testCreateAndManageUser_Affiliated() throws Exception { 456 runCrossUserVerification(/* createAndManageUserFlags */ 0, "assertAffiliatedUser"); 457 PrimaryUserService.assertCrossUserCallArrived(); 458 } 459 460 @SuppressWarnings("unused") 461 private static void assertEphemeralUser(Context context, 462 DevicePolicyManager devicePolicyManager, ComponentName componentName) { 463 assertTrue("not ephemeral user", devicePolicyManager.isEphemeralUser(componentName)); 464 } 465 466 public void testCreateAndManageUser_Ephemeral() throws Exception { 467 runCrossUserVerification(DevicePolicyManager.MAKE_USER_EPHEMERAL, "assertEphemeralUser"); 468 PrimaryUserService.assertCrossUserCallArrived(); 469 } 470 471 @SuppressWarnings("unused") 472 private static void assertAllSystemAppsInstalled(Context context, 473 DevicePolicyManager devicePolicyManager, ComponentName componentName) { 474 PackageManager packageManager = context.getPackageManager(); 475 // First get a set of installed package names 476 Set<String> installedPackageNames = packageManager 477 .getInstalledApplications(/* flags */ 0) 478 .stream() 479 .map(applicationInfo -> applicationInfo.packageName) 480 .collect(Collectors.toSet()); 481 // Then filter all package names by those that are not installed 482 Set<String> uninstalledPackageNames = packageManager 483 .getInstalledApplications(PackageManager.MATCH_UNINSTALLED_PACKAGES) 484 .stream() 485 .map(applicationInfo -> applicationInfo.packageName) 486 .filter(((Predicate<String>) installedPackageNames::contains).negate()) 487 .collect(Collectors.toSet()); 488 // Assert that all apps are installed 489 assertTrue("system apps not installed: " + uninstalledPackageNames, 490 uninstalledPackageNames.isEmpty()); 491 } 492 493 public void testCreateAndManageUser_LeaveAllSystemApps() throws Exception { 494 runCrossUserVerification( 495 DevicePolicyManager.LEAVE_ALL_SYSTEM_APPS_ENABLED, "assertAllSystemAppsInstalled"); 496 PrimaryUserService.assertCrossUserCallArrived(); 497 } 498 499 private UserHandle runCrossUserVerification(int createAndManageUserFlags, String methodName) 500 throws Exception { 501 String testUserName = "TestUser_" + System.currentTimeMillis(); 502 503 // Set affiliation id to allow communication. 504 mDevicePolicyManager.setAffiliationIds(getWho(), Collections.singleton(AFFILIATION_ID)); 505 506 // Pack the affiliation id in a bundle so the secondary user can get it. 507 PersistableBundle bundle = new PersistableBundle(); 508 bundle.putString(EXTRA_AFFILIATION_ID, AFFILIATION_ID); 509 bundle.putString(EXTRA_METHOD_NAME, methodName); 510 511 UserHandle userHandle = mDevicePolicyManager.createAndManageUser( 512 getWho(), 513 testUserName, 514 SecondaryUserAdminReceiver.getComponentName(getContext()), 515 bundle, 516 createAndManageUserFlags); 517 Log.d(TAG, "User create: " + userHandle); 518 assertEquals(UserManager.USER_OPERATION_SUCCESS, 519 mDevicePolicyManager.startUserInBackground(getWho(), userHandle)); 520 521 return userHandle; 522 } 523 524 public void testCreateAndManageUser_SkipSetupWizard() { 525 createAndManageUserTest(DevicePolicyManager.SKIP_SETUP_WIZARD); 526 } 527 528 public void testCreateAndManageUser_DontSkipSetupWizard() { 529 if (!mActivityManager.isRunningInTestHarness()) { 530 // In test harness, the setup wizard will be disabled by default, so this test is always 531 // failing. 532 createAndManageUserTest(0); 533 } 534 } 535 536 // createAndManageUser should circumvent the DISALLOW_ADD_USER restriction 537 public void testCreateAndManageUser_AddRestrictionSet() { 538 mDevicePolicyManager.addUserRestriction(getWho(), UserManager.DISALLOW_ADD_USER); 539 540 UserHandle userHandle = mDevicePolicyManager.createAndManageUser(getWho(), "Test User", 541 getWho(), null, 0); 542 assertNotNull(userHandle); 543 } 544 545 public void testCreateAndManageUser_RemoveRestrictionSet() { 546 mDevicePolicyManager.addUserRestriction(getWho(), UserManager.DISALLOW_REMOVE_USER); 547 548 UserHandle userHandle = mDevicePolicyManager.createAndManageUser(getWho(), "Test User", 549 getWho(), null, 0); 550 assertNotNull(userHandle); 551 552 boolean removed = mDevicePolicyManager.removeUser(getWho(), userHandle); 553 // When the device owner itself has set the user restriction, it should still be allowed 554 // to remove a user. 555 assertTrue(removed); 556 } 557 558 public void testUserAddedOrRemovedBroadcasts() throws InterruptedException { 559 LocalBroadcastReceiver receiver = new LocalBroadcastReceiver(); 560 LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance( 561 getContext()); 562 localBroadcastManager.registerReceiver(receiver, 563 new IntentFilter(BasicAdminReceiver.ACTION_USER_ADDED)); 564 UserHandle userHandle; 565 try { 566 userHandle = mDevicePolicyManager.createAndManageUser(getWho(), "Test User", getWho(), 567 null, 0); 568 assertNotNull(userHandle); 569 assertEquals(userHandle, receiver.waitForBroadcastReceived()); 570 } finally { 571 localBroadcastManager.unregisterReceiver(receiver); 572 } 573 localBroadcastManager.registerReceiver(receiver, 574 new IntentFilter(BasicAdminReceiver.ACTION_USER_REMOVED)); 575 try { 576 assertTrue(mDevicePolicyManager.removeUser(getWho(), userHandle)); 577 assertEquals(userHandle, receiver.waitForBroadcastReceived()); 578 } finally { 579 localBroadcastManager.unregisterReceiver(receiver); 580 } 581 } 582 583 static class LocalBroadcastReceiver extends BroadcastReceiver { 584 private LinkedBlockingQueue<UserHandle> mQueue = new LinkedBlockingQueue<UserHandle>(1); 585 586 @Override 587 public void onReceive(Context context, Intent intent) { 588 UserHandle userHandle = intent.getParcelableExtra(BasicAdminReceiver.EXTRA_USER_HANDLE); 589 Log.d(TAG, "broadcast receiver received " + intent + " with userHandle " 590 + userHandle); 591 mQueue.offer(userHandle); 592 593 } 594 595 public UserHandle waitForBroadcastReceived() throws InterruptedException { 596 return mQueue.poll(BROADCAST_TIMEOUT, TimeUnit.MILLISECONDS); 597 } 598 } 599 600 public static final class PrimaryUserService extends Service { 601 private static final Semaphore sSemaphore = new Semaphore(0); 602 private static String sError = null; 603 604 private final ICrossUserService.Stub mBinder = new ICrossUserService.Stub() { 605 public void onEnabledCalled(String error) { 606 Log.d(TAG, "onEnabledCalled on primary user"); 607 sError = error; 608 sSemaphore.release(); 609 } 610 }; 611 612 @Override 613 public IBinder onBind(Intent intent) { 614 return mBinder; 615 } 616 617 static void assertCrossUserCallArrived() throws Exception { 618 assertTrue(sSemaphore.tryAcquire(ON_ENABLED_TIMEOUT_SECONDS, TimeUnit.SECONDS)); 619 if (sError != null) { 620 throw new Exception(sError); 621 } 622 } 623 } 624 625 public static final class SecondaryUserAdminReceiver extends DeviceAdminReceiver { 626 @Override 627 public void onEnabled(Context context, Intent intent) { 628 Log.d(TAG, "onEnabled called"); 629 DevicePolicyManager dpm = context.getSystemService(DevicePolicyManager.class); 630 ComponentName who = getComponentName(context); 631 632 // Set affiliation ids 633 dpm.setAffiliationIds( 634 who, Collections.singleton(intent.getStringExtra(EXTRA_AFFILIATION_ID))); 635 636 String error = null; 637 try { 638 Method method = CreateAndManageUserTest.class.getDeclaredMethod( 639 intent.getStringExtra(EXTRA_METHOD_NAME), Context.class, 640 DevicePolicyManager.class, ComponentName.class); 641 method.setAccessible(true); 642 method.invoke(null, context, dpm, who); 643 } catch (NoSuchMethodException | IllegalAccessException e) { 644 error = e.toString(); 645 } catch (InvocationTargetException e) { 646 error = e.getCause().toString(); 647 } 648 649 // Call all affiliated users 650 final List<UserHandle> targetUsers = dpm.getBindDeviceAdminTargetUsers(who); 651 assertEquals(1, targetUsers.size()); 652 pingTargetUser(context, dpm, targetUsers.get(0), error); 653 } 654 655 private void pingTargetUser(Context context, DevicePolicyManager dpm, UserHandle target, 656 String error) { 657 Log.d(TAG, "Pinging target: " + target); 658 final ServiceConnection serviceConnection = new ServiceConnection() { 659 @Override 660 public void onServiceConnected(ComponentName name, IBinder service) { 661 Log.d(TAG, "onServiceConnected is called in " + Thread.currentThread().getName()); 662 ICrossUserService crossUserService = ICrossUserService 663 .Stub.asInterface(service); 664 try { 665 crossUserService.onEnabledCalled(error); 666 } catch (RemoteException re) { 667 Log.e(TAG, "Error when calling primary user", re); 668 // Do nothing, primary user will time out 669 } 670 } 671 672 @Override 673 public void onServiceDisconnected(ComponentName name) { 674 Log.d(TAG, "onServiceDisconnected is called"); 675 } 676 }; 677 final Intent serviceIntent = new Intent(context, PrimaryUserService.class); 678 assertTrue(dpm.bindDeviceAdminServiceAsUser( 679 getComponentName(context), 680 serviceIntent, 681 serviceConnection, 682 Context.BIND_AUTO_CREATE, 683 target)); 684 } 685 686 public static ComponentName getComponentName(Context context) { 687 return new ComponentName(context, SecondaryUserAdminReceiver.class); 688 } 689 } 690 } 691
