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