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