DpmMockContext.java revision 05dc9f764c9d399add8b7495e680f66d098c55eb
1/* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.server.devicepolicy; 18 19import android.accounts.Account; 20import android.accounts.AccountManager; 21import android.app.AlarmManager; 22import android.app.IActivityManager; 23import android.app.NotificationManager; 24import android.app.backup.IBackupManager; 25import android.content.BroadcastReceiver; 26import android.content.ContentResolver; 27import android.content.Context; 28import android.content.Intent; 29import android.content.IntentFilter; 30import android.content.pm.ApplicationInfo; 31import android.content.pm.IPackageManager; 32import android.content.pm.PackageManager; 33import android.content.pm.PackageManagerInternal; 34import android.content.pm.UserInfo; 35import android.content.res.Resources; 36import android.media.IAudioService; 37import android.net.IIpConnectivityMetrics; 38import android.net.wifi.WifiManager; 39import android.os.Bundle; 40import android.os.Handler; 41import android.os.PowerManager.WakeLock; 42import android.os.PowerManagerInternal; 43import android.os.UserHandle; 44import android.os.UserManager; 45import android.os.UserManagerInternal; 46import android.security.KeyChain; 47import android.telephony.TelephonyManager; 48import android.test.mock.MockContentResolver; 49import android.test.mock.MockContext; 50import android.util.ArrayMap; 51import android.view.IWindowManager; 52 53import com.android.internal.widget.LockPatternUtils; 54 55import org.junit.Assert; 56import org.mockito.invocation.InvocationOnMock; 57import org.mockito.stubbing.Answer; 58 59import java.io.File; 60import java.io.IOException; 61import java.util.ArrayList; 62import java.util.List; 63import java.util.Map; 64 65import static org.mockito.Matchers.anyBoolean; 66import static org.mockito.Matchers.anyInt; 67import static org.mockito.Matchers.eq; 68import static org.mockito.Mockito.RETURNS_DEEP_STUBS; 69import static org.mockito.Mockito.mock; 70import static org.mockito.Mockito.spy; 71import static org.mockito.Mockito.when; 72 73/** 74 * Context used throughout DPMS tests. 75 */ 76public class DpmMockContext extends MockContext { 77 /** 78 * User-id of a non-system user we use throughout unit tests. 79 */ 80 public static final int CALLER_USER_HANDLE = 20; 81 82 /** 83 * UID corresponding to {@link #CALLER_USER_HANDLE}. 84 */ 85 public static final int CALLER_UID = UserHandle.getUid(CALLER_USER_HANDLE, 20123); 86 87 /** 88 * UID used when a caller is on the system user. 89 */ 90 public static final int CALLER_SYSTEM_USER_UID = 20321; 91 92 /** 93 * PID of the caller. 94 */ 95 public static final int CALLER_PID = 22222; 96 97 /** 98 * UID of the system server. 99 */ 100 public static final int SYSTEM_UID = android.os.Process.SYSTEM_UID; 101 102 /** 103 * PID of the system server. 104 */ 105 public static final int SYSTEM_PID = 11111; 106 107 public static final String ANOTHER_PACKAGE_NAME = "com.another.package.name"; 108 109 public static final int ANOTHER_UID = UserHandle.getUid(UserHandle.USER_SYSTEM, 18434); 110 111 public static class MockBinder { 112 public int callingUid = CALLER_UID; 113 public int callingPid = CALLER_PID; 114 115 public long clearCallingIdentity() { 116 final long token = (((long) callingUid) << 32) | (callingPid); 117 callingUid = SYSTEM_UID; 118 callingPid = SYSTEM_PID; 119 return token; 120 } 121 122 public void restoreCallingIdentity(long token) { 123 callingUid = (int) (token >> 32); 124 callingPid = (int) token; 125 } 126 127 public int getCallingUid() { 128 return callingUid; 129 } 130 131 public int getCallingPid() { 132 return callingPid; 133 } 134 135 public UserHandle getCallingUserHandle() { 136 return new UserHandle(UserHandle.getUserId(getCallingUid())); 137 } 138 139 public boolean isCallerUidMyUid() { 140 return callingUid == SYSTEM_UID; 141 } 142 } 143 144 public static class EnvironmentForMock { 145 public File getUserSystemDirectory(int userId) { 146 return null; 147 } 148 } 149 150 public static class BuildMock { 151 public boolean isDebuggable = true; 152 } 153 154 public static class PowerManagerForMock { 155 public WakeLock newWakeLock(int levelAndFlags, String tag) { 156 return null; 157 } 158 159 public void goToSleep(long time, int reason, int flags) { 160 } 161 162 public void reboot(String reason) { 163 } 164 } 165 166 public static class RecoverySystemForMock { 167 public void rebootWipeUserData( 168 boolean shutdown, String reason, boolean force) throws IOException { 169 } 170 } 171 172 public static class SystemPropertiesForMock { 173 public boolean getBoolean(String key, boolean def) { 174 return false; 175 } 176 177 public long getLong(String key, long def) { 178 return 0; 179 } 180 181 public String get(String key, String def) { 182 return null; 183 } 184 185 public String get(String key) { 186 return null; 187 } 188 189 public void set(String key, String value) { 190 } 191 } 192 193 public static class UserManagerForMock { 194 public boolean isSplitSystemUser() { 195 return false; 196 } 197 } 198 199 public static class SettingsForMock { 200 public int settingsSecureGetIntForUser(String name, int def, int userHandle) { 201 return 0; 202 } 203 204 public String settingsSecureGetStringForUser(String name, int userHandle) { 205 return null; 206 } 207 208 public void settingsSecurePutIntForUser(String name, int value, int userHandle) { 209 } 210 211 public void settingsSecurePutStringForUser(String name, String value, int userHandle) { 212 } 213 214 public void settingsGlobalPutStringForUser(String name, String value, int userHandle) { 215 } 216 217 public void settingsSecurePutInt(String name, int value) { 218 } 219 220 public void settingsGlobalPutInt(String name, int value) { 221 } 222 223 public void settingsSecurePutString(String name, String value) { 224 } 225 226 public void settingsGlobalPutString(String name, String value) { 227 } 228 229 public int settingsGlobalGetInt(String name, int value) { 230 return 0; 231 } 232 233 public void securityLogSetLoggingEnabledProperty(boolean enabled) { 234 } 235 236 public boolean securityLogGetLoggingEnabledProperty() { 237 return false; 238 } 239 240 public boolean securityLogIsLoggingEnabled() { 241 return false; 242 } 243 } 244 245 public static class StorageManagerForMock { 246 public boolean isFileBasedEncryptionEnabled() { 247 return false; 248 } 249 250 public boolean isNonDefaultBlockEncrypted() { 251 return false; 252 } 253 254 public boolean isEncrypted() { 255 return false; 256 } 257 258 public boolean isEncryptable() { 259 return false; 260 } 261 } 262 263 public final Context realTestContext; 264 265 /** 266 * Use this instance to verify unimplemented methods such as {@link #sendBroadcast}. 267 * (Spying on {@code this} instance will confuse mockito somehow and I got weired "wrong number 268 * of arguments" exceptions.) 269 */ 270 public final Context spiedContext; 271 272 public final File dataDir; 273 public final File systemUserDataDir; 274 275 public final MockBinder binder; 276 public final EnvironmentForMock environment; 277 public final Resources resources; 278 public final SystemPropertiesForMock systemProperties; 279 public final UserManager userManager; 280 public final UserManagerInternal userManagerInternal; 281 public final PackageManagerInternal packageManagerInternal; 282 public final UserManagerForMock userManagerForMock; 283 public final PowerManagerForMock powerManager; 284 public final PowerManagerInternal powerManagerInternal; 285 public final RecoverySystemForMock recoverySystem; 286 public final NotificationManager notificationManager; 287 public final IIpConnectivityMetrics iipConnectivityMetrics; 288 public final IWindowManager iwindowManager; 289 public final IActivityManager iactivityManager; 290 public final IPackageManager ipackageManager; 291 public final IBackupManager ibackupManager; 292 public final IAudioService iaudioService; 293 public final LockPatternUtils lockPatternUtils; 294 public final StorageManagerForMock storageManager; 295 public final WifiManager wifiManager; 296 public final SettingsForMock settings; 297 public final MockContentResolver contentResolver; 298 public final TelephonyManager telephonyManager; 299 public final AccountManager accountManager; 300 public final AlarmManager alarmManager; 301 public final KeyChain.KeyChainConnection keyChainConnection; 302 303 /** Note this is a partial mock, not a real mock. */ 304 public final PackageManager packageManager; 305 306 public final List<String> callerPermissions = new ArrayList<>(); 307 308 private final ArrayList<UserInfo> mUserInfos = new ArrayList<>(); 309 310 public final BuildMock buildMock = new BuildMock(); 311 312 /** Optional mapping of other user contexts for {@link #createPackageContextAsUser} to return */ 313 public final Map<UserHandle, Context> userContexts = new ArrayMap<>(); 314 315 public String packageName = null; 316 317 public ApplicationInfo applicationInfo = null; 318 319 // We have to keep track of broadcast receivers registered for a given intent ourselves as the 320 // DPM unit tests mock out the package manager and PackageManager.queryBroadcastReceivers() does 321 // not work. 322 private class BroadcastReceiverRegistration { 323 public final BroadcastReceiver receiver; 324 public final IntentFilter filter; 325 public final Handler scheduler; 326 327 public BroadcastReceiverRegistration(BroadcastReceiver receiver, IntentFilter filter, 328 Handler scheduler) { 329 this.receiver = receiver; 330 this.filter = filter; 331 this.scheduler = scheduler; 332 } 333 334 public void sendBroadcastIfApplicable(int userId, Intent intent) { 335 final BroadcastReceiver.PendingResult result = new BroadcastReceiver.PendingResult( 336 0 /* resultCode */, null /* resultData */, null /* resultExtras */, 337 0 /* type */, false /* ordered */, false /* sticky */, null /* token */, userId, 338 0 /* flags */); 339 if (filter.match(null, intent, false, "DpmMockContext") > 0) { 340 if (scheduler != null) { 341 scheduler.post(() -> { 342 receiver.setPendingResult(result); 343 receiver.onReceive(DpmMockContext.this, intent); 344 }); 345 } else { 346 receiver.setPendingResult(result); 347 receiver.onReceive(DpmMockContext.this, intent); 348 } 349 } 350 } 351 } 352 private List<BroadcastReceiverRegistration> mBroadcastReceivers = new ArrayList<>(); 353 354 public DpmMockContext(Context context, File dataDir) { 355 realTestContext = context; 356 357 this.dataDir = dataDir; 358 DpmTestUtils.clearDir(dataDir); 359 360 binder = new MockBinder(); 361 environment = mock(EnvironmentForMock.class); 362 resources = mock(Resources.class); 363 systemProperties = mock(SystemPropertiesForMock.class); 364 userManager = mock(UserManager.class); 365 userManagerInternal = mock(UserManagerInternal.class); 366 userManagerForMock = mock(UserManagerForMock.class); 367 packageManagerInternal = mock(PackageManagerInternal.class); 368 powerManager = mock(PowerManagerForMock.class); 369 powerManagerInternal = mock(PowerManagerInternal.class); 370 recoverySystem = mock(RecoverySystemForMock.class); 371 notificationManager = mock(NotificationManager.class); 372 iipConnectivityMetrics = mock(IIpConnectivityMetrics.class); 373 iwindowManager = mock(IWindowManager.class); 374 iactivityManager = mock(IActivityManager.class); 375 ipackageManager = mock(IPackageManager.class); 376 ibackupManager = mock(IBackupManager.class); 377 iaudioService = mock(IAudioService.class); 378 lockPatternUtils = mock(LockPatternUtils.class); 379 storageManager = mock(StorageManagerForMock.class); 380 wifiManager = mock(WifiManager.class); 381 settings = mock(SettingsForMock.class); 382 telephonyManager = mock(TelephonyManager.class); 383 accountManager = mock(AccountManager.class); 384 alarmManager = mock(AlarmManager.class); 385 keyChainConnection = mock(KeyChain.KeyChainConnection.class, RETURNS_DEEP_STUBS); 386 387 // Package manager is huge, so we use a partial mock instead. 388 packageManager = spy(context.getPackageManager()); 389 390 spiedContext = mock(Context.class); 391 392 contentResolver = new MockContentResolver(); 393 394 // Add the system user with a fake profile group already set up (this can happen in the real 395 // world if a managed profile is added and then removed). 396 systemUserDataDir = 397 addUser(UserHandle.USER_SYSTEM, UserInfo.FLAG_PRIMARY, UserHandle.USER_SYSTEM); 398 399 // System user is always running. 400 setUserRunning(UserHandle.USER_SYSTEM, true); 401 } 402 403 public File addUser(int userId, int flags) { 404 return addUser(userId, flags, UserInfo.NO_PROFILE_GROUP_ID); 405 } 406 407 public File addUser(int userId, int flags, int profileGroupId) { 408 // Set up (default) UserInfo for CALLER_USER_HANDLE. 409 final UserInfo uh = new UserInfo(userId, "user" + userId, flags); 410 uh.profileGroupId = profileGroupId; 411 when(userManager.getUserInfo(eq(userId))).thenReturn(uh); 412 413 mUserInfos.add(uh); 414 when(userManager.getUsers()).thenReturn(mUserInfos); 415 when(userManager.getUsers(anyBoolean())).thenReturn(mUserInfos); 416 when(userManager.isUserRunning(eq(new UserHandle(userId)))).thenReturn(true); 417 when(userManager.getUserInfo(anyInt())).thenAnswer( 418 new Answer<UserInfo>() { 419 @Override 420 public UserInfo answer(InvocationOnMock invocation) throws Throwable { 421 final int userId = (int) invocation.getArguments()[0]; 422 return getUserInfo(userId); 423 } 424 } 425 ); 426 when(userManager.getProfiles(anyInt())).thenAnswer( 427 new Answer<List<UserInfo>>() { 428 @Override 429 public List<UserInfo> answer(InvocationOnMock invocation) throws Throwable { 430 final int userId = (int) invocation.getArguments()[0]; 431 return getProfiles(userId); 432 } 433 } 434 ); 435 when(userManager.getProfileIdsWithDisabled(anyInt())).thenAnswer( 436 new Answer<int[]>() { 437 @Override 438 public int[] answer(InvocationOnMock invocation) throws Throwable { 439 final int userId = (int) invocation.getArguments()[0]; 440 List<UserInfo> profiles = getProfiles(userId); 441 return profiles.stream() 442 .mapToInt(profile -> profile.id) 443 .toArray(); 444 } 445 } 446 ); 447 when(accountManager.getAccountsAsUser(anyInt())).thenReturn(new Account[0]); 448 449 // Create a data directory. 450 final File dir = new File(dataDir, "user" + userId); 451 DpmTestUtils.clearDir(dir); 452 453 when(environment.getUserSystemDirectory(eq(userId))).thenReturn(dir); 454 return dir; 455 } 456 457 public void removeUser(int userId) { 458 for (int i = 0; i < mUserInfos.size(); i++) { 459 if (mUserInfos.get(i).id == userId) { 460 mUserInfos.remove(i); 461 break; 462 } 463 } 464 when(userManager.getUserInfo(eq(userId))).thenReturn(null); 465 466 when(userManager.isUserRunning(eq(new UserHandle(userId)))).thenReturn(false); 467 } 468 469 private UserInfo getUserInfo(int userId) { 470 for (UserInfo ui : mUserInfos) { 471 if (ui.id == userId) { 472 return ui; 473 } 474 } 475 return null; 476 } 477 478 private List<UserInfo> getProfiles(int userId) { 479 final ArrayList<UserInfo> ret = new ArrayList<UserInfo>(); 480 UserInfo parent = null; 481 for (UserInfo ui : mUserInfos) { 482 if (ui.id == userId) { 483 parent = ui; 484 break; 485 } 486 } 487 if (parent == null) { 488 return ret; 489 } 490 for (UserInfo ui : mUserInfos) { 491 if (ui == parent 492 || ui.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID 493 && ui.profileGroupId == parent.profileGroupId) { 494 ret.add(ui); 495 } 496 } 497 return ret; 498 } 499 500 /** 501 * Add multiple users at once. They'll all have flag 0. 502 */ 503 public void addUsers(int... userIds) { 504 for (int userId : userIds) { 505 addUser(userId, 0); 506 } 507 } 508 509 public void setUserRunning(int userId, boolean isRunning) { 510 when(userManager.isUserRunning(MockUtils.checkUserHandle(userId))) 511 .thenReturn(isRunning); 512 } 513 514 public void injectBroadcast(Intent intent) { 515 final int userId = UserHandle.getUserId(binder.getCallingUid()); 516 for (final BroadcastReceiverRegistration receiver : mBroadcastReceivers) { 517 receiver.sendBroadcastIfApplicable(userId, intent); 518 } 519 } 520 521 @Override 522 public Resources getResources() { 523 return resources; 524 } 525 526 @Override 527 public Resources.Theme getTheme() { 528 return spiedContext.getTheme(); 529 } 530 531 @Override 532 public String getPackageName() { 533 if (packageName != null) { 534 return packageName; 535 } 536 return super.getPackageName(); 537 } 538 539 @Override 540 public ApplicationInfo getApplicationInfo() { 541 if (applicationInfo != null) { 542 return applicationInfo; 543 } 544 return super.getApplicationInfo(); 545 } 546 547 @Override 548 public Object getSystemService(String name) { 549 switch (name) { 550 case Context.ALARM_SERVICE: 551 return alarmManager; 552 case Context.USER_SERVICE: 553 return userManager; 554 case Context.POWER_SERVICE: 555 return powerManager; 556 case Context.WIFI_SERVICE: 557 return wifiManager; 558 case Context.ACCOUNT_SERVICE: 559 return accountManager; 560 } 561 throw new UnsupportedOperationException(); 562 } 563 564 @Override 565 public String getSystemServiceName(Class<?> serviceClass) { 566 return realTestContext.getSystemServiceName(serviceClass); 567 } 568 569 @Override 570 public PackageManager getPackageManager() { 571 return packageManager; 572 } 573 574 @Override 575 public void enforceCallingOrSelfPermission(String permission, String message) { 576 if (binder.getCallingUid() == SYSTEM_UID) { 577 return; // Assume system has all permissions. 578 } 579 if (!callerPermissions.contains(permission)) { 580 throw new SecurityException("Caller doesn't have " + permission + " : " + message); 581 } 582 } 583 584 @Override 585 public void sendBroadcast(Intent intent) { 586 spiedContext.sendBroadcast(intent); 587 } 588 589 @Override 590 public void sendBroadcast(Intent intent, String receiverPermission) { 591 spiedContext.sendBroadcast(intent, receiverPermission); 592 } 593 594 @Override 595 public void sendBroadcastMultiplePermissions(Intent intent, String[] receiverPermissions) { 596 spiedContext.sendBroadcastMultiplePermissions(intent, receiverPermissions); 597 } 598 599 @Override 600 public void sendBroadcast(Intent intent, String receiverPermission, Bundle options) { 601 spiedContext.sendBroadcast(intent, receiverPermission, options); 602 } 603 604 @Override 605 public void sendBroadcast(Intent intent, String receiverPermission, int appOp) { 606 spiedContext.sendBroadcast(intent, receiverPermission, appOp); 607 } 608 609 @Override 610 public void sendOrderedBroadcast(Intent intent, String receiverPermission) { 611 spiedContext.sendOrderedBroadcast(intent, receiverPermission); 612 } 613 614 @Override 615 public void sendOrderedBroadcast(Intent intent, String receiverPermission, 616 BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, 617 String initialData, Bundle initialExtras) { 618 spiedContext.sendOrderedBroadcast(intent, receiverPermission, resultReceiver, scheduler, 619 initialCode, initialData, initialExtras); 620 } 621 622 @Override 623 public void sendOrderedBroadcast(Intent intent, String receiverPermission, Bundle options, 624 BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, 625 String initialData, Bundle initialExtras) { 626 spiedContext.sendOrderedBroadcast(intent, receiverPermission, options, resultReceiver, 627 scheduler, 628 initialCode, initialData, initialExtras); 629 } 630 631 @Override 632 public void sendOrderedBroadcast(Intent intent, String receiverPermission, int appOp, 633 BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, 634 String initialData, Bundle initialExtras) { 635 spiedContext.sendOrderedBroadcast(intent, receiverPermission, appOp, resultReceiver, 636 scheduler, 637 initialCode, initialData, initialExtras); 638 } 639 640 @Override 641 public void sendBroadcastAsUser(Intent intent, UserHandle user) { 642 if (binder.callingPid != SYSTEM_PID) { 643 // Unless called as the system process, can only call if the target user is the 644 // calling user. 645 // (The actual check is more complex; we may need to change it later.) 646 Assert.assertEquals(UserHandle.getUserId(binder.getCallingUid()), user.getIdentifier()); 647 } 648 649 spiedContext.sendBroadcastAsUser(intent, user); 650 } 651 652 @Override 653 public void sendBroadcastAsUser(Intent intent, UserHandle user, String receiverPermission) { 654 spiedContext.sendBroadcastAsUser(intent, user, receiverPermission); 655 } 656 657 @Override 658 public void sendBroadcastAsUser(Intent intent, UserHandle user, String receiverPermission, 659 int appOp) { 660 spiedContext.sendBroadcastAsUser(intent, user, receiverPermission, appOp); 661 } 662 663 @Override 664 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 665 String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, 666 int initialCode, String initialData, Bundle initialExtras) { 667 spiedContext.sendOrderedBroadcastAsUser(intent, user, receiverPermission, resultReceiver, 668 scheduler, initialCode, initialData, initialExtras); 669 resultReceiver.onReceive(spiedContext, intent); 670 } 671 672 @Override 673 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 674 String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 675 Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { 676 spiedContext.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, 677 resultReceiver, 678 scheduler, initialCode, initialData, initialExtras); 679 } 680 681 @Override 682 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 683 String receiverPermission, int appOp, Bundle options, BroadcastReceiver resultReceiver, 684 Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { 685 spiedContext.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, options, 686 resultReceiver, scheduler, initialCode, initialData, initialExtras); 687 } 688 689 @Override 690 public void sendStickyBroadcast(Intent intent) { 691 spiedContext.sendStickyBroadcast(intent); 692 } 693 694 @Override 695 public void sendStickyOrderedBroadcast(Intent intent, BroadcastReceiver resultReceiver, 696 Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { 697 spiedContext.sendStickyOrderedBroadcast(intent, resultReceiver, scheduler, initialCode, 698 initialData, initialExtras); 699 } 700 701 @Override 702 public void removeStickyBroadcast(Intent intent) { 703 spiedContext.removeStickyBroadcast(intent); 704 } 705 706 @Override 707 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { 708 spiedContext.sendStickyBroadcastAsUser(intent, user); 709 } 710 711 @Override 712 public void sendStickyOrderedBroadcastAsUser(Intent intent, UserHandle user, 713 BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, 714 String initialData, Bundle initialExtras) { 715 spiedContext.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver, scheduler, initialCode, 716 initialData, initialExtras); 717 } 718 719 @Override 720 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 721 spiedContext.removeStickyBroadcastAsUser(intent, user); 722 } 723 724 @Override 725 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) { 726 mBroadcastReceivers.add(new BroadcastReceiverRegistration(receiver, filter, null)); 727 return spiedContext.registerReceiver(receiver, filter); 728 } 729 730 @Override 731 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, 732 String broadcastPermission, Handler scheduler) { 733 mBroadcastReceivers.add(new BroadcastReceiverRegistration(receiver, filter, scheduler)); 734 return spiedContext.registerReceiver(receiver, filter, broadcastPermission, scheduler); 735 } 736 737 @Override 738 public Intent registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user, 739 IntentFilter filter, String broadcastPermission, Handler scheduler) { 740 mBroadcastReceivers.add(new BroadcastReceiverRegistration(receiver, filter, scheduler)); 741 return spiedContext.registerReceiverAsUser(receiver, user, filter, broadcastPermission, 742 scheduler); 743 } 744 745 @Override 746 public void unregisterReceiver(BroadcastReceiver receiver) { 747 mBroadcastReceivers.removeIf(r -> r.receiver == receiver); 748 spiedContext.unregisterReceiver(receiver); 749 } 750 751 @Override 752 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 753 throws PackageManager.NameNotFoundException { 754 if (!userContexts.containsKey(user)) { 755 return super.createPackageContextAsUser(packageName, flags, user); 756 } 757 if (!getPackageName().equals(packageName)) { 758 throw new UnsupportedOperationException( 759 "Creating a context as another package is not implemented"); 760 } 761 return userContexts.get(user); 762 } 763 764 @Override 765 public ContentResolver getContentResolver() { 766 return contentResolver; 767 } 768 769 @Override 770 public int getUserId() { 771 return UserHandle.getUserId(binder.getCallingUid()); 772 } 773} 774