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