ContextWrapper.java revision 3cf75729d5a27b8ddd1ea174626dbcf0349a1d07
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 getExternalFilesDir(String type) { 206 return mBase.getExternalFilesDir(type); 207 } 208 209 @Override 210 public File[] getExternalFilesDirs(String type) { 211 return mBase.getExternalFilesDirs(type); 212 } 213 214 @Override 215 public File getObbDir() { 216 return mBase.getObbDir(); 217 } 218 219 @Override 220 public File[] getObbDirs() { 221 return mBase.getObbDirs(); 222 } 223 224 @Override 225 public File getCacheDir() { 226 return mBase.getCacheDir(); 227 } 228 229 @Override 230 public File getExternalCacheDir() { 231 return mBase.getExternalCacheDir(); 232 } 233 234 @Override 235 public File[] getExternalCacheDirs() { 236 return mBase.getExternalCacheDirs(); 237 } 238 239 @Override 240 public File getDir(String name, int mode) { 241 return mBase.getDir(name, mode); 242 } 243 244 @Override 245 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) { 246 return mBase.openOrCreateDatabase(name, mode, factory); 247 } 248 249 @Override 250 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory, 251 DatabaseErrorHandler errorHandler) { 252 return mBase.openOrCreateDatabase(name, mode, factory, errorHandler); 253 } 254 255 @Override 256 public boolean deleteDatabase(String name) { 257 return mBase.deleteDatabase(name); 258 } 259 260 @Override 261 public File getDatabasePath(String name) { 262 return mBase.getDatabasePath(name); 263 } 264 265 @Override 266 public String[] databaseList() { 267 return mBase.databaseList(); 268 } 269 270 @Override 271 public Drawable getWallpaper() { 272 return mBase.getWallpaper(); 273 } 274 275 @Override 276 public Drawable peekWallpaper() { 277 return mBase.peekWallpaper(); 278 } 279 280 @Override 281 public int getWallpaperDesiredMinimumWidth() { 282 return mBase.getWallpaperDesiredMinimumWidth(); 283 } 284 285 @Override 286 public int getWallpaperDesiredMinimumHeight() { 287 return mBase.getWallpaperDesiredMinimumHeight(); 288 } 289 290 @Override 291 public void setWallpaper(Bitmap bitmap) throws IOException { 292 mBase.setWallpaper(bitmap); 293 } 294 295 @Override 296 public void setWallpaper(InputStream data) throws IOException { 297 mBase.setWallpaper(data); 298 } 299 300 @Override 301 public void clearWallpaper() throws IOException { 302 mBase.clearWallpaper(); 303 } 304 305 @Override 306 public void startActivity(Intent intent) { 307 mBase.startActivity(intent); 308 } 309 310 /** @hide */ 311 @Override 312 public void startActivityAsUser(Intent intent, UserHandle user) { 313 mBase.startActivityAsUser(intent, user); 314 } 315 316 @Override 317 public void startActivity(Intent intent, Bundle options) { 318 mBase.startActivity(intent, options); 319 } 320 321 /** @hide */ 322 @Override 323 public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) { 324 mBase.startActivityAsUser(intent, options, user); 325 } 326 327 @Override 328 public void startActivities(Intent[] intents) { 329 mBase.startActivities(intents); 330 } 331 332 @Override 333 public void startActivities(Intent[] intents, Bundle options) { 334 mBase.startActivities(intents, options); 335 } 336 337 /** @hide */ 338 @Override 339 public void startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle) { 340 mBase.startActivitiesAsUser(intents, options, userHandle); 341 } 342 343 @Override 344 public void startIntentSender(IntentSender intent, 345 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) 346 throws IntentSender.SendIntentException { 347 mBase.startIntentSender(intent, fillInIntent, flagsMask, 348 flagsValues, extraFlags); 349 } 350 351 @Override 352 public void startIntentSender(IntentSender intent, 353 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, 354 Bundle options) throws IntentSender.SendIntentException { 355 mBase.startIntentSender(intent, fillInIntent, flagsMask, 356 flagsValues, extraFlags, options); 357 } 358 359 @Override 360 public void sendBroadcast(Intent intent) { 361 mBase.sendBroadcast(intent); 362 } 363 364 @Override 365 public void sendBroadcast(Intent intent, String receiverPermission) { 366 mBase.sendBroadcast(intent, receiverPermission); 367 } 368 369 /** @hide */ 370 @Override 371 public void sendBroadcast(Intent intent, String receiverPermission, int appOp) { 372 mBase.sendBroadcast(intent, receiverPermission, appOp); 373 } 374 375 @Override 376 public void sendOrderedBroadcast(Intent intent, 377 String receiverPermission) { 378 mBase.sendOrderedBroadcast(intent, receiverPermission); 379 } 380 381 @Override 382 public void sendOrderedBroadcast( 383 Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, 384 Handler scheduler, int initialCode, String initialData, 385 Bundle initialExtras) { 386 mBase.sendOrderedBroadcast(intent, receiverPermission, 387 resultReceiver, scheduler, initialCode, 388 initialData, initialExtras); 389 } 390 391 /** @hide */ 392 @Override 393 public void sendOrderedBroadcast( 394 Intent intent, String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 395 Handler scheduler, int initialCode, String initialData, 396 Bundle initialExtras) { 397 mBase.sendOrderedBroadcast(intent, receiverPermission, appOp, 398 resultReceiver, scheduler, initialCode, 399 initialData, initialExtras); 400 } 401 402 @Override 403 public void sendBroadcastAsUser(Intent intent, UserHandle user) { 404 mBase.sendBroadcastAsUser(intent, user); 405 } 406 407 @Override 408 public void sendBroadcastAsUser(Intent intent, UserHandle user, 409 String receiverPermission) { 410 mBase.sendBroadcastAsUser(intent, user, receiverPermission); 411 } 412 413 @Override 414 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 415 String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, 416 int initialCode, String initialData, Bundle initialExtras) { 417 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, resultReceiver, 418 scheduler, initialCode, initialData, initialExtras); 419 } 420 421 /** @hide */ 422 @Override 423 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 424 String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 425 Handler scheduler, 426 int initialCode, String initialData, Bundle initialExtras) { 427 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, resultReceiver, 428 scheduler, initialCode, initialData, initialExtras); 429 } 430 431 @Override 432 public void sendStickyBroadcast(Intent intent) { 433 mBase.sendStickyBroadcast(intent); 434 } 435 436 @Override 437 public void sendStickyOrderedBroadcast( 438 Intent intent, BroadcastReceiver resultReceiver, 439 Handler scheduler, int initialCode, String initialData, 440 Bundle initialExtras) { 441 mBase.sendStickyOrderedBroadcast(intent, 442 resultReceiver, scheduler, initialCode, 443 initialData, initialExtras); 444 } 445 446 @Override 447 public void removeStickyBroadcast(Intent intent) { 448 mBase.removeStickyBroadcast(intent); 449 } 450 451 @Override 452 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { 453 mBase.sendStickyBroadcastAsUser(intent, user); 454 } 455 456 @Override 457 public void sendStickyOrderedBroadcastAsUser(Intent intent, 458 UserHandle user, BroadcastReceiver resultReceiver, 459 Handler scheduler, int initialCode, String initialData, 460 Bundle initialExtras) { 461 mBase.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver, 462 scheduler, initialCode, initialData, initialExtras); 463 } 464 465 @Override 466 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 467 mBase.removeStickyBroadcastAsUser(intent, user); 468 } 469 470 @Override 471 public Intent registerReceiver( 472 BroadcastReceiver receiver, IntentFilter filter) { 473 return mBase.registerReceiver(receiver, filter); 474 } 475 476 @Override 477 public Intent registerReceiver( 478 BroadcastReceiver receiver, IntentFilter filter, 479 String broadcastPermission, Handler scheduler) { 480 return mBase.registerReceiver(receiver, filter, broadcastPermission, 481 scheduler); 482 } 483 484 /** @hide */ 485 @Override 486 public Intent registerReceiverAsUser( 487 BroadcastReceiver receiver, UserHandle user, IntentFilter filter, 488 String broadcastPermission, Handler scheduler) { 489 return mBase.registerReceiverAsUser(receiver, user, filter, broadcastPermission, 490 scheduler); 491 } 492 493 @Override 494 public void unregisterReceiver(BroadcastReceiver receiver) { 495 mBase.unregisterReceiver(receiver); 496 } 497 498 @Override 499 public ComponentName startService(Intent service) { 500 return mBase.startService(service); 501 } 502 503 @Override 504 public boolean stopService(Intent name) { 505 return mBase.stopService(name); 506 } 507 508 /** @hide */ 509 @Override 510 public ComponentName startServiceAsUser(Intent service, UserHandle user) { 511 return mBase.startServiceAsUser(service, user); 512 } 513 514 /** @hide */ 515 @Override 516 public boolean stopServiceAsUser(Intent name, UserHandle user) { 517 return mBase.stopServiceAsUser(name, user); 518 } 519 520 @Override 521 public boolean bindService(Intent service, ServiceConnection conn, 522 int flags) { 523 return mBase.bindService(service, conn, flags); 524 } 525 526 /** @hide */ 527 @Override 528 public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags, 529 UserHandle user) { 530 return mBase.bindServiceAsUser(service, conn, flags, user); 531 } 532 533 @Override 534 public void unbindService(ServiceConnection conn) { 535 mBase.unbindService(conn); 536 } 537 538 @Override 539 public boolean startInstrumentation(ComponentName className, 540 String profileFile, Bundle arguments) { 541 return mBase.startInstrumentation(className, profileFile, arguments); 542 } 543 544 @Override 545 public Object getSystemService(String name) { 546 return mBase.getSystemService(name); 547 } 548 549 @Override 550 public int checkPermission(String permission, int pid, int uid) { 551 return mBase.checkPermission(permission, pid, uid); 552 } 553 554 @Override 555 public int checkCallingPermission(String permission) { 556 return mBase.checkCallingPermission(permission); 557 } 558 559 @Override 560 public int checkCallingOrSelfPermission(String permission) { 561 return mBase.checkCallingOrSelfPermission(permission); 562 } 563 564 @Override 565 public void enforcePermission( 566 String permission, int pid, int uid, String message) { 567 mBase.enforcePermission(permission, pid, uid, message); 568 } 569 570 @Override 571 public void enforceCallingPermission(String permission, String message) { 572 mBase.enforceCallingPermission(permission, message); 573 } 574 575 @Override 576 public void enforceCallingOrSelfPermission( 577 String permission, String message) { 578 mBase.enforceCallingOrSelfPermission(permission, message); 579 } 580 581 @Override 582 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 583 mBase.grantUriPermission(toPackage, uri, modeFlags); 584 } 585 586 @Override 587 public void revokeUriPermission(Uri uri, int modeFlags) { 588 mBase.revokeUriPermission(uri, modeFlags); 589 } 590 591 @Override 592 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 593 return mBase.checkUriPermission(uri, pid, uid, modeFlags); 594 } 595 596 @Override 597 public int checkCallingUriPermission(Uri uri, int modeFlags) { 598 return mBase.checkCallingUriPermission(uri, modeFlags); 599 } 600 601 @Override 602 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 603 return mBase.checkCallingOrSelfUriPermission(uri, modeFlags); 604 } 605 606 @Override 607 public int checkUriPermission(Uri uri, String readPermission, 608 String writePermission, int pid, int uid, int modeFlags) { 609 return mBase.checkUriPermission(uri, readPermission, writePermission, 610 pid, uid, modeFlags); 611 } 612 613 @Override 614 public void enforceUriPermission( 615 Uri uri, int pid, int uid, int modeFlags, String message) { 616 mBase.enforceUriPermission(uri, pid, uid, modeFlags, message); 617 } 618 619 @Override 620 public void enforceCallingUriPermission( 621 Uri uri, int modeFlags, String message) { 622 mBase.enforceCallingUriPermission(uri, modeFlags, message); 623 } 624 625 @Override 626 public void enforceCallingOrSelfUriPermission( 627 Uri uri, int modeFlags, String message) { 628 mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message); 629 } 630 631 @Override 632 public void enforceUriPermission( 633 Uri uri, String readPermission, String writePermission, 634 int pid, int uid, int modeFlags, String message) { 635 mBase.enforceUriPermission( 636 uri, readPermission, writePermission, pid, uid, modeFlags, 637 message); 638 } 639 640 @Override 641 public Context createPackageContext(String packageName, int flags) 642 throws PackageManager.NameNotFoundException { 643 return mBase.createPackageContext(packageName, flags); 644 } 645 646 /** @hide */ 647 @Override 648 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 649 throws PackageManager.NameNotFoundException { 650 return mBase.createPackageContextAsUser(packageName, flags, user); 651 } 652 653 /** @hide */ 654 @Override 655 public int getUserId() { 656 return mBase.getUserId(); 657 } 658 659 @Override 660 public Context createConfigurationContext(Configuration overrideConfiguration) { 661 return mBase.createConfigurationContext(overrideConfiguration); 662 } 663 664 @Override 665 public Context createDisplayContext(Display display) { 666 return mBase.createDisplayContext(display); 667 } 668 669 @Override 670 public boolean isRestricted() { 671 return mBase.isRestricted(); 672 } 673 674 /** @hide */ 675 @Override 676 public DisplayAdjustments getDisplayAdjustments(int displayId) { 677 return mBase.getDisplayAdjustments(displayId); 678 } 679} 680