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