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 public Drawable getWallpaper() { 288 return mBase.getWallpaper(); 289 } 290 291 @Override 292 public Drawable peekWallpaper() { 293 return mBase.peekWallpaper(); 294 } 295 296 @Override 297 public int getWallpaperDesiredMinimumWidth() { 298 return mBase.getWallpaperDesiredMinimumWidth(); 299 } 300 301 @Override 302 public int getWallpaperDesiredMinimumHeight() { 303 return mBase.getWallpaperDesiredMinimumHeight(); 304 } 305 306 @Override 307 public void setWallpaper(Bitmap bitmap) throws IOException { 308 mBase.setWallpaper(bitmap); 309 } 310 311 @Override 312 public void setWallpaper(InputStream data) throws IOException { 313 mBase.setWallpaper(data); 314 } 315 316 @Override 317 public void clearWallpaper() throws IOException { 318 mBase.clearWallpaper(); 319 } 320 321 @Override 322 public void startActivity(Intent intent) { 323 mBase.startActivity(intent); 324 } 325 326 /** @hide */ 327 @Override 328 public void startActivityAsUser(Intent intent, UserHandle user) { 329 mBase.startActivityAsUser(intent, user); 330 } 331 332 @Override 333 public void startActivity(Intent intent, Bundle options) { 334 mBase.startActivity(intent, options); 335 } 336 337 /** @hide */ 338 @Override 339 public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) { 340 mBase.startActivityAsUser(intent, options, user); 341 } 342 343 @Override 344 public void startActivities(Intent[] intents) { 345 mBase.startActivities(intents); 346 } 347 348 @Override 349 public void startActivities(Intent[] intents, Bundle options) { 350 mBase.startActivities(intents, options); 351 } 352 353 /** @hide */ 354 @Override 355 public void startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle) { 356 mBase.startActivitiesAsUser(intents, options, userHandle); 357 } 358 359 @Override 360 public void startIntentSender(IntentSender intent, 361 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) 362 throws IntentSender.SendIntentException { 363 mBase.startIntentSender(intent, fillInIntent, flagsMask, 364 flagsValues, extraFlags); 365 } 366 367 @Override 368 public void startIntentSender(IntentSender intent, 369 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, 370 Bundle options) throws IntentSender.SendIntentException { 371 mBase.startIntentSender(intent, fillInIntent, flagsMask, 372 flagsValues, extraFlags, options); 373 } 374 375 @Override 376 public void sendBroadcast(Intent intent) { 377 mBase.sendBroadcast(intent); 378 } 379 380 @Override 381 public void sendBroadcast(Intent intent, String receiverPermission) { 382 mBase.sendBroadcast(intent, receiverPermission); 383 } 384 385 /** @hide */ 386 @Override 387 public void sendBroadcast(Intent intent, String receiverPermission, int appOp) { 388 mBase.sendBroadcast(intent, receiverPermission, appOp); 389 } 390 391 @Override 392 public void sendOrderedBroadcast(Intent intent, 393 String receiverPermission) { 394 mBase.sendOrderedBroadcast(intent, receiverPermission); 395 } 396 397 @Override 398 public void sendOrderedBroadcast( 399 Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, 400 Handler scheduler, int initialCode, String initialData, 401 Bundle initialExtras) { 402 mBase.sendOrderedBroadcast(intent, receiverPermission, 403 resultReceiver, scheduler, initialCode, 404 initialData, initialExtras); 405 } 406 407 /** @hide */ 408 @Override 409 public void sendOrderedBroadcast( 410 Intent intent, String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 411 Handler scheduler, int initialCode, String initialData, 412 Bundle initialExtras) { 413 mBase.sendOrderedBroadcast(intent, receiverPermission, appOp, 414 resultReceiver, scheduler, initialCode, 415 initialData, initialExtras); 416 } 417 418 @Override 419 public void sendBroadcastAsUser(Intent intent, UserHandle user) { 420 mBase.sendBroadcastAsUser(intent, user); 421 } 422 423 @Override 424 public void sendBroadcastAsUser(Intent intent, UserHandle user, 425 String receiverPermission) { 426 mBase.sendBroadcastAsUser(intent, user, receiverPermission); 427 } 428 429 @Override 430 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 431 String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, 432 int initialCode, String initialData, Bundle initialExtras) { 433 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, resultReceiver, 434 scheduler, initialCode, initialData, initialExtras); 435 } 436 437 /** @hide */ 438 @Override 439 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 440 String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 441 Handler scheduler, 442 int initialCode, String initialData, Bundle initialExtras) { 443 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, resultReceiver, 444 scheduler, initialCode, initialData, initialExtras); 445 } 446 447 @Override 448 public void sendStickyBroadcast(Intent intent) { 449 mBase.sendStickyBroadcast(intent); 450 } 451 452 @Override 453 public void sendStickyOrderedBroadcast( 454 Intent intent, BroadcastReceiver resultReceiver, 455 Handler scheduler, int initialCode, String initialData, 456 Bundle initialExtras) { 457 mBase.sendStickyOrderedBroadcast(intent, 458 resultReceiver, scheduler, initialCode, 459 initialData, initialExtras); 460 } 461 462 @Override 463 public void removeStickyBroadcast(Intent intent) { 464 mBase.removeStickyBroadcast(intent); 465 } 466 467 @Override 468 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { 469 mBase.sendStickyBroadcastAsUser(intent, user); 470 } 471 472 @Override 473 public void sendStickyOrderedBroadcastAsUser(Intent intent, 474 UserHandle user, BroadcastReceiver resultReceiver, 475 Handler scheduler, int initialCode, String initialData, 476 Bundle initialExtras) { 477 mBase.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver, 478 scheduler, initialCode, initialData, initialExtras); 479 } 480 481 @Override 482 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 483 mBase.removeStickyBroadcastAsUser(intent, user); 484 } 485 486 @Override 487 public Intent registerReceiver( 488 BroadcastReceiver receiver, IntentFilter filter) { 489 return mBase.registerReceiver(receiver, filter); 490 } 491 492 @Override 493 public Intent registerReceiver( 494 BroadcastReceiver receiver, IntentFilter filter, 495 String broadcastPermission, Handler scheduler) { 496 return mBase.registerReceiver(receiver, filter, broadcastPermission, 497 scheduler); 498 } 499 500 /** @hide */ 501 @Override 502 public Intent registerReceiverAsUser( 503 BroadcastReceiver receiver, UserHandle user, IntentFilter filter, 504 String broadcastPermission, Handler scheduler) { 505 return mBase.registerReceiverAsUser(receiver, user, filter, broadcastPermission, 506 scheduler); 507 } 508 509 @Override 510 public void unregisterReceiver(BroadcastReceiver receiver) { 511 mBase.unregisterReceiver(receiver); 512 } 513 514 @Override 515 public ComponentName startService(Intent service) { 516 return mBase.startService(service); 517 } 518 519 @Override 520 public boolean stopService(Intent name) { 521 return mBase.stopService(name); 522 } 523 524 /** @hide */ 525 @Override 526 public ComponentName startServiceAsUser(Intent service, UserHandle user) { 527 return mBase.startServiceAsUser(service, user); 528 } 529 530 /** @hide */ 531 @Override 532 public boolean stopServiceAsUser(Intent name, UserHandle user) { 533 return mBase.stopServiceAsUser(name, user); 534 } 535 536 @Override 537 public boolean bindService(Intent service, ServiceConnection conn, 538 int flags) { 539 return mBase.bindService(service, conn, flags); 540 } 541 542 /** @hide */ 543 @Override 544 public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags, 545 UserHandle user) { 546 return mBase.bindServiceAsUser(service, conn, flags, user); 547 } 548 549 @Override 550 public void unbindService(ServiceConnection conn) { 551 mBase.unbindService(conn); 552 } 553 554 @Override 555 public boolean startInstrumentation(ComponentName className, 556 String profileFile, Bundle arguments) { 557 return mBase.startInstrumentation(className, profileFile, arguments); 558 } 559 560 @Override 561 public Object getSystemService(String name) { 562 return mBase.getSystemService(name); 563 } 564 565 @Override 566 public int checkPermission(String permission, int pid, int uid) { 567 return mBase.checkPermission(permission, pid, uid); 568 } 569 570 /** @hide */ 571 @Override 572 public int checkPermission(String permission, int pid, int uid, IBinder callerToken) { 573 return mBase.checkPermission(permission, pid, uid, callerToken); 574 } 575 576 @Override 577 public int checkCallingPermission(String permission) { 578 return mBase.checkCallingPermission(permission); 579 } 580 581 @Override 582 public int checkCallingOrSelfPermission(String permission) { 583 return mBase.checkCallingOrSelfPermission(permission); 584 } 585 586 @Override 587 public void enforcePermission( 588 String permission, int pid, int uid, String message) { 589 mBase.enforcePermission(permission, pid, uid, message); 590 } 591 592 @Override 593 public void enforceCallingPermission(String permission, String message) { 594 mBase.enforceCallingPermission(permission, message); 595 } 596 597 @Override 598 public void enforceCallingOrSelfPermission( 599 String permission, String message) { 600 mBase.enforceCallingOrSelfPermission(permission, message); 601 } 602 603 @Override 604 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 605 mBase.grantUriPermission(toPackage, uri, modeFlags); 606 } 607 608 @Override 609 public void revokeUriPermission(Uri uri, int modeFlags) { 610 mBase.revokeUriPermission(uri, modeFlags); 611 } 612 613 @Override 614 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 615 return mBase.checkUriPermission(uri, pid, uid, modeFlags); 616 } 617 618 /** @hide */ 619 @Override 620 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) { 621 return mBase.checkUriPermission(uri, pid, uid, modeFlags, callerToken); 622 } 623 624 @Override 625 public int checkCallingUriPermission(Uri uri, int modeFlags) { 626 return mBase.checkCallingUriPermission(uri, modeFlags); 627 } 628 629 @Override 630 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 631 return mBase.checkCallingOrSelfUriPermission(uri, modeFlags); 632 } 633 634 @Override 635 public int checkUriPermission(Uri uri, String readPermission, 636 String writePermission, int pid, int uid, int modeFlags) { 637 return mBase.checkUriPermission(uri, readPermission, writePermission, 638 pid, uid, modeFlags); 639 } 640 641 @Override 642 public void enforceUriPermission( 643 Uri uri, int pid, int uid, int modeFlags, String message) { 644 mBase.enforceUriPermission(uri, pid, uid, modeFlags, message); 645 } 646 647 @Override 648 public void enforceCallingUriPermission( 649 Uri uri, int modeFlags, String message) { 650 mBase.enforceCallingUriPermission(uri, modeFlags, message); 651 } 652 653 @Override 654 public void enforceCallingOrSelfUriPermission( 655 Uri uri, int modeFlags, String message) { 656 mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message); 657 } 658 659 @Override 660 public void enforceUriPermission( 661 Uri uri, String readPermission, String writePermission, 662 int pid, int uid, int modeFlags, String message) { 663 mBase.enforceUriPermission( 664 uri, readPermission, writePermission, pid, uid, modeFlags, 665 message); 666 } 667 668 @Override 669 public Context createPackageContext(String packageName, int flags) 670 throws PackageManager.NameNotFoundException { 671 return mBase.createPackageContext(packageName, flags); 672 } 673 674 /** @hide */ 675 @Override 676 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 677 throws PackageManager.NameNotFoundException { 678 return mBase.createPackageContextAsUser(packageName, flags, user); 679 } 680 681 /** @hide */ 682 public Context createApplicationContext(ApplicationInfo application, 683 int flags) throws PackageManager.NameNotFoundException { 684 return mBase.createApplicationContext(application, flags); 685 } 686 687 /** @hide */ 688 @Override 689 public int getUserId() { 690 return mBase.getUserId(); 691 } 692 693 @Override 694 public Context createConfigurationContext(Configuration overrideConfiguration) { 695 return mBase.createConfigurationContext(overrideConfiguration); 696 } 697 698 @Override 699 public Context createDisplayContext(Display display) { 700 return mBase.createDisplayContext(display); 701 } 702 703 @Override 704 public boolean isRestricted() { 705 return mBase.isRestricted(); 706 } 707 708 /** @hide */ 709 @Override 710 public DisplayAdjustments getDisplayAdjustments(int displayId) { 711 return mBase.getDisplayAdjustments(displayId); 712 } 713} 714