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