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 17 package android.content; 18 19 import android.app.Activity; 20 import android.app.ActivityManagerNative; 21 import android.app.LoadedApk; 22 import android.content.pm.ApplicationInfo; 23 import android.content.pm.PackageManager; 24 import android.content.res.AssetManager; 25 import android.content.res.Configuration; 26 import android.content.res.Resources; 27 import android.database.DatabaseErrorHandler; 28 import android.database.sqlite.SQLiteDatabase; 29 import android.database.sqlite.SQLiteDatabase.CursorFactory; 30 import android.graphics.Bitmap; 31 import android.graphics.drawable.Drawable; 32 import android.net.Uri; 33 import android.os.Bundle; 34 import android.os.Handler; 35 import android.os.Looper; 36 import android.os.RemoteException; 37 import android.os.UserHandle; 38 import android.view.CompatibilityInfoHolder; 39 import android.view.Display; 40 41 import java.io.File; 42 import java.io.FileInputStream; 43 import java.io.FileNotFoundException; 44 import java.io.FileOutputStream; 45 import java.io.IOException; 46 import 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 */ 53 public 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 @Override 145 public ApplicationInfo getApplicationInfo() { 146 return mBase.getApplicationInfo(); 147 } 148 149 @Override 150 public String getPackageResourcePath() { 151 return mBase.getPackageResourcePath(); 152 } 153 154 @Override 155 public String getPackageCodePath() { 156 return mBase.getPackageCodePath(); 157 } 158 159 /** @hide */ 160 @Override 161 public File getSharedPrefsFile(String name) { 162 return mBase.getSharedPrefsFile(name); 163 } 164 165 @Override 166 public SharedPreferences getSharedPreferences(String name, int mode) { 167 return mBase.getSharedPreferences(name, mode); 168 } 169 170 @Override 171 public FileInputStream openFileInput(String name) 172 throws FileNotFoundException { 173 return mBase.openFileInput(name); 174 } 175 176 @Override 177 public FileOutputStream openFileOutput(String name, int mode) 178 throws FileNotFoundException { 179 return mBase.openFileOutput(name, mode); 180 } 181 182 @Override 183 public boolean deleteFile(String name) { 184 return mBase.deleteFile(name); 185 } 186 187 @Override 188 public File getFileStreamPath(String name) { 189 return mBase.getFileStreamPath(name); 190 } 191 192 @Override 193 public String[] fileList() { 194 return mBase.fileList(); 195 } 196 197 @Override 198 public File getFilesDir() { 199 return mBase.getFilesDir(); 200 } 201 202 @Override 203 public File getExternalFilesDir(String type) { 204 return mBase.getExternalFilesDir(type); 205 } 206 207 @Override 208 public File getObbDir() { 209 return mBase.getObbDir(); 210 } 211 212 @Override 213 public File getCacheDir() { 214 return mBase.getCacheDir(); 215 } 216 217 @Override 218 public File getExternalCacheDir() { 219 return mBase.getExternalCacheDir(); 220 } 221 222 @Override 223 public File getDir(String name, int mode) { 224 return mBase.getDir(name, mode); 225 } 226 227 @Override 228 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) { 229 return mBase.openOrCreateDatabase(name, mode, factory); 230 } 231 232 @Override 233 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory, 234 DatabaseErrorHandler errorHandler) { 235 return mBase.openOrCreateDatabase(name, mode, factory, errorHandler); 236 } 237 238 @Override 239 public boolean deleteDatabase(String name) { 240 return mBase.deleteDatabase(name); 241 } 242 243 @Override 244 public File getDatabasePath(String name) { 245 return mBase.getDatabasePath(name); 246 } 247 248 @Override 249 public String[] databaseList() { 250 return mBase.databaseList(); 251 } 252 253 @Override 254 public Drawable getWallpaper() { 255 return mBase.getWallpaper(); 256 } 257 258 @Override 259 public Drawable peekWallpaper() { 260 return mBase.peekWallpaper(); 261 } 262 263 @Override 264 public int getWallpaperDesiredMinimumWidth() { 265 return mBase.getWallpaperDesiredMinimumWidth(); 266 } 267 268 @Override 269 public int getWallpaperDesiredMinimumHeight() { 270 return mBase.getWallpaperDesiredMinimumHeight(); 271 } 272 273 @Override 274 public void setWallpaper(Bitmap bitmap) throws IOException { 275 mBase.setWallpaper(bitmap); 276 } 277 278 @Override 279 public void setWallpaper(InputStream data) throws IOException { 280 mBase.setWallpaper(data); 281 } 282 283 @Override 284 public void clearWallpaper() throws IOException { 285 mBase.clearWallpaper(); 286 } 287 288 @Override 289 public void startActivity(Intent intent) { 290 mBase.startActivity(intent); 291 } 292 293 /** @hide */ 294 @Override 295 public void startActivityAsUser(Intent intent, UserHandle user) { 296 mBase.startActivityAsUser(intent, user); 297 } 298 299 @Override 300 public void startActivity(Intent intent, Bundle options) { 301 mBase.startActivity(intent, options); 302 } 303 304 /** @hide */ 305 @Override 306 public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) { 307 mBase.startActivityAsUser(intent, options, user); 308 } 309 310 @Override 311 public void startActivities(Intent[] intents) { 312 mBase.startActivities(intents); 313 } 314 315 @Override 316 public void startActivities(Intent[] intents, Bundle options) { 317 mBase.startActivities(intents, options); 318 } 319 320 /** @hide */ 321 @Override 322 public void startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle) { 323 mBase.startActivitiesAsUser(intents, options, userHandle); 324 } 325 326 @Override 327 public void startIntentSender(IntentSender intent, 328 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) 329 throws IntentSender.SendIntentException { 330 mBase.startIntentSender(intent, fillInIntent, flagsMask, 331 flagsValues, extraFlags); 332 } 333 334 @Override 335 public void startIntentSender(IntentSender intent, 336 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, 337 Bundle options) throws IntentSender.SendIntentException { 338 mBase.startIntentSender(intent, fillInIntent, flagsMask, 339 flagsValues, extraFlags, options); 340 } 341 342 @Override 343 public void sendBroadcast(Intent intent) { 344 mBase.sendBroadcast(intent); 345 } 346 347 @Override 348 public void sendBroadcast(Intent intent, String receiverPermission) { 349 mBase.sendBroadcast(intent, receiverPermission); 350 } 351 352 /** @hide */ 353 @Override 354 public void sendBroadcast(Intent intent, String receiverPermission, int appOp) { 355 mBase.sendBroadcast(intent, receiverPermission, appOp); 356 } 357 358 @Override 359 public void sendOrderedBroadcast(Intent intent, 360 String receiverPermission) { 361 mBase.sendOrderedBroadcast(intent, receiverPermission); 362 } 363 364 @Override 365 public void sendOrderedBroadcast( 366 Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, 367 Handler scheduler, int initialCode, String initialData, 368 Bundle initialExtras) { 369 mBase.sendOrderedBroadcast(intent, receiverPermission, 370 resultReceiver, scheduler, initialCode, 371 initialData, initialExtras); 372 } 373 374 /** @hide */ 375 @Override 376 public void sendOrderedBroadcast( 377 Intent intent, String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 378 Handler scheduler, int initialCode, String initialData, 379 Bundle initialExtras) { 380 mBase.sendOrderedBroadcast(intent, receiverPermission, appOp, 381 resultReceiver, scheduler, initialCode, 382 initialData, initialExtras); 383 } 384 385 @Override 386 public void sendBroadcastAsUser(Intent intent, UserHandle user) { 387 mBase.sendBroadcastAsUser(intent, user); 388 } 389 390 @Override 391 public void sendBroadcastAsUser(Intent intent, UserHandle user, 392 String receiverPermission) { 393 mBase.sendBroadcastAsUser(intent, user, receiverPermission); 394 } 395 396 @Override 397 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 398 String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, 399 int initialCode, String initialData, Bundle initialExtras) { 400 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, resultReceiver, 401 scheduler, initialCode, initialData, initialExtras); 402 } 403 404 @Override 405 public void sendStickyBroadcast(Intent intent) { 406 mBase.sendStickyBroadcast(intent); 407 } 408 409 @Override 410 public void sendStickyOrderedBroadcast( 411 Intent intent, BroadcastReceiver resultReceiver, 412 Handler scheduler, int initialCode, String initialData, 413 Bundle initialExtras) { 414 mBase.sendStickyOrderedBroadcast(intent, 415 resultReceiver, scheduler, initialCode, 416 initialData, initialExtras); 417 } 418 419 @Override 420 public void removeStickyBroadcast(Intent intent) { 421 mBase.removeStickyBroadcast(intent); 422 } 423 424 @Override 425 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { 426 mBase.sendStickyBroadcastAsUser(intent, user); 427 } 428 429 @Override 430 public void sendStickyOrderedBroadcastAsUser(Intent intent, 431 UserHandle user, BroadcastReceiver resultReceiver, 432 Handler scheduler, int initialCode, String initialData, 433 Bundle initialExtras) { 434 mBase.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver, 435 scheduler, initialCode, initialData, initialExtras); 436 } 437 438 @Override 439 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 440 mBase.removeStickyBroadcastAsUser(intent, user); 441 } 442 443 @Override 444 public Intent registerReceiver( 445 BroadcastReceiver receiver, IntentFilter filter) { 446 return mBase.registerReceiver(receiver, filter); 447 } 448 449 @Override 450 public Intent registerReceiver( 451 BroadcastReceiver receiver, IntentFilter filter, 452 String broadcastPermission, Handler scheduler) { 453 return mBase.registerReceiver(receiver, filter, broadcastPermission, 454 scheduler); 455 } 456 457 /** @hide */ 458 @Override 459 public Intent registerReceiverAsUser( 460 BroadcastReceiver receiver, UserHandle user, IntentFilter filter, 461 String broadcastPermission, Handler scheduler) { 462 return mBase.registerReceiverAsUser(receiver, user, filter, broadcastPermission, 463 scheduler); 464 } 465 466 @Override 467 public void unregisterReceiver(BroadcastReceiver receiver) { 468 mBase.unregisterReceiver(receiver); 469 } 470 471 @Override 472 public ComponentName startService(Intent service) { 473 return mBase.startService(service); 474 } 475 476 @Override 477 public boolean stopService(Intent name) { 478 return mBase.stopService(name); 479 } 480 481 /** @hide */ 482 @Override 483 public ComponentName startServiceAsUser(Intent service, UserHandle user) { 484 return mBase.startServiceAsUser(service, user); 485 } 486 487 /** @hide */ 488 @Override 489 public boolean stopServiceAsUser(Intent name, UserHandle user) { 490 return mBase.stopServiceAsUser(name, user); 491 } 492 493 @Override 494 public boolean bindService(Intent service, ServiceConnection conn, 495 int flags) { 496 return mBase.bindService(service, conn, flags); 497 } 498 499 /** @hide */ 500 @Override 501 public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags, 502 UserHandle user) { 503 return mBase.bindServiceAsUser(service, conn, flags, user); 504 } 505 506 @Override 507 public void unbindService(ServiceConnection conn) { 508 mBase.unbindService(conn); 509 } 510 511 @Override 512 public boolean startInstrumentation(ComponentName className, 513 String profileFile, Bundle arguments) { 514 return mBase.startInstrumentation(className, profileFile, arguments); 515 } 516 517 @Override 518 public Object getSystemService(String name) { 519 return mBase.getSystemService(name); 520 } 521 522 @Override 523 public int checkPermission(String permission, int pid, int uid) { 524 return mBase.checkPermission(permission, pid, uid); 525 } 526 527 @Override 528 public int checkCallingPermission(String permission) { 529 return mBase.checkCallingPermission(permission); 530 } 531 532 @Override 533 public int checkCallingOrSelfPermission(String permission) { 534 return mBase.checkCallingOrSelfPermission(permission); 535 } 536 537 @Override 538 public void enforcePermission( 539 String permission, int pid, int uid, String message) { 540 mBase.enforcePermission(permission, pid, uid, message); 541 } 542 543 @Override 544 public void enforceCallingPermission(String permission, String message) { 545 mBase.enforceCallingPermission(permission, message); 546 } 547 548 @Override 549 public void enforceCallingOrSelfPermission( 550 String permission, String message) { 551 mBase.enforceCallingOrSelfPermission(permission, message); 552 } 553 554 @Override 555 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 556 mBase.grantUriPermission(toPackage, uri, modeFlags); 557 } 558 559 @Override 560 public void revokeUriPermission(Uri uri, int modeFlags) { 561 mBase.revokeUriPermission(uri, modeFlags); 562 } 563 564 @Override 565 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 566 return mBase.checkUriPermission(uri, pid, uid, modeFlags); 567 } 568 569 @Override 570 public int checkCallingUriPermission(Uri uri, int modeFlags) { 571 return mBase.checkCallingUriPermission(uri, modeFlags); 572 } 573 574 @Override 575 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 576 return mBase.checkCallingOrSelfUriPermission(uri, modeFlags); 577 } 578 579 @Override 580 public int checkUriPermission(Uri uri, String readPermission, 581 String writePermission, int pid, int uid, int modeFlags) { 582 return mBase.checkUriPermission(uri, readPermission, writePermission, 583 pid, uid, modeFlags); 584 } 585 586 @Override 587 public void enforceUriPermission( 588 Uri uri, int pid, int uid, int modeFlags, String message) { 589 mBase.enforceUriPermission(uri, pid, uid, modeFlags, message); 590 } 591 592 @Override 593 public void enforceCallingUriPermission( 594 Uri uri, int modeFlags, String message) { 595 mBase.enforceCallingUriPermission(uri, modeFlags, message); 596 } 597 598 @Override 599 public void enforceCallingOrSelfUriPermission( 600 Uri uri, int modeFlags, String message) { 601 mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message); 602 } 603 604 @Override 605 public void enforceUriPermission( 606 Uri uri, String readPermission, String writePermission, 607 int pid, int uid, int modeFlags, String message) { 608 mBase.enforceUriPermission( 609 uri, readPermission, writePermission, pid, uid, modeFlags, 610 message); 611 } 612 613 @Override 614 public Context createPackageContext(String packageName, int flags) 615 throws PackageManager.NameNotFoundException { 616 return mBase.createPackageContext(packageName, flags); 617 } 618 619 /** @hide */ 620 @Override 621 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 622 throws PackageManager.NameNotFoundException { 623 return mBase.createPackageContextAsUser(packageName, flags, user); 624 } 625 626 /** @hide */ 627 @Override 628 public int getUserId() { 629 return mBase.getUserId(); 630 } 631 632 @Override 633 public Context createConfigurationContext(Configuration overrideConfiguration) { 634 return mBase.createConfigurationContext(overrideConfiguration); 635 } 636 637 @Override 638 public Context createDisplayContext(Display display) { 639 return mBase.createDisplayContext(display); 640 } 641 642 @Override 643 public boolean isRestricted() { 644 return mBase.isRestricted(); 645 } 646 647 /** @hide */ 648 @Override 649 public CompatibilityInfoHolder getCompatibilityInfo(int displayId) { 650 return mBase.getCompatibilityInfo(displayId); 651 } 652 } 653