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