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