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