core/java/android/content/ContextWrapper.java

   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.annotation.SystemApi;
  20 import android.app.IApplicationThread;
  21 import android.app.IServiceConnection;
  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.IBinder;
  36 import android.os.Looper;
  37 import android.os.UserHandle;
  38 import android.view.Display;
  39 import android.view.DisplayAdjustments;
  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         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     /** @hide */
 138     @Override
 139     public String getBasePackageName() {
 140         return mBase.getBasePackageName();
 141     }
 142
 143     /** @hide */
 144     @Override
 145     public String getOpPackageName() {
 146         return mBase.getOpPackageName();
 147     }
 148
 149     @Override
 150     public ApplicationInfo getApplicationInfo() {
 151         return mBase.getApplicationInfo();
 152     }
 153
 154     @Override
 155     public String getPackageResourcePath() {
 156         return mBase.getPackageResourcePath();
 157     }
 158
 159     @Override
 160     public String getPackageCodePath() {
 161         return mBase.getPackageCodePath();
 162     }
 163
 164     @Override
 165     public SharedPreferences getSharedPreferences(String name, int mode) {
 166         return mBase.getSharedPreferences(name, mode);
 167     }
 168
 169     /** @removed */
 170     @Override
 171     public SharedPreferences getSharedPreferences(File file, int mode) {
 172         return mBase.getSharedPreferences(file, mode);
 173     }
 174
 175     /** @hide */
 176     @Override
 177     public void reloadSharedPreferences() {
 178         mBase.reloadSharedPreferences();
 179     }
 180
 181     @Override
 182     public boolean moveSharedPreferencesFrom(Context sourceContext, String name) {
 183         return mBase.moveSharedPreferencesFrom(sourceContext, name);
 184     }
 185
 186     @Override
 187     public boolean deleteSharedPreferences(String name) {
 188         return mBase.deleteSharedPreferences(name);
 189     }
 190
 191     @Override
 192     public FileInputStream openFileInput(String name)
 193         throws FileNotFoundException {
 194         return mBase.openFileInput(name);
 195     }
 196
 197     @Override
 198     public FileOutputStream openFileOutput(String name, int mode)
 199         throws FileNotFoundException {
 200         return mBase.openFileOutput(name, mode);
 201     }
 202
 203     @Override
 204     public boolean deleteFile(String name) {
 205         return mBase.deleteFile(name);
 206     }
 207
 208     @Override
 209     public File getFileStreamPath(String name) {
 210         return mBase.getFileStreamPath(name);
 211     }
 212
 213     /** @removed */
 214     @Override
 215     public File getSharedPreferencesPath(String name) {
 216         return mBase.getSharedPreferencesPath(name);
 217     }
 218
 219     @Override
 220     public String[] fileList() {
 221         return mBase.fileList();
 222     }
 223
 224     @Override
 225     public File getDataDir() {
 226         return mBase.getDataDir();
 227     }
 228
 229     @Override
 230     public File getFilesDir() {
 231         return mBase.getFilesDir();
 232     }
 233
 234     @Override
 235     public File getNoBackupFilesDir() {
 236         return mBase.getNoBackupFilesDir();
 237     }
 238
 239     @Override
 240     public File getExternalFilesDir(String type) {
 241         return mBase.getExternalFilesDir(type);
 242     }
 243
 244     @Override
 245     public File[] getExternalFilesDirs(String type) {
 246         return mBase.getExternalFilesDirs(type);
 247     }
 248
 249     @Override
 250     public File getObbDir() {
 251         return mBase.getObbDir();
 252     }
 253
 254     @Override
 255     public File[] getObbDirs() {
 256         return mBase.getObbDirs();
 257     }
 258
 259     @Override
 260     public File getCacheDir() {
 261         return mBase.getCacheDir();
 262     }
 263
 264     @Override
 265     public File getCodeCacheDir() {
 266         return mBase.getCodeCacheDir();
 267     }
 268
 269     @Override
 270     public File getExternalCacheDir() {
 271         return mBase.getExternalCacheDir();
 272     }
 273
 274     @Override
 275     public File[] getExternalCacheDirs() {
 276         return mBase.getExternalCacheDirs();
 277     }
 278
 279     @Override
 280     public File[] getExternalMediaDirs() {
 281         return mBase.getExternalMediaDirs();
 282     }
 283
 284     @Override
 285     public File getDir(String name, int mode) {
 286         return mBase.getDir(name, mode);
 287     }
 288
 289
 290     /** @hide **/
 291     @Override
 292     public File getPreloadsFileCache() {
 293         return mBase.getPreloadsFileCache();
 294     }
 295
 296     @Override
 297     public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) {
 298         return mBase.openOrCreateDatabase(name, mode, factory);
 299     }
 300
 301     @Override
 302     public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory,
 303             DatabaseErrorHandler errorHandler) {
 304         return mBase.openOrCreateDatabase(name, mode, factory, errorHandler);
 305     }
 306
 307     @Override
 308     public boolean moveDatabaseFrom(Context sourceContext, String name) {
 309         return mBase.moveDatabaseFrom(sourceContext, name);
 310     }
 311
 312     @Override
 313     public boolean deleteDatabase(String name) {
 314         return mBase.deleteDatabase(name);
 315     }
 316
 317     @Override
 318     public File getDatabasePath(String name) {
 319         return mBase.getDatabasePath(name);
 320     }
 321
 322     @Override
 323     public String[] databaseList() {
 324         return mBase.databaseList();
 325     }
 326
 327     @Override
 328     @Deprecated
 329     public Drawable getWallpaper() {
 330         return mBase.getWallpaper();
 331     }
 332
 333     @Override
 334     @Deprecated
 335     public Drawable peekWallpaper() {
 336         return mBase.peekWallpaper();
 337     }
 338
 339     @Override
 340     @Deprecated
 341     public int getWallpaperDesiredMinimumWidth() {
 342         return mBase.getWallpaperDesiredMinimumWidth();
 343     }
 344
 345     @Override
 346     @Deprecated
 347     public int getWallpaperDesiredMinimumHeight() {
 348         return mBase.getWallpaperDesiredMinimumHeight();
 349     }
 350
 351     @Override
 352     @Deprecated
 353     public void setWallpaper(Bitmap bitmap) throws IOException {
 354         mBase.setWallpaper(bitmap);
 355     }
 356
 357     @Override
 358     @Deprecated
 359     public void setWallpaper(InputStream data) throws IOException {
 360         mBase.setWallpaper(data);
 361     }
 362
 363     @Override
 364     @Deprecated
 365     public void clearWallpaper() throws IOException {
 366         mBase.clearWallpaper();
 367     }
 368
 369     @Override
 370     public void startActivity(Intent intent) {
 371         mBase.startActivity(intent);
 372     }
 373
 374     /** @hide */
 375     @Override
 376     public void startActivityAsUser(Intent intent, UserHandle user) {
 377         mBase.startActivityAsUser(intent, user);
 378     }
 379
 380     /** @hide **/
 381     public void startActivityForResult(
 382             String who, Intent intent, int requestCode, Bundle options) {
 383         mBase.startActivityForResult(who, intent, requestCode, options);
 384     }
 385
 386     /** @hide **/
 387     public boolean canStartActivityForResult() {
 388         return mBase.canStartActivityForResult();
 389     }
 390
 391     @Override
 392     public void startActivity(Intent intent, Bundle options) {
 393         mBase.startActivity(intent, options);
 394     }
 395
 396     /** @hide */
 397     @Override
 398     public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) {
 399         mBase.startActivityAsUser(intent, options, user);
 400     }
 401
 402     @Override
 403     public void startActivities(Intent[] intents) {
 404         mBase.startActivities(intents);
 405     }
 406
 407     @Override
 408     public void startActivities(Intent[] intents, Bundle options) {
 409         mBase.startActivities(intents, options);
 410     }
 411
 412     /** @hide */
 413     @Override
 414     public void startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle) {
 415         mBase.startActivitiesAsUser(intents, options, userHandle);
 416     }
 417
 418     @Override
 419     public void startIntentSender(IntentSender intent,
 420             Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags)
 421             throws IntentSender.SendIntentException {
 422         mBase.startIntentSender(intent, fillInIntent, flagsMask,
 423                 flagsValues, extraFlags);
 424     }
 425
 426     @Override
 427     public void startIntentSender(IntentSender intent,
 428             Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags,
 429             Bundle options) throws IntentSender.SendIntentException {
 430         mBase.startIntentSender(intent, fillInIntent, flagsMask,
 431                 flagsValues, extraFlags, options);
 432     }
 433
 434     @Override
 435     public void sendBroadcast(Intent intent) {
 436         mBase.sendBroadcast(intent);
 437     }
 438
 439     @Override
 440     public void sendBroadcast(Intent intent, String receiverPermission) {
 441         mBase.sendBroadcast(intent, receiverPermission);
 442     }
 443
 444     /** @hide */
 445     @Override
 446     public void sendBroadcastMultiplePermissions(Intent intent, String[] receiverPermissions) {
 447         mBase.sendBroadcastMultiplePermissions(intent, receiverPermissions);
 448     }
 449
 450     /** @hide */
 451     @SystemApi
 452     @Override
 453     public void sendBroadcast(Intent intent, String receiverPermission, Bundle options) {
 454         mBase.sendBroadcast(intent, receiverPermission, options);
 455     }
 456
 457     /** @hide */
 458     @Override
 459     public void sendBroadcast(Intent intent, String receiverPermission, int appOp) {
 460         mBase.sendBroadcast(intent, receiverPermission, appOp);
 461     }
 462
 463     @Override
 464     public void sendOrderedBroadcast(Intent intent,
 465             String receiverPermission) {
 466         mBase.sendOrderedBroadcast(intent, receiverPermission);
 467     }
 468
 469     @Override
 470     public void sendOrderedBroadcast(
 471         Intent intent, String receiverPermission, BroadcastReceiver resultReceiver,
 472         Handler scheduler, int initialCode, String initialData,
 473         Bundle initialExtras) {
 474         mBase.sendOrderedBroadcast(intent, receiverPermission,
 475                 resultReceiver, scheduler, initialCode,
 476                 initialData, initialExtras);
 477     }
 478
 479     /** @hide */
 480     @SystemApi
 481     @Override
 482     public void sendOrderedBroadcast(
 483             Intent intent, String receiverPermission, Bundle options, BroadcastReceiver resultReceiver,
 484             Handler scheduler, int initialCode, String initialData,
 485             Bundle initialExtras) {
 486         mBase.sendOrderedBroadcast(intent, receiverPermission,
 487                 options, resultReceiver, scheduler, initialCode,
 488                 initialData, initialExtras);
 489     }
 490
 491     /** @hide */
 492     @Override
 493     public void sendOrderedBroadcast(
 494         Intent intent, String receiverPermission, int appOp, BroadcastReceiver resultReceiver,
 495         Handler scheduler, int initialCode, String initialData,
 496         Bundle initialExtras) {
 497         mBase.sendOrderedBroadcast(intent, receiverPermission, appOp,
 498                 resultReceiver, scheduler, initialCode,
 499                 initialData, initialExtras);
 500     }
 501
 502     @Override
 503     public void sendBroadcastAsUser(Intent intent, UserHandle user) {
 504         mBase.sendBroadcastAsUser(intent, user);
 505     }
 506
 507     @Override
 508     public void sendBroadcastAsUser(Intent intent, UserHandle user,
 509             String receiverPermission) {
 510         mBase.sendBroadcastAsUser(intent, user, receiverPermission);
 511     }
 512
 513     /** @hide */
 514     @Override
 515     public void sendBroadcastAsUser(Intent intent, UserHandle user,
 516             String receiverPermission, Bundle options) {
 517         mBase.sendBroadcastAsUser(intent, user, receiverPermission, options);
 518     }
 519
 520     /** @hide */
 521     @Override
 522     public void sendBroadcastAsUser(Intent intent, UserHandle user,
 523             String receiverPermission, int appOp) {
 524         mBase.sendBroadcastAsUser(intent, user, receiverPermission, appOp);
 525     }
 526
 527     @Override
 528     public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user,
 529             String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler,
 530             int initialCode, String initialData, Bundle initialExtras) {
 531         mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, resultReceiver,
 532                 scheduler, initialCode, initialData, initialExtras);
 533     }
 534
 535     /** @hide */
 536     @Override
 537     public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user,
 538             String receiverPermission, int appOp, BroadcastReceiver resultReceiver,
 539             Handler scheduler, int initialCode, String initialData, Bundle initialExtras) {
 540         mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, resultReceiver,
 541                 scheduler, initialCode, initialData, initialExtras);
 542     }
 543
 544     /** @hide */
 545     @Override
 546     public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user,
 547             String receiverPermission, int appOp, Bundle options, BroadcastReceiver resultReceiver,
 548             Handler scheduler, int initialCode, String initialData, Bundle initialExtras) {
 549         mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, options,
 550                 resultReceiver, scheduler, initialCode, initialData, initialExtras);
 551     }
 552
 553     @Override
 554     @Deprecated
 555     public void sendStickyBroadcast(Intent intent) {
 556         mBase.sendStickyBroadcast(intent);
 557     }
 558
 559     @Override
 560     @Deprecated
 561     public void sendStickyOrderedBroadcast(
 562         Intent intent, BroadcastReceiver resultReceiver,
 563         Handler scheduler, int initialCode, String initialData,
 564         Bundle initialExtras) {
 565         mBase.sendStickyOrderedBroadcast(intent,
 566                 resultReceiver, scheduler, initialCode,
 567                 initialData, initialExtras);
 568     }
 569
 570     @Override
 571     @Deprecated
 572     public void removeStickyBroadcast(Intent intent) {
 573         mBase.removeStickyBroadcast(intent);
 574     }
 575
 576     @Override
 577     @Deprecated
 578     public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) {
 579         mBase.sendStickyBroadcastAsUser(intent, user);
 580     }
 581
 582     /** @hide */
 583     @Override
 584     @Deprecated
 585     public void sendStickyBroadcastAsUser(Intent intent, UserHandle user, Bundle options) {
 586         mBase.sendStickyBroadcastAsUser(intent, user, options);
 587     }
 588
 589     @Override
 590     @Deprecated
 591     public void sendStickyOrderedBroadcastAsUser(Intent intent,
 592             UserHandle user, BroadcastReceiver resultReceiver,
 593             Handler scheduler, int initialCode, String initialData,
 594             Bundle initialExtras) {
 595         mBase.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver,
 596                 scheduler, initialCode, initialData, initialExtras);
 597     }
 598
 599     @Override
 600     @Deprecated
 601     public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) {
 602         mBase.removeStickyBroadcastAsUser(intent, user);
 603     }
 604
 605     @Override
 606     public Intent registerReceiver(
 607         BroadcastReceiver receiver, IntentFilter filter) {
 608         return mBase.registerReceiver(receiver, filter);
 609     }
 610
 611     @Override
 612     public Intent registerReceiver(
 613         BroadcastReceiver receiver, IntentFilter filter, int flags) {
 614         return mBase.registerReceiver(receiver, filter, flags);
 615     }
 616
 617     @Override
 618     public Intent registerReceiver(
 619         BroadcastReceiver receiver, IntentFilter filter,
 620         String broadcastPermission, Handler scheduler) {
 621         return mBase.registerReceiver(receiver, filter, broadcastPermission,
 622                 scheduler);
 623     }
 624
 625     @Override
 626     public Intent registerReceiver(
 627         BroadcastReceiver receiver, IntentFilter filter,
 628         String broadcastPermission, Handler scheduler, int flags) {
 629         return mBase.registerReceiver(receiver, filter, broadcastPermission,
 630                 scheduler, flags);
 631     }
 632
 633     /** @hide */
 634     @Override
 635     public Intent registerReceiverAsUser(
 636         BroadcastReceiver receiver, UserHandle user, IntentFilter filter,
 637         String broadcastPermission, Handler scheduler) {
 638         return mBase.registerReceiverAsUser(receiver, user, filter, broadcastPermission,
 639                 scheduler);
 640     }
 641
 642     @Override
 643     public void unregisterReceiver(BroadcastReceiver receiver) {
 644         mBase.unregisterReceiver(receiver);
 645     }
 646
 647     @Override
 648     public ComponentName startService(Intent service) {
 649         return mBase.startService(service);
 650     }
 651
 652     @Override
 653     public ComponentName startForegroundService(Intent service) {
 654         return mBase.startForegroundService(service);
 655     }
 656
 657     @Override
 658     public boolean stopService(Intent name) {
 659         return mBase.stopService(name);
 660     }
 661
 662     /** @hide */
 663     @Override
 664     public ComponentName startServiceAsUser(Intent service, UserHandle user) {
 665         return mBase.startServiceAsUser(service, user);
 666     }
 667
 668     /** @hide */
 669     @Override
 670     public ComponentName startForegroundServiceAsUser(Intent service, UserHandle user) {
 671         return mBase.startForegroundServiceAsUser(service, user);
 672     }
 673
 674     /** @hide */
 675     @Override
 676     public boolean stopServiceAsUser(Intent name, UserHandle user) {
 677         return mBase.stopServiceAsUser(name, user);
 678     }
 679
 680     @Override
 681     public boolean bindService(Intent service, ServiceConnection conn,
 682             int flags) {
 683         return mBase.bindService(service, conn, flags);
 684     }
 685
 686     /** @hide */
 687     @Override
 688     public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags,
 689             UserHandle user) {
 690         return mBase.bindServiceAsUser(service, conn, flags, user);
 691     }
 692
 693     /** @hide */
 694     @Override
 695     public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags,
 696             Handler handler, UserHandle user) {
 697         return mBase.bindServiceAsUser(service, conn, flags, handler, user);
 698     }
 699
 700     @Override
 701     public void unbindService(ServiceConnection conn) {
 702         mBase.unbindService(conn);
 703     }
 704
 705     @Override
 706     public boolean startInstrumentation(ComponentName className,
 707             String profileFile, Bundle arguments) {
 708         return mBase.startInstrumentation(className, profileFile, arguments);
 709     }
 710
 711     @Override
 712     public Object getSystemService(String name) {
 713         return mBase.getSystemService(name);
 714     }
 715
 716     @Override
 717     public String getSystemServiceName(Class<?> serviceClass) {
 718         return mBase.getSystemServiceName(serviceClass);
 719     }
 720
 721     @Override
 722     public int checkPermission(String permission, int pid, int uid) {
 723         return mBase.checkPermission(permission, pid, uid);
 724     }
 725
 726     /** @hide */
 727     @Override
 728     public int checkPermission(String permission, int pid, int uid, IBinder callerToken) {
 729         return mBase.checkPermission(permission, pid, uid, callerToken);
 730     }
 731
 732     @Override
 733     public int checkCallingPermission(String permission) {
 734         return mBase.checkCallingPermission(permission);
 735     }
 736
 737     @Override
 738     public int checkCallingOrSelfPermission(String permission) {
 739         return mBase.checkCallingOrSelfPermission(permission);
 740     }
 741
 742     @Override
 743     public int checkSelfPermission(String permission) {
 744        return mBase.checkSelfPermission(permission);
 745     }
 746
 747     @Override
 748     public void enforcePermission(
 749             String permission, int pid, int uid, String message) {
 750         mBase.enforcePermission(permission, pid, uid, message);
 751     }
 752
 753     @Override
 754     public void enforceCallingPermission(String permission, String message) {
 755         mBase.enforceCallingPermission(permission, message);
 756     }
 757
 758     @Override
 759     public void enforceCallingOrSelfPermission(
 760             String permission, String message) {
 761         mBase.enforceCallingOrSelfPermission(permission, message);
 762     }
 763
 764     @Override
 765     public void grantUriPermission(String toPackage, Uri uri, int modeFlags) {
 766         mBase.grantUriPermission(toPackage, uri, modeFlags);
 767     }
 768
 769     @Override
 770     public void revokeUriPermission(Uri uri, int modeFlags) {
 771         mBase.revokeUriPermission(uri, modeFlags);
 772     }
 773
 774     @Override
 775     public void revokeUriPermission(String targetPackage, Uri uri, int modeFlags) {
 776         mBase.revokeUriPermission(targetPackage, uri, modeFlags);
 777     }
 778
 779     @Override
 780     public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) {
 781         return mBase.checkUriPermission(uri, pid, uid, modeFlags);
 782     }
 783
 784     /** @hide */
 785     @Override
 786     public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) {
 787         return mBase.checkUriPermission(uri, pid, uid, modeFlags, callerToken);
 788     }
 789
 790     @Override
 791     public int checkCallingUriPermission(Uri uri, int modeFlags) {
 792         return mBase.checkCallingUriPermission(uri, modeFlags);
 793     }
 794
 795     @Override
 796     public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) {
 797         return mBase.checkCallingOrSelfUriPermission(uri, modeFlags);
 798     }
 799
 800     @Override
 801     public int checkUriPermission(Uri uri, String readPermission,
 802             String writePermission, int pid, int uid, int modeFlags) {
 803         return mBase.checkUriPermission(uri, readPermission, writePermission,
 804                 pid, uid, modeFlags);
 805     }
 806
 807     @Override
 808     public void enforceUriPermission(
 809             Uri uri, int pid, int uid, int modeFlags, String message) {
 810         mBase.enforceUriPermission(uri, pid, uid, modeFlags, message);
 811     }
 812
 813     @Override
 814     public void enforceCallingUriPermission(
 815             Uri uri, int modeFlags, String message) {
 816         mBase.enforceCallingUriPermission(uri, modeFlags, message);
 817     }
 818
 819     @Override
 820     public void enforceCallingOrSelfUriPermission(
 821             Uri uri, int modeFlags, String message) {
 822         mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message);
 823     }
 824
 825     @Override
 826     public void enforceUriPermission(
 827             Uri uri, String readPermission, String writePermission,
 828             int pid, int uid, int modeFlags, String message) {
 829         mBase.enforceUriPermission(
 830                 uri, readPermission, writePermission, pid, uid, modeFlags,
 831                 message);
 832     }
 833
 834     @Override
 835     public Context createPackageContext(String packageName, int flags)
 836         throws PackageManager.NameNotFoundException {
 837         return mBase.createPackageContext(packageName, flags);
 838     }
 839
 840     /** @hide */
 841     @Override
 842     public Context createPackageContextAsUser(String packageName, int flags, UserHandle user)
 843             throws PackageManager.NameNotFoundException {
 844         return mBase.createPackageContextAsUser(packageName, flags, user);
 845     }
 846
 847     /** @hide */
 848     @Override
 849     public Context createApplicationContext(ApplicationInfo application,
 850             int flags) throws PackageManager.NameNotFoundException {
 851         return mBase.createApplicationContext(application, flags);
 852     }
 853
 854     /** @hide */
 855     @Override
 856     public Context createContextForSplit(String splitName)
 857             throws PackageManager.NameNotFoundException {
 858         return mBase.createContextForSplit(splitName);
 859     }
 860
 861     /** @hide */
 862     @Override
 863     public int getUserId() {
 864         return mBase.getUserId();
 865     }
 866
 867     @Override
 868     public Context createConfigurationContext(Configuration overrideConfiguration) {
 869         return mBase.createConfigurationContext(overrideConfiguration);
 870     }
 871
 872     @Override
 873     public Context createDisplayContext(Display display) {
 874         return mBase.createDisplayContext(display);
 875     }
 876
 877     @Override
 878     public boolean isRestricted() {
 879         return mBase.isRestricted();
 880     }
 881
 882     /** @hide */
 883     @Override
 884     public DisplayAdjustments getDisplayAdjustments(int displayId) {
 885         return mBase.getDisplayAdjustments(displayId);
 886     }
 887
 888     /**
 889      * @hide
 890      */
 891     @Override
 892     public Display getDisplay() {
 893         return mBase.getDisplay();
 894     }
 895
 896     /**
 897      * @hide
 898      */
 899     @Override
 900     public void updateDisplay(int displayId) {
 901         mBase.updateDisplay(displayId);
 902     }
 903
 904     @Override
 905     public Context createDeviceProtectedStorageContext() {
 906         return mBase.createDeviceProtectedStorageContext();
 907     }
 908
 909     /** {@hide} */
 910     @SystemApi
 911     @Override
 912     public Context createCredentialProtectedStorageContext() {
 913         return mBase.createCredentialProtectedStorageContext();
 914     }
 915
 916     @Override
 917     public boolean isDeviceProtectedStorage() {
 918         return mBase.isDeviceProtectedStorage();
 919     }
 920
 921     /** {@hide} */
 922     @SystemApi
 923     @Override
 924     public boolean isCredentialProtectedStorage() {
 925         return mBase.isCredentialProtectedStorage();
 926     }
 927
 928     /** {@hide} */
 929     @Override
 930     public boolean canLoadUnsafeResources() {
 931         return mBase.canLoadUnsafeResources();
 932     }
 933
 934     /**
 935      * @hide
 936      */
 937     @Override
 938     public IBinder getActivityToken() {
 939         return mBase.getActivityToken();
 940     }
 941
 942     /**
 943      * @hide
 944      */
 945     @Override
 946     public IServiceConnection getServiceDispatcher(ServiceConnection conn, Handler handler,
 947             int flags) {
 948         return mBase.getServiceDispatcher(conn, handler, flags);
 949     }
 950
 951     /**
 952      * @hide
 953      */
 954     @Override
 955     public IApplicationThread getIApplicationThread() {
 956         return mBase.getIApplicationThread();
 957     }
 958
 959     /**
 960      * @hide
 961      */
 962     @Override
 963     public Handler getMainThreadHandler() {
 964         return mBase.getMainThreadHandler();
 965     }
 966
 967     /**
 968      * @hide
 969      */
 970     public int getNextAutofillId() {
 971         return mBase.getNextAutofillId();
 972     }
 973 }