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