ContextWrapper.java revision 621e17de87f18003aba2dedb719a2941020a7902
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 @Override 110 public Resources.Theme getTheme() { 111 return mBase.getTheme(); 112 } 113 114 @Override 115 public ClassLoader getClassLoader() { 116 return mBase.getClassLoader(); 117 } 118 119 @Override 120 public String getPackageName() { 121 return mBase.getPackageName(); 122 } 123 124 @Override 125 public ApplicationInfo getApplicationInfo() { 126 return mBase.getApplicationInfo(); 127 } 128 129 @Override 130 public String getPackageResourcePath() { 131 return mBase.getPackageResourcePath(); 132 } 133 134 @Override 135 public String getPackageCodePath() { 136 return mBase.getPackageCodePath(); 137 } 138 139 /** @hide */ 140 @Override 141 public File getSharedPrefsFile(String name) { 142 return mBase.getSharedPrefsFile(name); 143 } 144 145 @Override 146 public SharedPreferences getSharedPreferences(String name, int mode) { 147 return mBase.getSharedPreferences(name, mode); 148 } 149 150 @Override 151 public FileInputStream openFileInput(String name) 152 throws FileNotFoundException { 153 return mBase.openFileInput(name); 154 } 155 156 @Override 157 public FileOutputStream openFileOutput(String name, int mode) 158 throws FileNotFoundException { 159 return mBase.openFileOutput(name, mode); 160 } 161 162 @Override 163 public boolean deleteFile(String name) { 164 return mBase.deleteFile(name); 165 } 166 167 @Override 168 public File getFileStreamPath(String name) { 169 return mBase.getFileStreamPath(name); 170 } 171 172 @Override 173 public String[] fileList() { 174 return mBase.fileList(); 175 } 176 177 @Override 178 public File getFilesDir() { 179 return mBase.getFilesDir(); 180 } 181 182 @Override 183 public File getExternalFilesDir(String type) { 184 return mBase.getExternalFilesDir(type); 185 } 186 187 @Override 188 public File getCacheDir() { 189 return mBase.getCacheDir(); 190 } 191 192 @Override 193 public File getExternalCacheDir() { 194 return mBase.getExternalCacheDir(); 195 } 196 197 @Override 198 public File getDir(String name, int mode) { 199 return mBase.getDir(name, mode); 200 } 201 202 @Override 203 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) { 204 return mBase.openOrCreateDatabase(name, mode, factory); 205 } 206 207 @Override 208 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory, 209 DatabaseErrorHandler errorHandler) { 210 return mBase.openOrCreateDatabase(name, mode, factory, errorHandler); 211 } 212 213 @Override 214 public boolean deleteDatabase(String name) { 215 return mBase.deleteDatabase(name); 216 } 217 218 @Override 219 public File getDatabasePath(String name) { 220 return mBase.getDatabasePath(name); 221 } 222 223 @Override 224 public String[] databaseList() { 225 return mBase.databaseList(); 226 } 227 228 @Override 229 public Drawable getWallpaper() { 230 return mBase.getWallpaper(); 231 } 232 233 @Override 234 public Drawable peekWallpaper() { 235 return mBase.peekWallpaper(); 236 } 237 238 @Override 239 public int getWallpaperDesiredMinimumWidth() { 240 return mBase.getWallpaperDesiredMinimumWidth(); 241 } 242 243 @Override 244 public int getWallpaperDesiredMinimumHeight() { 245 return mBase.getWallpaperDesiredMinimumHeight(); 246 } 247 248 @Override 249 public void setWallpaper(Bitmap bitmap) throws IOException { 250 mBase.setWallpaper(bitmap); 251 } 252 253 @Override 254 public void setWallpaper(InputStream data) throws IOException { 255 mBase.setWallpaper(data); 256 } 257 258 @Override 259 public void clearWallpaper() throws IOException { 260 mBase.clearWallpaper(); 261 } 262 263 @Override 264 public void startActivity(Intent intent) { 265 mBase.startActivity(intent); 266 } 267 268 @Override 269 public void startActivities(Intent[] intents) { 270 mBase.startActivities(intents); 271 } 272 273 @Override 274 public void startIntentSender(IntentSender intent, 275 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) 276 throws IntentSender.SendIntentException { 277 mBase.startIntentSender(intent, fillInIntent, flagsMask, 278 flagsValues, extraFlags); 279 } 280 281 @Override 282 public void sendBroadcast(Intent intent) { 283 mBase.sendBroadcast(intent); 284 } 285 286 @Override 287 public void sendBroadcast(Intent intent, String receiverPermission) { 288 mBase.sendBroadcast(intent, receiverPermission); 289 } 290 291 @Override 292 public void sendOrderedBroadcast(Intent intent, 293 String receiverPermission) { 294 mBase.sendOrderedBroadcast(intent, receiverPermission); 295 } 296 297 @Override 298 public void sendOrderedBroadcast( 299 Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, 300 Handler scheduler, int initialCode, String initialData, 301 Bundle initialExtras) { 302 mBase.sendOrderedBroadcast(intent, receiverPermission, 303 resultReceiver, scheduler, initialCode, 304 initialData, initialExtras); 305 } 306 307 @Override 308 public void sendStickyBroadcast(Intent intent) { 309 mBase.sendStickyBroadcast(intent); 310 } 311 312 @Override 313 public void sendStickyOrderedBroadcast( 314 Intent intent, BroadcastReceiver resultReceiver, 315 Handler scheduler, int initialCode, String initialData, 316 Bundle initialExtras) { 317 mBase.sendStickyOrderedBroadcast(intent, 318 resultReceiver, scheduler, initialCode, 319 initialData, initialExtras); 320 } 321 322 @Override 323 public void removeStickyBroadcast(Intent intent) { 324 mBase.removeStickyBroadcast(intent); 325 } 326 327 @Override 328 public Intent registerReceiver( 329 BroadcastReceiver receiver, IntentFilter filter) { 330 return mBase.registerReceiver(receiver, filter); 331 } 332 333 @Override 334 public Intent registerReceiver( 335 BroadcastReceiver receiver, IntentFilter filter, 336 String broadcastPermission, Handler scheduler) { 337 return mBase.registerReceiver(receiver, filter, broadcastPermission, 338 scheduler); 339 } 340 341 @Override 342 public void unregisterReceiver(BroadcastReceiver receiver) { 343 mBase.unregisterReceiver(receiver); 344 } 345 346 @Override 347 public ComponentName startService(Intent service) { 348 return mBase.startService(service); 349 } 350 351 @Override 352 public boolean stopService(Intent name) { 353 return mBase.stopService(name); 354 } 355 356 @Override 357 public boolean bindService(Intent service, ServiceConnection conn, 358 int flags) { 359 return mBase.bindService(service, conn, flags); 360 } 361 362 @Override 363 public void unbindService(ServiceConnection conn) { 364 mBase.unbindService(conn); 365 } 366 367 @Override 368 public boolean startInstrumentation(ComponentName className, 369 String profileFile, Bundle arguments) { 370 return mBase.startInstrumentation(className, profileFile, arguments); 371 } 372 373 @Override 374 public Object getSystemService(String name) { 375 return mBase.getSystemService(name); 376 } 377 378 @Override 379 public int checkPermission(String permission, int pid, int uid) { 380 return mBase.checkPermission(permission, pid, uid); 381 } 382 383 @Override 384 public int checkCallingPermission(String permission) { 385 return mBase.checkCallingPermission(permission); 386 } 387 388 @Override 389 public int checkCallingOrSelfPermission(String permission) { 390 return mBase.checkCallingOrSelfPermission(permission); 391 } 392 393 @Override 394 public void enforcePermission( 395 String permission, int pid, int uid, String message) { 396 mBase.enforcePermission(permission, pid, uid, message); 397 } 398 399 @Override 400 public void enforceCallingPermission(String permission, String message) { 401 mBase.enforceCallingPermission(permission, message); 402 } 403 404 @Override 405 public void enforceCallingOrSelfPermission( 406 String permission, String message) { 407 mBase.enforceCallingOrSelfPermission(permission, message); 408 } 409 410 @Override 411 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 412 mBase.grantUriPermission(toPackage, uri, modeFlags); 413 } 414 415 @Override 416 public void revokeUriPermission(Uri uri, int modeFlags) { 417 mBase.revokeUriPermission(uri, modeFlags); 418 } 419 420 @Override 421 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 422 return mBase.checkUriPermission(uri, pid, uid, modeFlags); 423 } 424 425 @Override 426 public int checkCallingUriPermission(Uri uri, int modeFlags) { 427 return mBase.checkCallingUriPermission(uri, modeFlags); 428 } 429 430 @Override 431 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 432 return mBase.checkCallingOrSelfUriPermission(uri, modeFlags); 433 } 434 435 @Override 436 public int checkUriPermission(Uri uri, String readPermission, 437 String writePermission, int pid, int uid, int modeFlags) { 438 return mBase.checkUriPermission(uri, readPermission, writePermission, 439 pid, uid, modeFlags); 440 } 441 442 @Override 443 public void enforceUriPermission( 444 Uri uri, int pid, int uid, int modeFlags, String message) { 445 mBase.enforceUriPermission(uri, pid, uid, modeFlags, message); 446 } 447 448 @Override 449 public void enforceCallingUriPermission( 450 Uri uri, int modeFlags, String message) { 451 mBase.enforceCallingUriPermission(uri, modeFlags, message); 452 } 453 454 @Override 455 public void enforceCallingOrSelfUriPermission( 456 Uri uri, int modeFlags, String message) { 457 mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message); 458 } 459 460 @Override 461 public void enforceUriPermission( 462 Uri uri, String readPermission, String writePermission, 463 int pid, int uid, int modeFlags, String message) { 464 mBase.enforceUriPermission( 465 uri, readPermission, writePermission, pid, uid, modeFlags, 466 message); 467 } 468 469 @Override 470 public Context createPackageContext(String packageName, int flags) 471 throws PackageManager.NameNotFoundException { 472 return mBase.createPackageContext(packageName, flags); 473 } 474 475 @Override 476 public boolean isRestricted() { 477 return mBase.isRestricted(); 478 } 479} 480