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