1/* 2 * Copyright (C) 2006 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 android.content; 18 19import android.annotation.SystemApi; 20import android.app.IApplicationThread; 21import android.app.IServiceConnection; 22import android.content.pm.ApplicationInfo; 23import android.content.pm.PackageManager; 24import android.content.res.AssetManager; 25import android.content.res.Configuration; 26import android.content.res.Resources; 27import android.database.DatabaseErrorHandler; 28import android.database.sqlite.SQLiteDatabase; 29import android.database.sqlite.SQLiteDatabase.CursorFactory; 30import android.graphics.Bitmap; 31import android.graphics.drawable.Drawable; 32import android.net.Uri; 33import android.os.Bundle; 34import android.os.Handler; 35import android.os.IBinder; 36import android.os.Looper; 37import android.os.UserHandle; 38import android.view.Display; 39import android.view.DisplayAdjustments; 40import android.view.autofill.AutofillManager.AutofillClient; 41 42import java.io.File; 43import java.io.FileInputStream; 44import java.io.FileNotFoundException; 45import java.io.FileOutputStream; 46import java.io.IOException; 47import java.io.InputStream; 48 49/** 50 * Proxying implementation of Context that simply delegates all of its calls to 51 * another Context. Can be subclassed to modify behavior without changing 52 * the original Context. 53 */ 54public class ContextWrapper extends Context { 55 Context mBase; 56 57 public ContextWrapper(Context base) { 58 mBase = base; 59 } 60 61 /** 62 * Set the base context for this ContextWrapper. All calls will then be 63 * delegated to the base context. Throws 64 * IllegalStateException if a base context has already been set. 65 * 66 * @param base The new base context for this wrapper. 67 */ 68 protected void attachBaseContext(Context base) { 69 if (mBase != null) { 70 throw new IllegalStateException("Base context already set"); 71 } 72 mBase = base; 73 } 74 75 /** 76 * @return the base context as set by the constructor or setBaseContext 77 */ 78 public Context getBaseContext() { 79 return mBase; 80 } 81 82 @Override 83 public AssetManager getAssets() { 84 return mBase.getAssets(); 85 } 86 87 @Override 88 public Resources getResources() { 89 return mBase.getResources(); 90 } 91 92 @Override 93 public PackageManager getPackageManager() { 94 return mBase.getPackageManager(); 95 } 96 97 @Override 98 public ContentResolver getContentResolver() { 99 return mBase.getContentResolver(); 100 } 101 102 @Override 103 public Looper getMainLooper() { 104 return mBase.getMainLooper(); 105 } 106 107 @Override 108 public Context getApplicationContext() { 109 return mBase.getApplicationContext(); 110 } 111 112 @Override 113 public void setTheme(int resid) { 114 mBase.setTheme(resid); 115 } 116 117 /** @hide */ 118 @Override 119 public int getThemeResId() { 120 return mBase.getThemeResId(); 121 } 122 123 @Override 124 public Resources.Theme getTheme() { 125 return mBase.getTheme(); 126 } 127 128 @Override 129 public ClassLoader getClassLoader() { 130 return mBase.getClassLoader(); 131 } 132 133 @Override 134 public String getPackageName() { 135 return mBase.getPackageName(); 136 } 137 138 /** @hide */ 139 @Override 140 public String getBasePackageName() { 141 return mBase.getBasePackageName(); 142 } 143 144 /** @hide */ 145 @Override 146 public String getOpPackageName() { 147 return mBase.getOpPackageName(); 148 } 149 150 @Override 151 public ApplicationInfo getApplicationInfo() { 152 return mBase.getApplicationInfo(); 153 } 154 155 @Override 156 public String getPackageResourcePath() { 157 return mBase.getPackageResourcePath(); 158 } 159 160 @Override 161 public String getPackageCodePath() { 162 return mBase.getPackageCodePath(); 163 } 164 165 @Override 166 public SharedPreferences getSharedPreferences(String name, int mode) { 167 return mBase.getSharedPreferences(name, mode); 168 } 169 170 /** @removed */ 171 @Override 172 public SharedPreferences getSharedPreferences(File file, int mode) { 173 return mBase.getSharedPreferences(file, mode); 174 } 175 176 /** @hide */ 177 @Override 178 public void reloadSharedPreferences() { 179 mBase.reloadSharedPreferences(); 180 } 181 182 @Override 183 public boolean moveSharedPreferencesFrom(Context sourceContext, String name) { 184 return mBase.moveSharedPreferencesFrom(sourceContext, name); 185 } 186 187 @Override 188 public boolean deleteSharedPreferences(String name) { 189 return mBase.deleteSharedPreferences(name); 190 } 191 192 @Override 193 public FileInputStream openFileInput(String name) 194 throws FileNotFoundException { 195 return mBase.openFileInput(name); 196 } 197 198 @Override 199 public FileOutputStream openFileOutput(String name, int mode) 200 throws FileNotFoundException { 201 return mBase.openFileOutput(name, mode); 202 } 203 204 @Override 205 public boolean deleteFile(String name) { 206 return mBase.deleteFile(name); 207 } 208 209 @Override 210 public File getFileStreamPath(String name) { 211 return mBase.getFileStreamPath(name); 212 } 213 214 /** @removed */ 215 @Override 216 public File getSharedPreferencesPath(String name) { 217 return mBase.getSharedPreferencesPath(name); 218 } 219 220 @Override 221 public String[] fileList() { 222 return mBase.fileList(); 223 } 224 225 @Override 226 public File getDataDir() { 227 return mBase.getDataDir(); 228 } 229 230 @Override 231 public File getFilesDir() { 232 return mBase.getFilesDir(); 233 } 234 235 @Override 236 public File getNoBackupFilesDir() { 237 return mBase.getNoBackupFilesDir(); 238 } 239 240 @Override 241 public File getExternalFilesDir(String type) { 242 return mBase.getExternalFilesDir(type); 243 } 244 245 @Override 246 public File[] getExternalFilesDirs(String type) { 247 return mBase.getExternalFilesDirs(type); 248 } 249 250 @Override 251 public File getObbDir() { 252 return mBase.getObbDir(); 253 } 254 255 @Override 256 public File[] getObbDirs() { 257 return mBase.getObbDirs(); 258 } 259 260 @Override 261 public File getCacheDir() { 262 return mBase.getCacheDir(); 263 } 264 265 @Override 266 public File getCodeCacheDir() { 267 return mBase.getCodeCacheDir(); 268 } 269 270 @Override 271 public File getExternalCacheDir() { 272 return mBase.getExternalCacheDir(); 273 } 274 275 @Override 276 public File[] getExternalCacheDirs() { 277 return mBase.getExternalCacheDirs(); 278 } 279 280 @Override 281 public File[] getExternalMediaDirs() { 282 return mBase.getExternalMediaDirs(); 283 } 284 285 @Override 286 public File getDir(String name, int mode) { 287 return mBase.getDir(name, mode); 288 } 289 290 291 /** @hide **/ 292 @Override 293 public File getPreloadsFileCache() { 294 return mBase.getPreloadsFileCache(); 295 } 296 297 @Override 298 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) { 299 return mBase.openOrCreateDatabase(name, mode, factory); 300 } 301 302 @Override 303 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory, 304 DatabaseErrorHandler errorHandler) { 305 return mBase.openOrCreateDatabase(name, mode, factory, errorHandler); 306 } 307 308 @Override 309 public boolean moveDatabaseFrom(Context sourceContext, String name) { 310 return mBase.moveDatabaseFrom(sourceContext, name); 311 } 312 313 @Override 314 public boolean deleteDatabase(String name) { 315 return mBase.deleteDatabase(name); 316 } 317 318 @Override 319 public File getDatabasePath(String name) { 320 return mBase.getDatabasePath(name); 321 } 322 323 @Override 324 public String[] databaseList() { 325 return mBase.databaseList(); 326 } 327 328 @Override 329 @Deprecated 330 public Drawable getWallpaper() { 331 return mBase.getWallpaper(); 332 } 333 334 @Override 335 @Deprecated 336 public Drawable peekWallpaper() { 337 return mBase.peekWallpaper(); 338 } 339 340 @Override 341 @Deprecated 342 public int getWallpaperDesiredMinimumWidth() { 343 return mBase.getWallpaperDesiredMinimumWidth(); 344 } 345 346 @Override 347 @Deprecated 348 public int getWallpaperDesiredMinimumHeight() { 349 return mBase.getWallpaperDesiredMinimumHeight(); 350 } 351 352 @Override 353 @Deprecated 354 public void setWallpaper(Bitmap bitmap) throws IOException { 355 mBase.setWallpaper(bitmap); 356 } 357 358 @Override 359 @Deprecated 360 public void setWallpaper(InputStream data) throws IOException { 361 mBase.setWallpaper(data); 362 } 363 364 @Override 365 @Deprecated 366 public void clearWallpaper() throws IOException { 367 mBase.clearWallpaper(); 368 } 369 370 @Override 371 public void startActivity(Intent intent) { 372 mBase.startActivity(intent); 373 } 374 375 /** @hide */ 376 @Override 377 public void startActivityAsUser(Intent intent, UserHandle user) { 378 mBase.startActivityAsUser(intent, user); 379 } 380 381 /** @hide **/ 382 public void startActivityForResult( 383 String who, Intent intent, int requestCode, Bundle options) { 384 mBase.startActivityForResult(who, intent, requestCode, options); 385 } 386 387 /** @hide **/ 388 public boolean canStartActivityForResult() { 389 return mBase.canStartActivityForResult(); 390 } 391 392 @Override 393 public void startActivity(Intent intent, Bundle options) { 394 mBase.startActivity(intent, options); 395 } 396 397 /** @hide */ 398 @Override 399 public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) { 400 mBase.startActivityAsUser(intent, options, user); 401 } 402 403 @Override 404 public void startActivities(Intent[] intents) { 405 mBase.startActivities(intents); 406 } 407 408 @Override 409 public void startActivities(Intent[] intents, Bundle options) { 410 mBase.startActivities(intents, options); 411 } 412 413 /** @hide */ 414 @Override 415 public void startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle) { 416 mBase.startActivitiesAsUser(intents, options, userHandle); 417 } 418 419 @Override 420 public void startIntentSender(IntentSender intent, 421 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) 422 throws IntentSender.SendIntentException { 423 mBase.startIntentSender(intent, fillInIntent, flagsMask, 424 flagsValues, extraFlags); 425 } 426 427 @Override 428 public void startIntentSender(IntentSender intent, 429 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, 430 Bundle options) throws IntentSender.SendIntentException { 431 mBase.startIntentSender(intent, fillInIntent, flagsMask, 432 flagsValues, extraFlags, options); 433 } 434 435 @Override 436 public void sendBroadcast(Intent intent) { 437 mBase.sendBroadcast(intent); 438 } 439 440 @Override 441 public void sendBroadcast(Intent intent, String receiverPermission) { 442 mBase.sendBroadcast(intent, receiverPermission); 443 } 444 445 /** @hide */ 446 @Override 447 public void sendBroadcastMultiplePermissions(Intent intent, String[] receiverPermissions) { 448 mBase.sendBroadcastMultiplePermissions(intent, receiverPermissions); 449 } 450 451 /** @hide */ 452 @SystemApi 453 @Override 454 public void sendBroadcast(Intent intent, String receiverPermission, Bundle options) { 455 mBase.sendBroadcast(intent, receiverPermission, options); 456 } 457 458 /** @hide */ 459 @Override 460 public void sendBroadcast(Intent intent, String receiverPermission, int appOp) { 461 mBase.sendBroadcast(intent, receiverPermission, appOp); 462 } 463 464 @Override 465 public void sendOrderedBroadcast(Intent intent, 466 String receiverPermission) { 467 mBase.sendOrderedBroadcast(intent, receiverPermission); 468 } 469 470 @Override 471 public void sendOrderedBroadcast( 472 Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, 473 Handler scheduler, int initialCode, String initialData, 474 Bundle initialExtras) { 475 mBase.sendOrderedBroadcast(intent, receiverPermission, 476 resultReceiver, scheduler, initialCode, 477 initialData, initialExtras); 478 } 479 480 /** @hide */ 481 @SystemApi 482 @Override 483 public void sendOrderedBroadcast( 484 Intent intent, String receiverPermission, Bundle options, BroadcastReceiver resultReceiver, 485 Handler scheduler, int initialCode, String initialData, 486 Bundle initialExtras) { 487 mBase.sendOrderedBroadcast(intent, receiverPermission, 488 options, resultReceiver, scheduler, initialCode, 489 initialData, initialExtras); 490 } 491 492 /** @hide */ 493 @Override 494 public void sendOrderedBroadcast( 495 Intent intent, String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 496 Handler scheduler, int initialCode, String initialData, 497 Bundle initialExtras) { 498 mBase.sendOrderedBroadcast(intent, receiverPermission, appOp, 499 resultReceiver, scheduler, initialCode, 500 initialData, initialExtras); 501 } 502 503 @Override 504 public void sendBroadcastAsUser(Intent intent, UserHandle user) { 505 mBase.sendBroadcastAsUser(intent, user); 506 } 507 508 @Override 509 public void sendBroadcastAsUser(Intent intent, UserHandle user, 510 String receiverPermission) { 511 mBase.sendBroadcastAsUser(intent, user, receiverPermission); 512 } 513 514 /** @hide */ 515 @Override 516 public void sendBroadcastAsUser(Intent intent, UserHandle user, 517 String receiverPermission, Bundle options) { 518 mBase.sendBroadcastAsUser(intent, user, receiverPermission, options); 519 } 520 521 /** @hide */ 522 @Override 523 public void sendBroadcastAsUser(Intent intent, UserHandle user, 524 String receiverPermission, int appOp) { 525 mBase.sendBroadcastAsUser(intent, user, receiverPermission, appOp); 526 } 527 528 @Override 529 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 530 String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, 531 int initialCode, String initialData, Bundle initialExtras) { 532 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, resultReceiver, 533 scheduler, initialCode, initialData, initialExtras); 534 } 535 536 /** @hide */ 537 @Override 538 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 539 String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 540 Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { 541 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, resultReceiver, 542 scheduler, initialCode, initialData, initialExtras); 543 } 544 545 /** @hide */ 546 @Override 547 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 548 String receiverPermission, int appOp, Bundle options, BroadcastReceiver resultReceiver, 549 Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { 550 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, options, 551 resultReceiver, scheduler, initialCode, initialData, initialExtras); 552 } 553 554 @Override 555 @Deprecated 556 public void sendStickyBroadcast(Intent intent) { 557 mBase.sendStickyBroadcast(intent); 558 } 559 560 @Override 561 @Deprecated 562 public void sendStickyOrderedBroadcast( 563 Intent intent, BroadcastReceiver resultReceiver, 564 Handler scheduler, int initialCode, String initialData, 565 Bundle initialExtras) { 566 mBase.sendStickyOrderedBroadcast(intent, 567 resultReceiver, scheduler, initialCode, 568 initialData, initialExtras); 569 } 570 571 @Override 572 @Deprecated 573 public void removeStickyBroadcast(Intent intent) { 574 mBase.removeStickyBroadcast(intent); 575 } 576 577 @Override 578 @Deprecated 579 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { 580 mBase.sendStickyBroadcastAsUser(intent, user); 581 } 582 583 /** @hide */ 584 @Override 585 @Deprecated 586 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user, Bundle options) { 587 mBase.sendStickyBroadcastAsUser(intent, user, options); 588 } 589 590 @Override 591 @Deprecated 592 public void sendStickyOrderedBroadcastAsUser(Intent intent, 593 UserHandle user, BroadcastReceiver resultReceiver, 594 Handler scheduler, int initialCode, String initialData, 595 Bundle initialExtras) { 596 mBase.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver, 597 scheduler, initialCode, initialData, initialExtras); 598 } 599 600 @Override 601 @Deprecated 602 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 603 mBase.removeStickyBroadcastAsUser(intent, user); 604 } 605 606 @Override 607 public Intent registerReceiver( 608 BroadcastReceiver receiver, IntentFilter filter) { 609 return mBase.registerReceiver(receiver, filter); 610 } 611 612 @Override 613 public Intent registerReceiver( 614 BroadcastReceiver receiver, IntentFilter filter, int flags) { 615 return mBase.registerReceiver(receiver, filter, flags); 616 } 617 618 @Override 619 public Intent registerReceiver( 620 BroadcastReceiver receiver, IntentFilter filter, 621 String broadcastPermission, Handler scheduler) { 622 return mBase.registerReceiver(receiver, filter, broadcastPermission, 623 scheduler); 624 } 625 626 @Override 627 public Intent registerReceiver( 628 BroadcastReceiver receiver, IntentFilter filter, 629 String broadcastPermission, Handler scheduler, int flags) { 630 return mBase.registerReceiver(receiver, filter, broadcastPermission, 631 scheduler, flags); 632 } 633 634 /** @hide */ 635 @Override 636 public Intent registerReceiverAsUser( 637 BroadcastReceiver receiver, UserHandle user, IntentFilter filter, 638 String broadcastPermission, Handler scheduler) { 639 return mBase.registerReceiverAsUser(receiver, user, filter, broadcastPermission, 640 scheduler); 641 } 642 643 @Override 644 public void unregisterReceiver(BroadcastReceiver receiver) { 645 mBase.unregisterReceiver(receiver); 646 } 647 648 @Override 649 public ComponentName startService(Intent service) { 650 return mBase.startService(service); 651 } 652 653 @Override 654 public ComponentName startForegroundService(Intent service) { 655 return mBase.startForegroundService(service); 656 } 657 658 @Override 659 public boolean stopService(Intent name) { 660 return mBase.stopService(name); 661 } 662 663 /** @hide */ 664 @Override 665 public ComponentName startServiceAsUser(Intent service, UserHandle user) { 666 return mBase.startServiceAsUser(service, user); 667 } 668 669 /** @hide */ 670 @Override 671 public ComponentName startForegroundServiceAsUser(Intent service, UserHandle user) { 672 return mBase.startForegroundServiceAsUser(service, user); 673 } 674 675 /** @hide */ 676 @Override 677 public boolean stopServiceAsUser(Intent name, UserHandle user) { 678 return mBase.stopServiceAsUser(name, user); 679 } 680 681 @Override 682 public boolean bindService(Intent service, ServiceConnection conn, 683 int flags) { 684 return mBase.bindService(service, conn, flags); 685 } 686 687 /** @hide */ 688 @Override 689 public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags, 690 UserHandle user) { 691 return mBase.bindServiceAsUser(service, conn, flags, user); 692 } 693 694 /** @hide */ 695 @Override 696 public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags, 697 Handler handler, UserHandle user) { 698 return mBase.bindServiceAsUser(service, conn, flags, handler, user); 699 } 700 701 @Override 702 public void unbindService(ServiceConnection conn) { 703 mBase.unbindService(conn); 704 } 705 706 @Override 707 public boolean startInstrumentation(ComponentName className, 708 String profileFile, Bundle arguments) { 709 return mBase.startInstrumentation(className, profileFile, arguments); 710 } 711 712 @Override 713 public Object getSystemService(String name) { 714 return mBase.getSystemService(name); 715 } 716 717 @Override 718 public String getSystemServiceName(Class<?> serviceClass) { 719 return mBase.getSystemServiceName(serviceClass); 720 } 721 722 @Override 723 public int checkPermission(String permission, int pid, int uid) { 724 return mBase.checkPermission(permission, pid, uid); 725 } 726 727 /** @hide */ 728 @Override 729 public int checkPermission(String permission, int pid, int uid, IBinder callerToken) { 730 return mBase.checkPermission(permission, pid, uid, callerToken); 731 } 732 733 @Override 734 public int checkCallingPermission(String permission) { 735 return mBase.checkCallingPermission(permission); 736 } 737 738 @Override 739 public int checkCallingOrSelfPermission(String permission) { 740 return mBase.checkCallingOrSelfPermission(permission); 741 } 742 743 @Override 744 public int checkSelfPermission(String permission) { 745 return mBase.checkSelfPermission(permission); 746 } 747 748 @Override 749 public void enforcePermission( 750 String permission, int pid, int uid, String message) { 751 mBase.enforcePermission(permission, pid, uid, message); 752 } 753 754 @Override 755 public void enforceCallingPermission(String permission, String message) { 756 mBase.enforceCallingPermission(permission, message); 757 } 758 759 @Override 760 public void enforceCallingOrSelfPermission( 761 String permission, String message) { 762 mBase.enforceCallingOrSelfPermission(permission, message); 763 } 764 765 @Override 766 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 767 mBase.grantUriPermission(toPackage, uri, modeFlags); 768 } 769 770 @Override 771 public void revokeUriPermission(Uri uri, int modeFlags) { 772 mBase.revokeUriPermission(uri, modeFlags); 773 } 774 775 @Override 776 public void revokeUriPermission(String targetPackage, Uri uri, int modeFlags) { 777 mBase.revokeUriPermission(targetPackage, uri, modeFlags); 778 } 779 780 @Override 781 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 782 return mBase.checkUriPermission(uri, pid, uid, modeFlags); 783 } 784 785 /** @hide */ 786 @Override 787 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) { 788 return mBase.checkUriPermission(uri, pid, uid, modeFlags, callerToken); 789 } 790 791 @Override 792 public int checkCallingUriPermission(Uri uri, int modeFlags) { 793 return mBase.checkCallingUriPermission(uri, modeFlags); 794 } 795 796 @Override 797 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 798 return mBase.checkCallingOrSelfUriPermission(uri, modeFlags); 799 } 800 801 @Override 802 public int checkUriPermission(Uri uri, String readPermission, 803 String writePermission, int pid, int uid, int modeFlags) { 804 return mBase.checkUriPermission(uri, readPermission, writePermission, 805 pid, uid, modeFlags); 806 } 807 808 @Override 809 public void enforceUriPermission( 810 Uri uri, int pid, int uid, int modeFlags, String message) { 811 mBase.enforceUriPermission(uri, pid, uid, modeFlags, message); 812 } 813 814 @Override 815 public void enforceCallingUriPermission( 816 Uri uri, int modeFlags, String message) { 817 mBase.enforceCallingUriPermission(uri, modeFlags, message); 818 } 819 820 @Override 821 public void enforceCallingOrSelfUriPermission( 822 Uri uri, int modeFlags, String message) { 823 mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message); 824 } 825 826 @Override 827 public void enforceUriPermission( 828 Uri uri, String readPermission, String writePermission, 829 int pid, int uid, int modeFlags, String message) { 830 mBase.enforceUriPermission( 831 uri, readPermission, writePermission, pid, uid, modeFlags, 832 message); 833 } 834 835 @Override 836 public Context createPackageContext(String packageName, int flags) 837 throws PackageManager.NameNotFoundException { 838 return mBase.createPackageContext(packageName, flags); 839 } 840 841 /** @hide */ 842 @Override 843 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 844 throws PackageManager.NameNotFoundException { 845 return mBase.createPackageContextAsUser(packageName, flags, user); 846 } 847 848 /** @hide */ 849 @Override 850 public Context createApplicationContext(ApplicationInfo application, 851 int flags) throws PackageManager.NameNotFoundException { 852 return mBase.createApplicationContext(application, flags); 853 } 854 855 /** @hide */ 856 @Override 857 public Context createContextForSplit(String splitName) 858 throws PackageManager.NameNotFoundException { 859 return mBase.createContextForSplit(splitName); 860 } 861 862 /** @hide */ 863 @Override 864 public int getUserId() { 865 return mBase.getUserId(); 866 } 867 868 @Override 869 public Context createConfigurationContext(Configuration overrideConfiguration) { 870 return mBase.createConfigurationContext(overrideConfiguration); 871 } 872 873 @Override 874 public Context createDisplayContext(Display display) { 875 return mBase.createDisplayContext(display); 876 } 877 878 @Override 879 public boolean isRestricted() { 880 return mBase.isRestricted(); 881 } 882 883 /** @hide */ 884 @Override 885 public DisplayAdjustments getDisplayAdjustments(int displayId) { 886 return mBase.getDisplayAdjustments(displayId); 887 } 888 889 /** 890 * @hide 891 */ 892 @Override 893 public Display getDisplay() { 894 return mBase.getDisplay(); 895 } 896 897 /** 898 * @hide 899 */ 900 @Override 901 public void updateDisplay(int displayId) { 902 mBase.updateDisplay(displayId); 903 } 904 905 @Override 906 public Context createDeviceProtectedStorageContext() { 907 return mBase.createDeviceProtectedStorageContext(); 908 } 909 910 /** {@hide} */ 911 @SystemApi 912 @Override 913 public Context createCredentialProtectedStorageContext() { 914 return mBase.createCredentialProtectedStorageContext(); 915 } 916 917 @Override 918 public boolean isDeviceProtectedStorage() { 919 return mBase.isDeviceProtectedStorage(); 920 } 921 922 /** {@hide} */ 923 @SystemApi 924 @Override 925 public boolean isCredentialProtectedStorage() { 926 return mBase.isCredentialProtectedStorage(); 927 } 928 929 /** {@hide} */ 930 @Override 931 public boolean canLoadUnsafeResources() { 932 return mBase.canLoadUnsafeResources(); 933 } 934 935 /** 936 * @hide 937 */ 938 @Override 939 public IBinder getActivityToken() { 940 return mBase.getActivityToken(); 941 } 942 943 /** 944 * @hide 945 */ 946 @Override 947 public IServiceConnection getServiceDispatcher(ServiceConnection conn, Handler handler, 948 int flags) { 949 return mBase.getServiceDispatcher(conn, handler, flags); 950 } 951 952 /** 953 * @hide 954 */ 955 @Override 956 public IApplicationThread getIApplicationThread() { 957 return mBase.getIApplicationThread(); 958 } 959 960 /** 961 * @hide 962 */ 963 @Override 964 public Handler getMainThreadHandler() { 965 return mBase.getMainThreadHandler(); 966 } 967 968 /** 969 * @hide 970 */ 971 @Override 972 public int getNextAutofillId() { 973 return mBase.getNextAutofillId(); 974 } 975 976 /** 977 * @hide 978 */ 979 @Override 980 public AutofillClient getAutofillClient() { 981 return mBase.getAutofillClient(); 982 } 983 984 /** 985 * @hide 986 */ 987 @Override 988 public void setAutofillClient(AutofillClient client) { 989 mBase.setAutofillClient(client); 990 } 991} 992