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