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