ContextWrapper.java revision e13529a4adb60e5a18c2e36ce6c5bf8f2d1db78f
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 @Override 540 @Deprecated 541 public void sendStickyOrderedBroadcastAsUser(Intent intent, 542 UserHandle user, BroadcastReceiver resultReceiver, 543 Handler scheduler, int initialCode, String initialData, 544 Bundle initialExtras) { 545 mBase.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver, 546 scheduler, initialCode, initialData, initialExtras); 547 } 548 549 @Override 550 @Deprecated 551 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 552 mBase.removeStickyBroadcastAsUser(intent, user); 553 } 554 555 @Override 556 public Intent registerReceiver( 557 BroadcastReceiver receiver, IntentFilter filter) { 558 return mBase.registerReceiver(receiver, filter); 559 } 560 561 @Override 562 public Intent registerReceiver( 563 BroadcastReceiver receiver, IntentFilter filter, 564 String broadcastPermission, Handler scheduler) { 565 return mBase.registerReceiver(receiver, filter, broadcastPermission, 566 scheduler); 567 } 568 569 /** @hide */ 570 @Override 571 public Intent registerReceiverAsUser( 572 BroadcastReceiver receiver, UserHandle user, IntentFilter filter, 573 String broadcastPermission, Handler scheduler) { 574 return mBase.registerReceiverAsUser(receiver, user, filter, broadcastPermission, 575 scheduler); 576 } 577 578 @Override 579 public void unregisterReceiver(BroadcastReceiver receiver) { 580 mBase.unregisterReceiver(receiver); 581 } 582 583 @Override 584 public ComponentName startService(Intent service) { 585 return mBase.startService(service); 586 } 587 588 @Override 589 public boolean stopService(Intent name) { 590 return mBase.stopService(name); 591 } 592 593 /** @hide */ 594 @Override 595 public ComponentName startServiceAsUser(Intent service, UserHandle user) { 596 return mBase.startServiceAsUser(service, user); 597 } 598 599 /** @hide */ 600 @Override 601 public boolean stopServiceAsUser(Intent name, UserHandle user) { 602 return mBase.stopServiceAsUser(name, user); 603 } 604 605 @Override 606 public boolean bindService(Intent service, ServiceConnection conn, 607 int flags) { 608 return mBase.bindService(service, conn, flags); 609 } 610 611 /** @hide */ 612 @Override 613 public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags, 614 UserHandle user) { 615 return mBase.bindServiceAsUser(service, conn, flags, user); 616 } 617 618 @Override 619 public void unbindService(ServiceConnection conn) { 620 mBase.unbindService(conn); 621 } 622 623 @Override 624 public boolean startInstrumentation(ComponentName className, 625 String profileFile, Bundle arguments) { 626 return mBase.startInstrumentation(className, profileFile, arguments); 627 } 628 629 @Override 630 public Object getSystemService(String name) { 631 return mBase.getSystemService(name); 632 } 633 634 @Override 635 public String getSystemServiceName(Class<?> serviceClass) { 636 return mBase.getSystemServiceName(serviceClass); 637 } 638 639 @Override 640 public int checkPermission(String permission, int pid, int uid) { 641 return mBase.checkPermission(permission, pid, uid); 642 } 643 644 /** @hide */ 645 @Override 646 public int checkPermission(String permission, int pid, int uid, IBinder callerToken) { 647 return mBase.checkPermission(permission, pid, uid, callerToken); 648 } 649 650 @Override 651 public int checkCallingPermission(String permission) { 652 return mBase.checkCallingPermission(permission); 653 } 654 655 @Override 656 public int checkCallingOrSelfPermission(String permission) { 657 return mBase.checkCallingOrSelfPermission(permission); 658 } 659 660 @Override 661 public int checkSelfPermission(String permission) { 662 return mBase.checkSelfPermission(permission); 663 } 664 665 @Override 666 public void enforcePermission( 667 String permission, int pid, int uid, String message) { 668 mBase.enforcePermission(permission, pid, uid, message); 669 } 670 671 @Override 672 public void enforceCallingPermission(String permission, String message) { 673 mBase.enforceCallingPermission(permission, message); 674 } 675 676 @Override 677 public void enforceCallingOrSelfPermission( 678 String permission, String message) { 679 mBase.enforceCallingOrSelfPermission(permission, message); 680 } 681 682 @Override 683 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 684 mBase.grantUriPermission(toPackage, uri, modeFlags); 685 } 686 687 @Override 688 public void revokeUriPermission(Uri uri, int modeFlags) { 689 mBase.revokeUriPermission(uri, modeFlags); 690 } 691 692 @Override 693 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 694 return mBase.checkUriPermission(uri, pid, uid, modeFlags); 695 } 696 697 /** @hide */ 698 @Override 699 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) { 700 return mBase.checkUriPermission(uri, pid, uid, modeFlags, callerToken); 701 } 702 703 @Override 704 public int checkCallingUriPermission(Uri uri, int modeFlags) { 705 return mBase.checkCallingUriPermission(uri, modeFlags); 706 } 707 708 @Override 709 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 710 return mBase.checkCallingOrSelfUriPermission(uri, modeFlags); 711 } 712 713 @Override 714 public int checkUriPermission(Uri uri, String readPermission, 715 String writePermission, int pid, int uid, int modeFlags) { 716 return mBase.checkUriPermission(uri, readPermission, writePermission, 717 pid, uid, modeFlags); 718 } 719 720 @Override 721 public void enforceUriPermission( 722 Uri uri, int pid, int uid, int modeFlags, String message) { 723 mBase.enforceUriPermission(uri, pid, uid, modeFlags, message); 724 } 725 726 @Override 727 public void enforceCallingUriPermission( 728 Uri uri, int modeFlags, String message) { 729 mBase.enforceCallingUriPermission(uri, modeFlags, message); 730 } 731 732 @Override 733 public void enforceCallingOrSelfUriPermission( 734 Uri uri, int modeFlags, String message) { 735 mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message); 736 } 737 738 @Override 739 public void enforceUriPermission( 740 Uri uri, String readPermission, String writePermission, 741 int pid, int uid, int modeFlags, String message) { 742 mBase.enforceUriPermission( 743 uri, readPermission, writePermission, pid, uid, modeFlags, 744 message); 745 } 746 747 @Override 748 public Context createPackageContext(String packageName, int flags) 749 throws PackageManager.NameNotFoundException { 750 return mBase.createPackageContext(packageName, flags); 751 } 752 753 /** @hide */ 754 @Override 755 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 756 throws PackageManager.NameNotFoundException { 757 return mBase.createPackageContextAsUser(packageName, flags, user); 758 } 759 760 /** @hide */ 761 @Override 762 public Context createApplicationContext(ApplicationInfo application, 763 int flags) throws PackageManager.NameNotFoundException { 764 return mBase.createApplicationContext(application, flags); 765 } 766 767 /** @hide */ 768 @Override 769 public int getUserId() { 770 return mBase.getUserId(); 771 } 772 773 @Override 774 public Context createConfigurationContext(Configuration overrideConfiguration) { 775 return mBase.createConfigurationContext(overrideConfiguration); 776 } 777 778 @Override 779 public Context createDisplayContext(Display display) { 780 return mBase.createDisplayContext(display); 781 } 782 783 @Override 784 public boolean isRestricted() { 785 return mBase.isRestricted(); 786 } 787 788 /** @hide */ 789 @Override 790 public DisplayAdjustments getDisplayAdjustments(int displayId) { 791 return mBase.getDisplayAdjustments(displayId); 792 } 793 794 @Override 795 public Context createDeviceEncryptedStorageContext() { 796 return mBase.createDeviceEncryptedStorageContext(); 797 } 798 799 /** {@hide} */ 800 @SystemApi 801 @Override 802 public Context createCredentialEncryptedStorageContext() { 803 return mBase.createCredentialEncryptedStorageContext(); 804 } 805 806 @Override 807 public boolean isDeviceEncryptedStorage() { 808 return mBase.isDeviceEncryptedStorage(); 809 } 810 811 /** {@hide} */ 812 @SystemApi 813 @Override 814 public boolean isCredentialEncryptedStorage() { 815 return mBase.isCredentialEncryptedStorage(); 816 } 817} 818