ContextWrapper.java revision 35871f2c2bb114806b4e3f109960b7f863d7885c
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.annotation.SystemApi; 20import android.content.pm.ApplicationInfo; 21import android.content.pm.PackageManager; 22import android.content.res.AssetManager; 23import android.content.res.Configuration; 24import android.content.res.Resources; 25import android.database.DatabaseErrorHandler; 26import android.database.sqlite.SQLiteDatabase; 27import android.database.sqlite.SQLiteDatabase.CursorFactory; 28import android.graphics.Bitmap; 29import android.graphics.drawable.Drawable; 30import android.net.Uri; 31import android.os.Bundle; 32import android.os.Handler; 33import android.os.IBinder; 34import android.os.Looper; 35import android.os.UserHandle; 36import android.view.DisplayAdjustments; 37import android.view.Display; 38 39import java.io.File; 40import java.io.FileInputStream; 41import java.io.FileNotFoundException; 42import java.io.FileOutputStream; 43import java.io.IOException; 44import java.io.InputStream; 45 46/** 47 * Proxying implementation of Context that simply delegates all of its calls to 48 * another Context. Can be subclassed to modify behavior without changing 49 * the original Context. 50 */ 51public class ContextWrapper extends Context { 52 Context mBase; 53 54 public ContextWrapper(Context base) { 55 mBase = base; 56 } 57 58 /** 59 * Set the base context for this ContextWrapper. All calls will then be 60 * delegated to the base context. Throws 61 * IllegalStateException if a base context has already been set. 62 * 63 * @param base The new base context for this wrapper. 64 */ 65 protected void attachBaseContext(Context base) { 66 if (mBase != null) { 67 throw new IllegalStateException("Base context already set"); 68 } 69 mBase = base; 70 } 71 72 /** 73 * @return the base context as set by the constructor or setBaseContext 74 */ 75 public Context getBaseContext() { 76 return mBase; 77 } 78 79 @Override 80 public AssetManager getAssets() { 81 return mBase.getAssets(); 82 } 83 84 @Override 85 public Resources getResources() { 86 return mBase.getResources(); 87 } 88 89 @Override 90 public PackageManager getPackageManager() { 91 return mBase.getPackageManager(); 92 } 93 94 @Override 95 public ContentResolver getContentResolver() { 96 return mBase.getContentResolver(); 97 } 98 99 @Override 100 public Looper getMainLooper() { 101 return mBase.getMainLooper(); 102 } 103 104 @Override 105 public Context getApplicationContext() { 106 return mBase.getApplicationContext(); 107 } 108 109 @Override 110 public void setTheme(int resid) { 111 mBase.setTheme(resid); 112 } 113 114 /** @hide */ 115 @Override 116 public int getThemeResId() { 117 return mBase.getThemeResId(); 118 } 119 120 @Override 121 public Resources.Theme getTheme() { 122 return mBase.getTheme(); 123 } 124 125 @Override 126 public ClassLoader getClassLoader() { 127 return mBase.getClassLoader(); 128 } 129 130 @Override 131 public String getPackageName() { 132 return mBase.getPackageName(); 133 } 134 135 /** @hide */ 136 @Override 137 public String getBasePackageName() { 138 return mBase.getBasePackageName(); 139 } 140 141 /** @hide */ 142 @Override 143 public String getOpPackageName() { 144 return mBase.getOpPackageName(); 145 } 146 147 @Override 148 public ApplicationInfo getApplicationInfo() { 149 return mBase.getApplicationInfo(); 150 } 151 152 @Override 153 public String getPackageResourcePath() { 154 return mBase.getPackageResourcePath(); 155 } 156 157 @Override 158 public String getPackageCodePath() { 159 return mBase.getPackageCodePath(); 160 } 161 162 @Override 163 public SharedPreferences getSharedPreferences(String name, int mode) { 164 return mBase.getSharedPreferences(name, mode); 165 } 166 167 @Override 168 public SharedPreferences getSharedPreferences(File file, int mode) { 169 return mBase.getSharedPreferences(file, mode); 170 } 171 172 @Override 173 public boolean migrateSharedPreferencesFrom(Context sourceContext, String name) { 174 return mBase.migrateSharedPreferencesFrom(sourceContext, name); 175 } 176 177 @Override 178 public boolean deleteSharedPreferences(String name) { 179 return mBase.deleteSharedPreferences(name); 180 } 181 182 @Override 183 public FileInputStream openFileInput(String name) 184 throws FileNotFoundException { 185 return mBase.openFileInput(name); 186 } 187 188 @Override 189 public FileOutputStream openFileOutput(String name, int mode) 190 throws FileNotFoundException { 191 return mBase.openFileOutput(name, mode); 192 } 193 194 @Override 195 public boolean deleteFile(String name) { 196 return mBase.deleteFile(name); 197 } 198 199 @Override 200 public File getFileStreamPath(String name) { 201 return mBase.getFileStreamPath(name); 202 } 203 204 @Override 205 public File getSharedPreferencesPath(String name) { 206 return mBase.getSharedPreferencesPath(name); 207 } 208 209 @Override 210 public String[] fileList() { 211 return mBase.fileList(); 212 } 213 214 @Override 215 public File getFilesDir() { 216 return mBase.getFilesDir(); 217 } 218 219 @Override 220 public File getNoBackupFilesDir() { 221 return mBase.getNoBackupFilesDir(); 222 } 223 224 @Override 225 public File getExternalFilesDir(String type) { 226 return mBase.getExternalFilesDir(type); 227 } 228 229 @Override 230 public File[] getExternalFilesDirs(String type) { 231 return mBase.getExternalFilesDirs(type); 232 } 233 234 @Override 235 public File getObbDir() { 236 return mBase.getObbDir(); 237 } 238 239 @Override 240 public File[] getObbDirs() { 241 return mBase.getObbDirs(); 242 } 243 244 @Override 245 public File getCacheDir() { 246 return mBase.getCacheDir(); 247 } 248 249 @Override 250 public File getCodeCacheDir() { 251 return mBase.getCodeCacheDir(); 252 } 253 254 @Override 255 public File getExternalCacheDir() { 256 return mBase.getExternalCacheDir(); 257 } 258 259 @Override 260 public File[] getExternalCacheDirs() { 261 return mBase.getExternalCacheDirs(); 262 } 263 264 @Override 265 public File[] getExternalMediaDirs() { 266 return mBase.getExternalMediaDirs(); 267 } 268 269 @Override 270 public File getDir(String name, int mode) { 271 return mBase.getDir(name, mode); 272 } 273 274 @Override 275 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) { 276 return mBase.openOrCreateDatabase(name, mode, factory); 277 } 278 279 @Override 280 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory, 281 DatabaseErrorHandler errorHandler) { 282 return mBase.openOrCreateDatabase(name, mode, factory, errorHandler); 283 } 284 285 @Override 286 public boolean migrateDatabaseFrom(Context sourceContext, String name) { 287 return mBase.migrateDatabaseFrom(sourceContext, name); 288 } 289 290 @Override 291 public boolean deleteDatabase(String name) { 292 return mBase.deleteDatabase(name); 293 } 294 295 @Override 296 public File getDatabasePath(String name) { 297 return mBase.getDatabasePath(name); 298 } 299 300 @Override 301 public String[] databaseList() { 302 return mBase.databaseList(); 303 } 304 305 @Override 306 @Deprecated 307 public Drawable getWallpaper() { 308 return mBase.getWallpaper(); 309 } 310 311 @Override 312 @Deprecated 313 public Drawable peekWallpaper() { 314 return mBase.peekWallpaper(); 315 } 316 317 @Override 318 @Deprecated 319 public int getWallpaperDesiredMinimumWidth() { 320 return mBase.getWallpaperDesiredMinimumWidth(); 321 } 322 323 @Override 324 @Deprecated 325 public int getWallpaperDesiredMinimumHeight() { 326 return mBase.getWallpaperDesiredMinimumHeight(); 327 } 328 329 @Override 330 @Deprecated 331 public void setWallpaper(Bitmap bitmap) throws IOException { 332 mBase.setWallpaper(bitmap); 333 } 334 335 @Override 336 @Deprecated 337 public void setWallpaper(InputStream data) throws IOException { 338 mBase.setWallpaper(data); 339 } 340 341 @Override 342 @Deprecated 343 public void clearWallpaper() throws IOException { 344 mBase.clearWallpaper(); 345 } 346 347 @Override 348 public void startActivity(Intent intent) { 349 mBase.startActivity(intent); 350 } 351 352 /** @hide */ 353 @Override 354 public void startActivityAsUser(Intent intent, UserHandle user) { 355 mBase.startActivityAsUser(intent, user); 356 } 357 358 /** @hide **/ 359 public void startActivityForResult( 360 String who, Intent intent, int requestCode, Bundle options) { 361 mBase.startActivityForResult(who, intent, requestCode, options); 362 } 363 364 /** @hide **/ 365 public boolean canStartActivityForResult() { 366 return mBase.canStartActivityForResult(); 367 } 368 369 @Override 370 public void startActivity(Intent intent, Bundle options) { 371 mBase.startActivity(intent, options); 372 } 373 374 /** @hide */ 375 @Override 376 public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) { 377 mBase.startActivityAsUser(intent, options, user); 378 } 379 380 @Override 381 public void startActivities(Intent[] intents) { 382 mBase.startActivities(intents); 383 } 384 385 @Override 386 public void startActivities(Intent[] intents, Bundle options) { 387 mBase.startActivities(intents, options); 388 } 389 390 /** @hide */ 391 @Override 392 public void startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle) { 393 mBase.startActivitiesAsUser(intents, options, userHandle); 394 } 395 396 @Override 397 public void startIntentSender(IntentSender intent, 398 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) 399 throws IntentSender.SendIntentException { 400 mBase.startIntentSender(intent, fillInIntent, flagsMask, 401 flagsValues, extraFlags); 402 } 403 404 @Override 405 public void startIntentSender(IntentSender intent, 406 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, 407 Bundle options) throws IntentSender.SendIntentException { 408 mBase.startIntentSender(intent, fillInIntent, flagsMask, 409 flagsValues, extraFlags, options); 410 } 411 412 @Override 413 public void sendBroadcast(Intent intent) { 414 mBase.sendBroadcast(intent); 415 } 416 417 @Override 418 public void sendBroadcast(Intent intent, String receiverPermission) { 419 mBase.sendBroadcast(intent, receiverPermission); 420 } 421 422 /** @hide */ 423 @Override 424 public void sendBroadcastMultiplePermissions(Intent intent, String[] receiverPermissions) { 425 mBase.sendBroadcastMultiplePermissions(intent, receiverPermissions); 426 } 427 428 /** @hide */ 429 @SystemApi 430 @Override 431 public void sendBroadcast(Intent intent, String receiverPermission, Bundle options) { 432 mBase.sendBroadcast(intent, receiverPermission, options); 433 } 434 435 /** @hide */ 436 @Override 437 public void sendBroadcast(Intent intent, String receiverPermission, int appOp) { 438 mBase.sendBroadcast(intent, receiverPermission, appOp); 439 } 440 441 @Override 442 public void sendOrderedBroadcast(Intent intent, 443 String receiverPermission) { 444 mBase.sendOrderedBroadcast(intent, receiverPermission); 445 } 446 447 @Override 448 public void sendOrderedBroadcast( 449 Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, 450 Handler scheduler, int initialCode, String initialData, 451 Bundle initialExtras) { 452 mBase.sendOrderedBroadcast(intent, receiverPermission, 453 resultReceiver, scheduler, initialCode, 454 initialData, initialExtras); 455 } 456 457 /** @hide */ 458 @SystemApi 459 @Override 460 public void sendOrderedBroadcast( 461 Intent intent, String receiverPermission, Bundle options, BroadcastReceiver resultReceiver, 462 Handler scheduler, int initialCode, String initialData, 463 Bundle initialExtras) { 464 mBase.sendOrderedBroadcast(intent, receiverPermission, 465 options, resultReceiver, scheduler, initialCode, 466 initialData, initialExtras); 467 } 468 469 /** @hide */ 470 @Override 471 public void sendOrderedBroadcast( 472 Intent intent, String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 473 Handler scheduler, int initialCode, String initialData, 474 Bundle initialExtras) { 475 mBase.sendOrderedBroadcast(intent, receiverPermission, appOp, 476 resultReceiver, scheduler, initialCode, 477 initialData, initialExtras); 478 } 479 480 @Override 481 public void sendBroadcastAsUser(Intent intent, UserHandle user) { 482 mBase.sendBroadcastAsUser(intent, user); 483 } 484 485 @Override 486 public void sendBroadcastAsUser(Intent intent, UserHandle user, 487 String receiverPermission) { 488 mBase.sendBroadcastAsUser(intent, user, receiverPermission); 489 } 490 491 /** @hide */ 492 @Override 493 public void sendBroadcastAsUser(Intent intent, UserHandle user, 494 String receiverPermission, int appOp) { 495 mBase.sendBroadcastAsUser(intent, user, receiverPermission, appOp); 496 } 497 498 @Override 499 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 500 String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, 501 int initialCode, String initialData, Bundle initialExtras) { 502 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, resultReceiver, 503 scheduler, initialCode, initialData, initialExtras); 504 } 505 506 /** @hide */ 507 @Override 508 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 509 String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 510 Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { 511 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, resultReceiver, 512 scheduler, initialCode, initialData, initialExtras); 513 } 514 515 /** @hide */ 516 @Override 517 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 518 String receiverPermission, int appOp, Bundle options, BroadcastReceiver resultReceiver, 519 Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { 520 mBase.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, options, 521 resultReceiver, scheduler, initialCode, initialData, initialExtras); 522 } 523 524 @Override 525 @Deprecated 526 public void sendStickyBroadcast(Intent intent) { 527 mBase.sendStickyBroadcast(intent); 528 } 529 530 @Override 531 @Deprecated 532 public void sendStickyOrderedBroadcast( 533 Intent intent, BroadcastReceiver resultReceiver, 534 Handler scheduler, int initialCode, String initialData, 535 Bundle initialExtras) { 536 mBase.sendStickyOrderedBroadcast(intent, 537 resultReceiver, scheduler, initialCode, 538 initialData, initialExtras); 539 } 540 541 @Override 542 @Deprecated 543 public void removeStickyBroadcast(Intent intent) { 544 mBase.removeStickyBroadcast(intent); 545 } 546 547 @Override 548 @Deprecated 549 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { 550 mBase.sendStickyBroadcastAsUser(intent, user); 551 } 552 553 /** @hide */ 554 @Override 555 @Deprecated 556 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user, Bundle options) { 557 mBase.sendStickyBroadcastAsUser(intent, user, options); 558 } 559 560 @Override 561 @Deprecated 562 public void sendStickyOrderedBroadcastAsUser(Intent intent, 563 UserHandle user, BroadcastReceiver resultReceiver, 564 Handler scheduler, int initialCode, String initialData, 565 Bundle initialExtras) { 566 mBase.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver, 567 scheduler, initialCode, initialData, initialExtras); 568 } 569 570 @Override 571 @Deprecated 572 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 573 mBase.removeStickyBroadcastAsUser(intent, user); 574 } 575 576 @Override 577 public Intent registerReceiver( 578 BroadcastReceiver receiver, IntentFilter filter) { 579 return mBase.registerReceiver(receiver, filter); 580 } 581 582 @Override 583 public Intent registerReceiver( 584 BroadcastReceiver receiver, IntentFilter filter, 585 String broadcastPermission, Handler scheduler) { 586 return mBase.registerReceiver(receiver, filter, broadcastPermission, 587 scheduler); 588 } 589 590 /** @hide */ 591 @Override 592 public Intent registerReceiverAsUser( 593 BroadcastReceiver receiver, UserHandle user, IntentFilter filter, 594 String broadcastPermission, Handler scheduler) { 595 return mBase.registerReceiverAsUser(receiver, user, filter, broadcastPermission, 596 scheduler); 597 } 598 599 @Override 600 public void unregisterReceiver(BroadcastReceiver receiver) { 601 mBase.unregisterReceiver(receiver); 602 } 603 604 @Override 605 public ComponentName startService(Intent service) { 606 return mBase.startService(service); 607 } 608 609 @Override 610 public boolean stopService(Intent name) { 611 return mBase.stopService(name); 612 } 613 614 /** @hide */ 615 @Override 616 public ComponentName startServiceAsUser(Intent service, UserHandle user) { 617 return mBase.startServiceAsUser(service, user); 618 } 619 620 /** @hide */ 621 @Override 622 public boolean stopServiceAsUser(Intent name, UserHandle user) { 623 return mBase.stopServiceAsUser(name, user); 624 } 625 626 @Override 627 public boolean bindService(Intent service, ServiceConnection conn, 628 int flags) { 629 return mBase.bindService(service, conn, flags); 630 } 631 632 /** @hide */ 633 @Override 634 public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags, 635 UserHandle user) { 636 return mBase.bindServiceAsUser(service, conn, flags, user); 637 } 638 639 @Override 640 public void unbindService(ServiceConnection conn) { 641 mBase.unbindService(conn); 642 } 643 644 @Override 645 public boolean startInstrumentation(ComponentName className, 646 String profileFile, Bundle arguments) { 647 return mBase.startInstrumentation(className, profileFile, arguments); 648 } 649 650 @Override 651 public Object getSystemService(String name) { 652 return mBase.getSystemService(name); 653 } 654 655 @Override 656 public String getSystemServiceName(Class<?> serviceClass) { 657 return mBase.getSystemServiceName(serviceClass); 658 } 659 660 @Override 661 public int checkPermission(String permission, int pid, int uid) { 662 return mBase.checkPermission(permission, pid, uid); 663 } 664 665 /** @hide */ 666 @Override 667 public int checkPermission(String permission, int pid, int uid, IBinder callerToken) { 668 return mBase.checkPermission(permission, pid, uid, callerToken); 669 } 670 671 @Override 672 public int checkCallingPermission(String permission) { 673 return mBase.checkCallingPermission(permission); 674 } 675 676 @Override 677 public int checkCallingOrSelfPermission(String permission) { 678 return mBase.checkCallingOrSelfPermission(permission); 679 } 680 681 @Override 682 public int checkSelfPermission(String permission) { 683 return mBase.checkSelfPermission(permission); 684 } 685 686 @Override 687 public void enforcePermission( 688 String permission, int pid, int uid, String message) { 689 mBase.enforcePermission(permission, pid, uid, message); 690 } 691 692 @Override 693 public void enforceCallingPermission(String permission, String message) { 694 mBase.enforceCallingPermission(permission, message); 695 } 696 697 @Override 698 public void enforceCallingOrSelfPermission( 699 String permission, String message) { 700 mBase.enforceCallingOrSelfPermission(permission, message); 701 } 702 703 @Override 704 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 705 mBase.grantUriPermission(toPackage, uri, modeFlags); 706 } 707 708 @Override 709 public void revokeUriPermission(Uri uri, int modeFlags) { 710 mBase.revokeUriPermission(uri, modeFlags); 711 } 712 713 @Override 714 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 715 return mBase.checkUriPermission(uri, pid, uid, modeFlags); 716 } 717 718 /** @hide */ 719 @Override 720 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) { 721 return mBase.checkUriPermission(uri, pid, uid, modeFlags, callerToken); 722 } 723 724 @Override 725 public int checkCallingUriPermission(Uri uri, int modeFlags) { 726 return mBase.checkCallingUriPermission(uri, modeFlags); 727 } 728 729 @Override 730 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 731 return mBase.checkCallingOrSelfUriPermission(uri, modeFlags); 732 } 733 734 @Override 735 public int checkUriPermission(Uri uri, String readPermission, 736 String writePermission, int pid, int uid, int modeFlags) { 737 return mBase.checkUriPermission(uri, readPermission, writePermission, 738 pid, uid, modeFlags); 739 } 740 741 @Override 742 public void enforceUriPermission( 743 Uri uri, int pid, int uid, int modeFlags, String message) { 744 mBase.enforceUriPermission(uri, pid, uid, modeFlags, message); 745 } 746 747 @Override 748 public void enforceCallingUriPermission( 749 Uri uri, int modeFlags, String message) { 750 mBase.enforceCallingUriPermission(uri, modeFlags, message); 751 } 752 753 @Override 754 public void enforceCallingOrSelfUriPermission( 755 Uri uri, int modeFlags, String message) { 756 mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message); 757 } 758 759 @Override 760 public void enforceUriPermission( 761 Uri uri, String readPermission, String writePermission, 762 int pid, int uid, int modeFlags, String message) { 763 mBase.enforceUriPermission( 764 uri, readPermission, writePermission, pid, uid, modeFlags, 765 message); 766 } 767 768 @Override 769 public Context createPackageContext(String packageName, int flags) 770 throws PackageManager.NameNotFoundException { 771 return mBase.createPackageContext(packageName, flags); 772 } 773 774 /** @hide */ 775 @Override 776 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 777 throws PackageManager.NameNotFoundException { 778 return mBase.createPackageContextAsUser(packageName, flags, user); 779 } 780 781 /** @hide */ 782 @Override 783 public Context createApplicationContext(ApplicationInfo application, 784 int flags) throws PackageManager.NameNotFoundException { 785 return mBase.createApplicationContext(application, flags); 786 } 787 788 /** @hide */ 789 @Override 790 public int getUserId() { 791 return mBase.getUserId(); 792 } 793 794 @Override 795 public Context createConfigurationContext(Configuration overrideConfiguration) { 796 return mBase.createConfigurationContext(overrideConfiguration); 797 } 798 799 @Override 800 public Context createDisplayContext(Display display) { 801 return mBase.createDisplayContext(display); 802 } 803 804 @Override 805 public boolean isRestricted() { 806 return mBase.isRestricted(); 807 } 808 809 /** @hide */ 810 @Override 811 public DisplayAdjustments getDisplayAdjustments(int displayId) { 812 return mBase.getDisplayAdjustments(displayId); 813 } 814 815 @Override 816 public Context createDeviceEncryptedStorageContext() { 817 return mBase.createDeviceEncryptedStorageContext(); 818 } 819 820 /** {@hide} */ 821 @SystemApi 822 @Override 823 public Context createCredentialEncryptedStorageContext() { 824 return mBase.createCredentialEncryptedStorageContext(); 825 } 826 827 @Override 828 public boolean isDeviceEncryptedStorage() { 829 return mBase.isDeviceEncryptedStorage(); 830 } 831 832 /** {@hide} */ 833 @SystemApi 834 @Override 835 public boolean isCredentialEncryptedStorage() { 836 return mBase.isCredentialEncryptedStorage(); 837 } 838} 839