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