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