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 /** @hide */ 164 @Override 165 public File getSharedPrefsFile(String name) { 166 return mBase.getSharedPrefsFile(name); 167 } 168 169 @Override 170 public SharedPreferences getSharedPreferences(String name, int mode) { 171 return mBase.getSharedPreferences(name, mode); 172 } 173 174 @Override 175 public FileInputStream openFileInput(String name) 176 throws FileNotFoundException { 177 return mBase.openFileInput(name); 178 } 179 180 @Override 181 public FileOutputStream openFileOutput(String name, int mode) 182 throws FileNotFoundException { 183 return mBase.openFileOutput(name, mode); 184 } 185 186 @Override 187 public boolean deleteFile(String name) { 188 return mBase.deleteFile(name); 189 } 190 191 @Override 192 public File getFileStreamPath(String name) { 193 return mBase.getFileStreamPath(name); 194 } 195 196 @Override 197 public String[] fileList() { 198 return mBase.fileList(); 199 } 200 201 @Override 202 public File getFilesDir() { 203 return mBase.getFilesDir(); 204 } 205 206 @Override 207 public File getNoBackupFilesDir() { 208 return mBase.getNoBackupFilesDir(); 209 } 210 211 @Override 212 public File getExternalFilesDir(String type) { 213 return mBase.getExternalFilesDir(type); 214 } 215 216 @Override 217 public File[] getExternalFilesDirs(String type) { 218 return mBase.getExternalFilesDirs(type); 219 } 220 221 @Override 222 public File getObbDir() { 223 return mBase.getObbDir(); 224 } 225 226 @Override 227 public File[] getObbDirs() { 228 return mBase.getObbDirs(); 229 } 230 231 @Override 232 public File getCacheDir() { 233 return mBase.getCacheDir(); 234 } 235 236 @Override 237 public File getCodeCacheDir() { 238 return mBase.getCodeCacheDir(); 239 } 240 241 @Override 242 public File getExternalCacheDir() { 243 return mBase.getExternalCacheDir(); 244 } 245 246 @Override 247 public File[] getExternalCacheDirs() { 248 return mBase.getExternalCacheDirs(); 249 } 250 251 @Override 252 public File[] getExternalMediaDirs() { 253 return mBase.getExternalMediaDirs(); 254 } 255 256 @Override 257 public File getDir(String name, int mode) { 258 return mBase.getDir(name, mode); 259 } 260 261 @Override 262 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) { 263 return mBase.openOrCreateDatabase(name, mode, factory); 264 } 265 266 @Override 267 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory, 268 DatabaseErrorHandler errorHandler) { 269 return mBase.openOrCreateDatabase(name, mode, factory, errorHandler); 270 } 271 272 @Override 273 public boolean deleteDatabase(String name) { 274 return mBase.deleteDatabase(name); 275 } 276 277 @Override 278 public File getDatabasePath(String name) { 279 return mBase.getDatabasePath(name); 280 } 281 282 @Override 283 public String[] databaseList() { 284 return mBase.databaseList(); 285 } 286 287 @Override 288 @Deprecated 289 public Drawable getWallpaper() { 290 return mBase.getWallpaper(); 291 } 292 293 @Override 294 @Deprecated 295 public Drawable peekWallpaper() { 296 return mBase.peekWallpaper(); 297 } 298 299 @Override 300 @Deprecated 301 public int getWallpaperDesiredMinimumWidth() { 302 return mBase.getWallpaperDesiredMinimumWidth(); 303 } 304 305 @Override 306 @Deprecated 307 public int getWallpaperDesiredMinimumHeight() { 308 return mBase.getWallpaperDesiredMinimumHeight(); 309 } 310 311 @Override 312 @Deprecated 313 public void setWallpaper(Bitmap bitmap) throws IOException { 314 mBase.setWallpaper(bitmap); 315 } 316 317 @Override 318 @Deprecated 319 public void setWallpaper(InputStream data) throws IOException { 320 mBase.setWallpaper(data); 321 } 322 323 @Override 324 @Deprecated 325 public void clearWallpaper() throws IOException { 326 mBase.clearWallpaper(); 327 } 328 329 @Override 330 public void startActivity(Intent intent) { 331 mBase.startActivity(intent); 332 } 333 334 /** @hide */ 335 @Override 336 public void startActivityAsUser(Intent intent, UserHandle user) { 337 mBase.startActivityAsUser(intent, user); 338 } 339 340 /** @hide **/ 341 public void startActivityForResult( 342 String who, Intent intent, int requestCode, Bundle options) { 343 mBase.startActivityForResult(who, intent, requestCode, options); 344 } 345 346 /** @hide **/ 347 public boolean canStartActivityForResult() { 348 return mBase.canStartActivityForResult(); 349 } 350 351 @Override 352 public void startActivity(Intent intent, Bundle options) { 353 mBase.startActivity(intent, options); 354 } 355 356 /** @hide */ 357 @Override 358 public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) { 359 mBase.startActivityAsUser(intent, options, user); 360 } 361 362 @Override 363 public void startActivities(Intent[] intents) { 364 mBase.startActivities(intents); 365 } 366 367 @Override 368 public void startActivities(Intent[] intents, Bundle options) { 369 mBase.startActivities(intents, options); 370 } 371 372 /** @hide */ 373 @Override 374 public void startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle) { 375 mBase.startActivitiesAsUser(intents, options, userHandle); 376 } 377 378 @Override 379 public void startIntentSender(IntentSender intent, 380 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) 381 throws IntentSender.SendIntentException { 382 mBase.startIntentSender(intent, fillInIntent, flagsMask, 383 flagsValues, extraFlags); 384 } 385 386 @Override 387 public void startIntentSender(IntentSender intent, 388 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, 389 Bundle options) throws IntentSender.SendIntentException { 390 mBase.startIntentSender(intent, fillInIntent, flagsMask, 391 flagsValues, extraFlags, options); 392 } 393 394 @Override 395 public void sendBroadcast(Intent intent) { 396 mBase.sendBroadcast(intent); 397 } 398 399 @Override 400 public void sendBroadcast(Intent intent, String receiverPermission) { 401 mBase.sendBroadcast(intent, receiverPermission); 402 } 403 404 /** @hide */ 405 @Override 406 public void sendBroadcastMultiplePermissions(Intent intent, String[] receiverPermissions) { 407 mBase.sendBroadcastMultiplePermissions(intent, receiverPermissions); 408 } 409 410 /** @hide */ 411 @SystemApi 412 @Override 413 public void sendBroadcast(Intent intent, String receiverPermission, Bundle options) { 414 mBase.sendBroadcast(intent, receiverPermission, options); 415 } 416 417 /** @hide */ 418 @Override 419 public void sendBroadcast(Intent intent, String receiverPermission, int appOp) { 420 mBase.sendBroadcast(intent, receiverPermission, appOp); 421 } 422 423 @Override 424 public void sendOrderedBroadcast(Intent intent, 425 String receiverPermission) { 426 mBase.sendOrderedBroadcast(intent, receiverPermission); 427 } 428 429 @Override 430 public void sendOrderedBroadcast( 431 Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, 432 Handler scheduler, int initialCode, String initialData, 433 Bundle initialExtras) { 434 mBase.sendOrderedBroadcast(intent, receiverPermission, 435 resultReceiver, scheduler, initialCode, 436 initialData, initialExtras); 437 } 438 439 /** @hide */ 440 @SystemApi 441 @Override 442 public void sendOrderedBroadcast( 443 Intent intent, String receiverPermission, Bundle options, BroadcastReceiver resultReceiver, 444 Handler scheduler, int initialCode, String initialData, 445 Bundle initialExtras) { 446 mBase.sendOrderedBroadcast(intent, receiverPermission, 447 options, resultReceiver, scheduler, initialCode, 448 initialData, initialExtras); 449 } 450 451 /** @hide */ 452 @Override 453 public void sendOrderedBroadcast( 454 Intent intent, String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 455 Handler scheduler, int initialCode, String initialData, 456 Bundle initialExtras) { 457 mBase.sendOrderedBroadcast(intent, receiverPermission, appOp, 458 resultReceiver, scheduler, initialCode, 459 initialData, initialExtras); 460 } 461 462 @Override 463 public void sendBroadcastAsUser(Intent intent, UserHandle user) { 464 mBase.sendBroadcastAsUser(intent, user); 465 } 466 467 @Override 468 public void sendBroadcastAsUser(Intent intent, UserHandle user, 469 String receiverPermission) { 470 mBase.sendBroadcastAsUser(intent, user, receiverPermission); 471 } 472 473 /** @hide */ 474 @Override 475 public void sendBroadcastAsUser(Intent intent, UserHandle user, 476 String receiverPermission, int appOp) { 477 mBase.sendBroadcastAsUser(intent, user, receiverPermission, appOp); 478 } 479 480 @Override 481 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 482 String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, 483 int initialCode, String initialData, Bundle initialExtras) { 484 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, resultReceiver, 485 scheduler, initialCode, initialData, initialExtras); 486 } 487 488 /** @hide */ 489 @Override 490 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 491 String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 492 Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { 493 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, resultReceiver, 494 scheduler, initialCode, initialData, initialExtras); 495 } 496 497 /** @hide */ 498 @Override 499 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 500 String receiverPermission, int appOp, Bundle options, BroadcastReceiver resultReceiver, 501 Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { 502 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, options, 503 resultReceiver, scheduler, initialCode, initialData, initialExtras); 504 } 505 506 @Override 507 @Deprecated 508 public void sendStickyBroadcast(Intent intent) { 509 mBase.sendStickyBroadcast(intent); 510 } 511 512 @Override 513 @Deprecated 514 public void sendStickyOrderedBroadcast( 515 Intent intent, BroadcastReceiver resultReceiver, 516 Handler scheduler, int initialCode, String initialData, 517 Bundle initialExtras) { 518 mBase.sendStickyOrderedBroadcast(intent, 519 resultReceiver, scheduler, initialCode, 520 initialData, initialExtras); 521 } 522 523 @Override 524 @Deprecated 525 public void removeStickyBroadcast(Intent intent) { 526 mBase.removeStickyBroadcast(intent); 527 } 528 529 @Override 530 @Deprecated 531 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { 532 mBase.sendStickyBroadcastAsUser(intent, user); 533 } 534 535 @Override 536 @Deprecated 537 public void sendStickyOrderedBroadcastAsUser(Intent intent, 538 UserHandle user, BroadcastReceiver resultReceiver, 539 Handler scheduler, int initialCode, String initialData, 540 Bundle initialExtras) { 541 mBase.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver, 542 scheduler, initialCode, initialData, initialExtras); 543 } 544 545 @Override 546 @Deprecated 547 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 548 mBase.removeStickyBroadcastAsUser(intent, user); 549 } 550 551 @Override 552 public Intent registerReceiver( 553 BroadcastReceiver receiver, IntentFilter filter) { 554 return mBase.registerReceiver(receiver, filter); 555 } 556 557 @Override 558 public Intent registerReceiver( 559 BroadcastReceiver receiver, IntentFilter filter, 560 String broadcastPermission, Handler scheduler) { 561 return mBase.registerReceiver(receiver, filter, broadcastPermission, 562 scheduler); 563 } 564 565 /** @hide */ 566 @Override 567 public Intent registerReceiverAsUser( 568 BroadcastReceiver receiver, UserHandle user, IntentFilter filter, 569 String broadcastPermission, Handler scheduler) { 570 return mBase.registerReceiverAsUser(receiver, user, filter, broadcastPermission, 571 scheduler); 572 } 573 574 @Override 575 public void unregisterReceiver(BroadcastReceiver receiver) { 576 mBase.unregisterReceiver(receiver); 577 } 578 579 @Override 580 public ComponentName startService(Intent service) { 581 return mBase.startService(service); 582 } 583 584 @Override 585 public boolean stopService(Intent name) { 586 return mBase.stopService(name); 587 } 588 589 /** @hide */ 590 @Override 591 public ComponentName startServiceAsUser(Intent service, UserHandle user) { 592 return mBase.startServiceAsUser(service, user); 593 } 594 595 /** @hide */ 596 @Override 597 public boolean stopServiceAsUser(Intent name, UserHandle user) { 598 return mBase.stopServiceAsUser(name, user); 599 } 600 601 @Override 602 public boolean bindService(Intent service, ServiceConnection conn, 603 int flags) { 604 return mBase.bindService(service, conn, flags); 605 } 606 607 /** @hide */ 608 @Override 609 public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags, 610 UserHandle user) { 611 return mBase.bindServiceAsUser(service, conn, flags, user); 612 } 613 614 @Override 615 public void unbindService(ServiceConnection conn) { 616 mBase.unbindService(conn); 617 } 618 619 @Override 620 public boolean startInstrumentation(ComponentName className, 621 String profileFile, Bundle arguments) { 622 return mBase.startInstrumentation(className, profileFile, arguments); 623 } 624 625 @Override 626 public Object getSystemService(String name) { 627 return mBase.getSystemService(name); 628 } 629 630 @Override 631 public String getSystemServiceName(Class<?> serviceClass) { 632 return mBase.getSystemServiceName(serviceClass); 633 } 634 635 @Override 636 public int checkPermission(String permission, int pid, int uid) { 637 return mBase.checkPermission(permission, pid, uid); 638 } 639 640 /** @hide */ 641 @Override 642 public int checkPermission(String permission, int pid, int uid, IBinder callerToken) { 643 return mBase.checkPermission(permission, pid, uid, callerToken); 644 } 645 646 @Override 647 public int checkCallingPermission(String permission) { 648 return mBase.checkCallingPermission(permission); 649 } 650 651 @Override 652 public int checkCallingOrSelfPermission(String permission) { 653 return mBase.checkCallingOrSelfPermission(permission); 654 } 655 656 @Override 657 public int checkSelfPermission(String permission) { 658 return mBase.checkSelfPermission(permission); 659 } 660 661 @Override 662 public void enforcePermission( 663 String permission, int pid, int uid, String message) { 664 mBase.enforcePermission(permission, pid, uid, message); 665 } 666 667 @Override 668 public void enforceCallingPermission(String permission, String message) { 669 mBase.enforceCallingPermission(permission, message); 670 } 671 672 @Override 673 public void enforceCallingOrSelfPermission( 674 String permission, String message) { 675 mBase.enforceCallingOrSelfPermission(permission, message); 676 } 677 678 @Override 679 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 680 mBase.grantUriPermission(toPackage, uri, modeFlags); 681 } 682 683 @Override 684 public void revokeUriPermission(Uri uri, int modeFlags) { 685 mBase.revokeUriPermission(uri, modeFlags); 686 } 687 688 @Override 689 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 690 return mBase.checkUriPermission(uri, pid, uid, modeFlags); 691 } 692 693 /** @hide */ 694 @Override 695 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) { 696 return mBase.checkUriPermission(uri, pid, uid, modeFlags, callerToken); 697 } 698 699 @Override 700 public int checkCallingUriPermission(Uri uri, int modeFlags) { 701 return mBase.checkCallingUriPermission(uri, modeFlags); 702 } 703 704 @Override 705 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 706 return mBase.checkCallingOrSelfUriPermission(uri, modeFlags); 707 } 708 709 @Override 710 public int checkUriPermission(Uri uri, String readPermission, 711 String writePermission, int pid, int uid, int modeFlags) { 712 return mBase.checkUriPermission(uri, readPermission, writePermission, 713 pid, uid, modeFlags); 714 } 715 716 @Override 717 public void enforceUriPermission( 718 Uri uri, int pid, int uid, int modeFlags, String message) { 719 mBase.enforceUriPermission(uri, pid, uid, modeFlags, message); 720 } 721 722 @Override 723 public void enforceCallingUriPermission( 724 Uri uri, int modeFlags, String message) { 725 mBase.enforceCallingUriPermission(uri, modeFlags, message); 726 } 727 728 @Override 729 public void enforceCallingOrSelfUriPermission( 730 Uri uri, int modeFlags, String message) { 731 mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message); 732 } 733 734 @Override 735 public void enforceUriPermission( 736 Uri uri, String readPermission, String writePermission, 737 int pid, int uid, int modeFlags, String message) { 738 mBase.enforceUriPermission( 739 uri, readPermission, writePermission, pid, uid, modeFlags, 740 message); 741 } 742 743 @Override 744 public Context createPackageContext(String packageName, int flags) 745 throws PackageManager.NameNotFoundException { 746 return mBase.createPackageContext(packageName, flags); 747 } 748 749 /** @hide */ 750 @Override 751 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 752 throws PackageManager.NameNotFoundException { 753 return mBase.createPackageContextAsUser(packageName, flags, user); 754 } 755 756 /** @hide */ 757 @Override 758 public Context createApplicationContext(ApplicationInfo application, 759 int flags) throws PackageManager.NameNotFoundException { 760 return mBase.createApplicationContext(application, flags); 761 } 762 763 /** @hide */ 764 @Override 765 public int getUserId() { 766 return mBase.getUserId(); 767 } 768 769 @Override 770 public Context createConfigurationContext(Configuration overrideConfiguration) { 771 return mBase.createConfigurationContext(overrideConfiguration); 772 } 773 774 @Override 775 public Context createDisplayContext(Display display) { 776 return mBase.createDisplayContext(display); 777 } 778 779 @Override 780 public boolean isRestricted() { 781 return mBase.isRestricted(); 782 } 783 784 /** @hide */ 785 @Override 786 public DisplayAdjustments getDisplayAdjustments(int displayId) { 787 return mBase.getDisplayAdjustments(displayId); 788 } 789} 790