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