MockContext

Kotlin |Java

open class MockContext : Context

kotlin.Any
↳	android.content.Context
	↳	android.test.mock.MockContext

A mock android.content.Context class. All methods are non-functional and throw java.lang.UnsupportedOperationException. You can use this to inject other dependencies, mocks, or monitors into the classes you are testing.

Summary

Inherited constants

From class Context

`String`	`ACCESSIBILITY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.accessibility.AccessibilityManager` for giving the user feedback for UI events through the registered event listeners.
`String`	`ACCOUNT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.accounts.AccountManager` for receiving intents at a time of your choosing.
`String`	`ACTIVITY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.ActivityManager` for interacting with the global system state.
`String`	`ADVANCED_PROTECTION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve an `android.security.advancedprotection.AdvancedProtectionManager`
`String`	`ALARM_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.AlarmManager` for receiving intents at a time of your choosing.
`String`	`APPWIDGET_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.appwidget.AppWidgetManager` for accessing AppWidgets.
`String`	`APP_FUNCTION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve an `AppFunctionManager` for executing app functions.
`String`	`APP_OPS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.AppOpsManager` for tracking application operations on the device.
`String`	`APP_SEARCH_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve an `android.app.appsearch.AppSearchManager` for indexing and querying app data managed by the system.
`String`	`AUDIO_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.AudioManager` for handling management of volume, ringer modes and audio routing.
`String`	`BATTERY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.BatteryManager` for managing battery state.
`Int`	`BIND_ABOVE_CLIENT` Flag for #bindService: indicates that the client application binding to this service considers the service to be more important than the app itself. When set, the platform will try to have the out of memory killer kill the app before it kills the service it is bound to, though this is not guaranteed to be the case.
`Int`	`BIND_ADJUST_WITH_ACTIVITY` Flag for #bindService: If binding from an activity, allow the target service's process importance to be raised based on whether the activity is visible to the user, regardless whether another flag is used to reduce the amount that the client process's overall importance is used to impact it.
`Int`	`BIND_ALLOW_ACTIVITY_STARTS` Flag for #bindService: If binding from an app that is visible, the bound service is allowed to start an activity from background. This was the default behavior before SDK version `android.os.Build.VERSION_CODES#UPSIDE_DOWN_CAKE`. Since then, the default behavior changed to disallow the bound service to start a background activity even if the app bound to it is in foreground, unless this flag is specified when binding.
`Int`	`BIND_ALLOW_OOM_MANAGEMENT` Flag for #bindService: allow the process hosting the bound service to go through its normal memory management. It will be treated more like a running service, allowing the system to (temporarily) expunge the process if low on memory or for some other whim it may have, and being more aggressive about making it a candidate to be killed (and restarted) if running for a long time.
`Int`	`BIND_AUTO_CREATE` Flag for #bindService: automatically create the service as long as the binding exists. Note that while this will create the service, its `android.app.Service#onStartCommand` method will still only be called due to an explicit call to `startService`. Even without that, though, this still provides you with access to the service object while the service is created. Note that prior to `android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH`, not supplying this flag would also impact how important the system consider's the target service's process to be. When set, the only way for it to be raised was by binding from a service in which case it will only be important when that activity is in the foreground. Now to achieve this behavior you must explicitly supply the new flag `BIND_ADJUST_WITH_ACTIVITY`. For compatibility, old applications that don't specify `BIND_AUTO_CREATE` will automatically have the flags `BIND_WAIVE_PRIORITY` and `BIND_ADJUST_WITH_ACTIVITY` set for them in order to achieve the same result.
`Int`	`BIND_DEBUG_UNBIND` Flag for #bindService: include debugging help for mismatched calls to unbind. When this flag is set, the callstack of the following `unbindService` call is retained, to be printed if a later incorrect unbind call is made. Note that doing this requires retaining information about the binding that was made for the lifetime of the app, resulting in a leak -- this should only be used for debugging.
`Int`	`BIND_EXTERNAL_SERVICE` Flag for #bindService: The service being bound is an `isolated`, `external` service. This binds the service into the calling application's package, rather than the package in which the service is declared. When using this flag, the code for the service being bound will execute under the calling application's package name and user ID. Because the service must be an isolated process, it will not have direct access to the application's data, though. The purpose of this flag is to allow applications to provide services that are attributed to the app using the service, rather than the application providing the service. This flag is NOT compatible with `BindServiceFlags`. If you need to use `BindServiceFlags`, you must use `BIND_EXTERNAL_SERVICE_LONG` instead.
`Long`	`BIND_EXTERNAL_SERVICE_LONG` Works in the same way as `BIND_EXTERNAL_SERVICE`, but it's defined as a `long` value that is compatible to `BindServiceFlags`.
`Int`	`BIND_IMPORTANT` Flag for #bindService: this service is very important to the client, so should be brought to the foreground process level when the client is. Normally a process can only be raised to the visibility level by a client, even if that client is in the foreground.
`Int`	`BIND_INCLUDE_CAPABILITIES` Flag for #bindService: If binding from an app that has specific capabilities due to its foreground state such as an activity or foreground service, then this flag will allow the bound app to get the same capabilities, as long as it has the required permissions as well. If binding from a top app and its target SDK version is at or above `android.os.Build.VERSION_CODES#R`, the app needs to explicitly use BIND_INCLUDE_CAPABILITIES flag to pass all capabilities to the service so the other app can have while-in-use access such as location, camera, microphone from background. If binding from a top app and its target SDK version is below `android.os.Build.VERSION_CODES#R`, BIND_INCLUDE_CAPABILITIES is implicit.
`Int`	`BIND_NOT_FOREGROUND` Flag for #bindService: don't allow this binding to raise the target service's process to the foreground scheduling priority. It will still be raised to at least the same memory priority as the client (so that its process will not be killable in any situation where the client is not killable), but for CPU scheduling purposes it may be left in the background. This only has an impact in the situation where the binding client is a foreground process and the target service is in a background process.
`Int`	`BIND_NOT_PERCEPTIBLE` Flag for #bindService: If binding from an app that is visible or user-perceptible, lower the target service's importance to below the perceptible level. This allows the system to (temporarily) expunge the bound process from memory to make room for more important user-perceptible processes.
`Int`	`BIND_PACKAGE_ISOLATED_PROCESS` Flag for #bindIsolatedService: Bind the service into a shared isolated process, but only with other isolated services from the same package that declare the same process name. Specifying this flag allows multiple isolated services defined in the same package to be running in a single shared isolated process. This shared isolated process must be specified since this flag will not work with the default application process. This flag is different from `BIND_SHARED_ISOLATED_PROCESS` since it only allows binding services from the same package in the same shared isolated process. This also means the shared package isolated process is global, and not scoped to each potential calling app. The shared isolated process instance is identified by the "android:process" attribute defined by the service. This flag cannot be used without this attribute set.
`Int`	`BIND_SHARED_ISOLATED_PROCESS` Flag for #bindIsolatedService: Bind the service into a shared isolated process. Specifying this flag allows multiple isolated services to be running in a single shared isolated process. The shared isolated process instance is identified by the instanceName parameter in `bindIsolatedService(android.content.Intent,int,java.lang.String,java.util.concurrent.Executor,android.content.ServiceConnection)`. Subsequent calls to #bindIsolatedService with the same instanceName will cause the isolated service to be co-located in the same shared isolated process. Note that the shared isolated process is scoped to the calling app; once created, only the calling app can bind additional isolated services into the shared process. However, the services themselves can come from different APKs and therefore different vendors. Only services that set the `android.R.attr#allowSharedIsolatedProcess` attribute to `true` are allowed to be bound into a shared isolated process.
`Int`	`BIND_WAIVE_PRIORITY` Flag for #bindService: don't impact the scheduling or memory management priority of the target service's hosting process. Allows the service's process to be managed on the background LRU list just like a regular application process in the background.
`String`	`BIOMETRIC_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.biometrics.BiometricManager` for handling biometric and PIN/pattern/password authentication.
`String`	`BLOB_STORE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.blob.BlobStoreManager` for contributing and accessing data blobs from the blob store maintained by the system.
`String`	`BLUETOOTH_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.bluetooth.BluetoothManager` for using Bluetooth.
`String`	`BUGREPORT_SERVICE` Service to capture a bugreport.
`String`	`CAMERA_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.camera2.CameraManager` for interacting with camera devices.
`String`	`CAPTIONING_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.accessibility.CaptioningManager` for obtaining captioning properties and listening for changes in captioning preferences.
`String`	`CARRIER_CONFIG_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.CarrierConfigManager` for reading carrier configuration values.
`String`	`CHOOSER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.service.chooser.ChooserManager`. Note: This service is not available on Wear OS, Android TV, or Android Auto devices. On these form factors, calls to `getSystemService` for this service will return `null`.
`String`	`CLIPBOARD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.ClipboardManager` for accessing and modifying the contents of the global clipboard.
`String`	`COMPANION_DEVICE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.companion.CompanionDeviceManager` for managing companion devices
`String`	`CONNECTIVITY_DIAGNOSTICS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.ConnectivityDiagnosticsManager` for performing network connectivity diagnostics as well as receiving network connectivity information from the system.
`String`	`CONNECTIVITY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.ConnectivityManager` for handling management of network connections.
`String`	`CONSUMER_IR_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.ConsumerIrManager` for transmitting infrared signals from the device.
`String`	`CONTACT_KEYS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `E2eeContactKeysManager` to managing contact keys.
`Int`	`CONTEXT_IGNORE_SECURITY` Flag for use with `createPackageContext`: ignore any security restrictions on the Context being requested, allowing it to always be loaded. For use with `CONTEXT_INCLUDE_CODE` to allow code to be loaded into a process even when it isn't safe to do so. Use with extreme care!
`Int`	`CONTEXT_INCLUDE_CODE` Flag for use with `createPackageContext`: include the application code with the context. This means loading code into the caller's process, so that `getClassLoader()` can be used to instantiate the application's classes. Setting this flags imposes security restrictions on what application context you can access; if the requested application can not be safely loaded into your process, java.lang.SecurityException will be thrown. If this flag is not set, there will be no restrictions on the packages that can be loaded, but `getClassLoader` will always return the default system class loader.
`Int`	`CONTEXT_RESTRICTED` Flag for use with `createPackageContext`: a restricted context may disable specific features. For instance, a View associated with a restricted context would ignore particular XML attributes.
`String`	`CREDENTIAL_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.credentials.CredentialManager` to authenticate a user to your app.
`String`	`CROSS_PROFILE_APPS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.pm.CrossProfileApps` for cross profile operations.
`Int`	`DEVICE_ID_DEFAULT` The default device ID, which is the ID of the primary (non-virtual) device.
`Int`	`DEVICE_ID_INVALID` Invalid device ID.
`String`	`DEVICE_LOCK_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.devicelock.DeviceLockManager`.
`String`	`DEVICE_POLICY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.admin.DevicePolicyManager` for working with global device policy management.
`String`	`DISPLAY_HASH_SERVICE` Use with `getSystemService(java.lang.String)` to access `android.view.displayhash.DisplayHashManager` to handle display hashes.
`String`	`DISPLAY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.display.DisplayManager` for interacting with display devices.
`String`	`DOMAIN_VERIFICATION_SERVICE` Use with `getSystemService(java.lang.String)` to access `android.content.pm.verify.domain.DomainVerificationManager` to retrieve approval and user state for declared web domains.
`String`	`DOWNLOAD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.DownloadManager` for requesting HTTP downloads.
`String`	`DROPBOX_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.DropBoxManager` instance for recording diagnostic logs.
`String`	`EUICC_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.euicc.EuiccManager` to manage the device eUICC (embedded SIM).
`String`	`FILE_INTEGRITY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve an `android.security.FileIntegrityManager`.
`String`	`GAME_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `GameManager`.
`String`	`GRAMMATICAL_INFLECTION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `GrammaticalInflectionManager`.
`String`	`HARDWARE_PROPERTIES_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.HardwarePropertiesManager` for accessing the hardware properties service.
`String`	`HEALTHCONNECT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.health.connect.HealthConnectManager`.
`String`	`INPUT_METHOD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.inputmethod.InputMethodManager` for accessing input methods.
`String`	`INPUT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.input.InputManager` for interacting with input devices.
`String`	`IPSEC_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.IpSecManager` for encrypting Sockets or Networks with IPSec.
`String`	`JOB_SCHEDULER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.job.JobScheduler` instance for managing occasional background tasks.
`String`	`KEYGUARD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.KeyguardManager` for controlling keyguard.
`String`	`KEYSTORE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.security.keystore.KeyStoreManager` for accessing Android Keystore functions.
`String`	`LAUNCHER_APPS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.pm.LauncherApps` for querying and monitoring launchable apps across profiles of a user.
`String`	`LAYOUT_INFLATER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.LayoutInflater` for inflating layout resources in this context.
`String`	`LOCALE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.LocaleManager`.
`String`	`LOCATION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.location.LocationManager` for controlling location updates.
`String`	`MEDIA_COMMUNICATION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.MediaCommunicationManager` for managing `android.media.MediaSession2`.
`String`	`MEDIA_METRICS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.metrics.MediaMetricsManager` for interacting with media metrics on the device.
`String`	`MEDIA_PROJECTION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.projection.MediaProjectionManager` instance for managing media projection sessions.
`String`	`MEDIA_QUALITY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.quality.MediaQualityManager` for standardize picture and audio API parameters.
`String`	`MEDIA_ROUTER_SERVICE` Use with #getSystemService to retrieve a `android.media.MediaRouter` for controlling and managing routing of media.
`String`	`MEDIA_SESSION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.session.MediaSessionManager` for managing media Sessions.
`String`	`MIDI_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.midi.MidiManager` for accessing the MIDI service.
`Int`	`MODE_APPEND` File creation mode: for use with `openFileOutput`, if the file already exists then write data to the end of the existing file instead of erasing it.
`Int`	`MODE_ENABLE_WRITE_AHEAD_LOGGING` Database open flag: when set, the database is opened with write-ahead logging enabled by default.
`Int`	`MODE_MULTI_PROCESS` SharedPreference loading flag: when set, the file on disk will be checked for modification even if the shared preferences instance is already loaded in this process. This behavior is sometimes desired in cases where the application has multiple processes, all writing to the same SharedPreferences file. Generally there are better forms of communication between processes, though. This was the legacy (but undocumented) behavior in and before Gingerbread (Android 2.3) and this flag is implied when targeting such releases. For applications targeting SDK versions greater than Android 2.3, this flag must be explicitly set if desired.
`Int`	`MODE_NO_LOCALIZED_COLLATORS` Database open flag: when set, the database is opened without support for localized collators.
`Int`	`MODE_PRIVATE` File creation mode: the default mode, where the created file can only be accessed by the calling application (or all applications sharing the same user ID).
`Int`	`MODE_WORLD_READABLE` File creation mode: allow all other applications to have read access to the created file. Starting from `android.os.Build.VERSION_CODES#N`, attempting to use this mode throws a `SecurityException`.
`Int`	`MODE_WORLD_WRITEABLE` File creation mode: allow all other applications to have write access to the created file. Starting from `android.os.Build.VERSION_CODES#N`, attempting to use this mode will throw a `SecurityException`.
`String`	`NETWORK_STATS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.usage.NetworkStatsManager` for querying network usage stats.
`String`	`NFC_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.nfc.NfcManager` for using NFC.
`String`	`NOTIFICATION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.NotificationManager` for informing the user of background events.
`String`	`NSD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.nsd.NsdManager` for handling management of network service discovery
`String`	`OVERLAY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.om.OverlayManager` for managing overlay packages.
`String`	`PEOPLE_SERVICE` Use with `getSystemService(java.lang.String)` to access a `PeopleManager` to interact with your published conversations.
`String`	`PERFORMANCE_HINT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.PerformanceHintManager` for accessing the performance hinting service.
`String`	`PERSISTENT_DATA_BLOCK_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.service.persistentdata.PersistentDataBlockManager` instance for interacting with a storage device that lives across factory resets.
`String`	`POWER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.PowerManager` for controlling power management, including "wake locks," which let you keep the device on while you're running long tasks.
`String`	`PRINT_SERVICE` `android.print.PrintManager` for printing and managing printers and print tasks.
`String`	`PROFILING_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve an `android.os.ProfilingManager`.
`Int`	`RECEIVER_EXPORTED` Flag for #registerReceiver: The receiver can receive broadcasts from other Apps. Has the same behavior as marking a statically registered receiver with "exported=true"
`Int`	`RECEIVER_NOT_EXPORTED` Flag for #registerReceiver: The receiver cannot receive broadcasts from other Apps. Has the same behavior as marking a statically registered receiver with "exported=false"
`Int`	`RECEIVER_VISIBLE_TO_INSTANT_APPS` Flag for #registerReceiver: The receiver can receive broadcasts from Instant Apps.
`String`	`RESTRICTIONS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.RestrictionsManager` for retrieving application restrictions and requesting permissions for restricted operations.
`String`	`ROLE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.role.RoleManager` for managing roles.
`String`	`SATELLITE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.satellite.SatelliteManager` for accessing satellite functionality.
`String`	`SEARCH_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.SearchManager` for handling searches. `Configuration.UI_MODE_TYPE_WATCH` does not support `android.app.SearchManager`.
`String`	`SECURITY_STATE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.SecurityStateManager` for accessing the security state manager service.
`String`	`SENSOR_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.SensorManager` for accessing sensors.
`String`	`SHORTCUT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.pm.ShortcutManager` for accessing the launcher shortcut service.
`String`	`STATUS_BAR_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.StatusBarManager` for interacting with the status bar and quick settings.
`String`	`STORAGE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.storage.StorageManager` for accessing system storage functions.
`String`	`STORAGE_STATS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.usage.StorageStatsManager` for accessing system storage statistics.
`String`	`SYSTEM_HEALTH_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.health.SystemHealthManager` for accessing system health (battery, power, memory, etc) metrics.
`String`	`TELECOM_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telecom.TelecomManager` to manage telecom-related features of the device.
`String`	`TELEPHONY_IMS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve an `android.telephony.ims.ImsManager`.
`String`	`TELEPHONY_PHONE_NUMBER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.PhoneNumberManager` for parsing phone numbers.
`String`	`TELEPHONY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.TelephonyManager` for handling management the telephony features of the device.
`String`	`TELEPHONY_SUBSCRIPTION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.SubscriptionManager` for handling management the telephony subscriptions of the device.
`String`	`TETHERING_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.TetheringManager` for managing tethering functions.
`String`	`TEXT_CLASSIFICATION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `TextClassificationManager` for text classification services.
`String`	`TEXT_SERVICES_MANAGER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.textservice.TextServicesManager` for accessing text services.
`String`	`TV_AD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.tv.ad.TvAdManager` for interacting with TV client-side advertisement services on the device.
`String`	`TV_INPUT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.tv.TvInputManager` for interacting with TV inputs on the device.
`String`	`TV_INTERACTIVE_APP_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.tv.interactive.TvInteractiveAppManager` for interacting with TV interactive applications on the device.
`String`	`UI_MODE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.UiModeManager` for controlling UI modes.
`String`	`USAGE_STATS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.usage.UsageStatsManager` for querying device usage stats.
`String`	`USB_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.usb.UsbManager` for access to USB devices (as a USB host) and for controlling this device's behavior as a USB device.
`String`	`USER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.UserManager` for managing users on devices that support multiple users.
`String`	`VIBRATOR_MANAGER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.VibratorManager` for accessing the device vibrators, interacting with individual ones and playing synchronized effects on multiple vibrators.
`String`	`VIBRATOR_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.Vibrator` for interacting with the vibration hardware.
`String`	`VIRTUAL_DEVICE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.companion.virtual.VirtualDeviceManager` for managing virtual devices. On devices without `PackageManager.FEATURE_COMPANION_DEVICE_SETUP` system feature the `getSystemService(java.lang.String)` will return `null`.
`String`	`VPN_MANAGEMENT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.VpnManager` to manage profiles for the platform built-in VPN.
`String`	`WALLPAPER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a com.android.server.WallpaperService for accessing wallpapers.
`String`	`WIFI_AWARE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.wifi.aware.WifiAwareManager` for handling management of Wi-Fi Aware.
`String`	`WIFI_P2P_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.wifi.p2p.WifiP2pManager` for handling management of Wi-Fi peer-to-peer connections.
`String`	`WIFI_RTT_RANGING_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.wifi.rtt.WifiRttManager` for ranging devices with wifi.
`String`	`WIFI_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.wifi.WifiManager` for handling management of Wi-Fi access.
`String`	`WINDOW_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.WindowManager` for accessing the system's window manager.

Public constructors
`MockContext()`

Public methods
open Boolean	`bindIsolatedService(service: Intent, flags: Int, instanceName: String, executor: Executor, conn: ServiceConnection)` Variation of #bindService that, in the specific case of isolated services, allows the caller to generate multiple instances of a service from a single component declaration.
open Boolean	`bindService(service: Intent, conn: ServiceConnection, flags: Int)` Connects to an application service, creating it if needed.
open Boolean	`bindService(service: Intent, flags: Int, executor: Executor, conn: ServiceConnection)` Same as `bindService(Intent, ServiceConnection, int)` with executor to control ServiceConnection callbacks.
open Boolean	`bindServiceAsUser(service: Intent, conn: ServiceConnection, flags: Int, user: UserHandle)`
open Int	`checkCallingOrSelfPermission(permission: String)` Determine whether the calling process of an IPC or you have been granted a particular permission.
open Int	`checkCallingOrSelfUriPermission(uri: Uri!, modeFlags: Int)` Determine whether the calling process of an IPC or you has been granted permission to access a specific URI.
open Int	`checkCallingPermission(permission: String)` Determine whether the calling process of an IPC you are handling has been granted a particular permission.
open Int	`checkCallingUriPermission(uri: Uri!, modeFlags: Int)` Determine whether the calling process and uid has been granted permission to access a specific URI.
open Int	`checkPermission(permission: String, pid: Int, uid: Int)` Determine whether the given permission is allowed for a particular process and user ID running in the system.
open Int	`checkSelfPermission(permission: String)` Determine whether you have been granted a particular permission.
open Int	`checkUriPermission(uri: Uri!, pid: Int, uid: Int, modeFlags: Int)` Determine whether a particular process and uid has been granted permission to access a specific URI.
open Int	`checkUriPermission(uri: Uri?, readPermission: String?, writePermission: String?, pid: Int, uid: Int, modeFlags: Int)` Check both a Uri and normal permission.
open Unit	`clearWallpaper()`
open Context!	`createConfigurationContext(overrideConfiguration: Configuration)` Return a new Context object for the current Context but whose resources are adjusted to match the given Configuration.
open Context!	`createContextForSplit(splitName: String!)`
open Context	`createDeviceContext(deviceId: Int)` Returns a new `Context` object from the current context but with device association given by the `deviceId`.
open Context!	`createDeviceProtectedStorageContext()` Return a new Context object for the current Context but whose storage APIs are backed by device-protected storage.
open Context!	`createDisplayContext(display: Display)` Returns a new `Context` object from the current context but with resources adjusted to match the metrics of `display`.
open Context!	`createPackageContext(packageName: String!, flags: Int)` Return a new Context object for the given application name.
open Context	`createWindowContext(display: Display, type: Int, options: Bundle?)` Creates a `Context` for a non-`activity` window on the given `Display`.
open Context	`createWindowContext(type: Int, options: Bundle?)` Creates a Context for a non-activity window.
open Array<String!>!	`databaseList()` Returns an array of strings naming the private databases associated with this Context's application package.
open Boolean	`deleteDatabase(name: String!)` Delete an existing private SQLiteDatabase associated with this Context's application package.
open Boolean	`deleteFile(name: String!)` Delete the given private file associated with this Context's application package.
open Boolean	`deleteSharedPreferences(name: String!)` Delete an existing shared preferences file.
open Unit	`enforceCallingOrSelfPermission(permission: String, message: String?)` If neither you nor the calling process of an IPC you are handling has been granted a particular permission, throw a `SecurityException`.
open Unit	`enforceCallingOrSelfUriPermission(uri: Uri!, modeFlags: Int, message: String!)` If the calling process of an IPC or you has not been granted permission to access a specific URI, throw `SecurityException`.
open Unit	`enforceCallingPermission(permission: String, message: String?)` If the calling process of an IPC you are handling has not been granted a particular permission, throw a `SecurityException`.
open Unit	`enforceCallingUriPermission(uri: Uri!, modeFlags: Int, message: String!)` If the calling process and uid has not been granted permission to access a specific URI, throw `SecurityException`.
open Unit	`enforcePermission(permission: String, pid: Int, uid: Int, message: String?)` If the given permission is not allowed for a particular process and user ID running in the system, throw a `SecurityException`.
open Unit	`enforceUriPermission(uri: Uri!, pid: Int, uid: Int, modeFlags: Int, message: String!)` If a particular process and uid has not been granted permission to access a specific URI, throw `SecurityException`.
open Unit	`enforceUriPermission(uri: Uri?, readPermission: String?, writePermission: String?, pid: Int, uid: Int, modeFlags: Int, message: String?)` Enforce both a Uri and normal permission.
open Array<String!>!	`fileList()` Returns an array of strings naming the private files associated with this Context's application package.
open Context!	`getApplicationContext()` Return the context of the single, global Application object of the current process.
open ApplicationInfo!	`getApplicationInfo()` Return the full application info for this context's package.
open AssetManager!	`getAssets()` Returns an AssetManager instance for the application's package.
open File!	`getCacheDir()` Returns the absolute path to the application specific cache directory on the filesystem.
open ClassLoader!	`getClassLoader()` Return a class loader you can use to retrieve classes in this package.
open File!	`getCodeCacheDir()` Returns the absolute path to the application specific cache directory on the filesystem designed for storing cached code.
open ContentResolver!	`getContentResolver()` Return a ContentResolver instance for your application's package.
open File!	`getDataDir()` Returns the absolute path to the directory on the filesystem where all private files belonging to this app are stored.
open File!	`getDatabasePath(name: String!)` Returns the absolute path on the filesystem where a database created with #openOrCreateDatabase is stored.
open Int	`getDeviceId()` Gets the device ID this context is associated with.
open File!	`getDir(name: String!, mode: Int)` Retrieve, creating if needed, a new directory in which the application can place its own custom data files.
open Display	`getDisplay()` Get the display this context is associated with.
open File?	`getExternalCacheDir()` Returns absolute path to application-specific directory on the primary shared/external storage device where the application can place cache files it owns.
open Array<File!>!	`getExternalCacheDirs()` Returns absolute paths to application-specific directories on all shared/external storage devices where the application can place cache files it owns.
open File?	`getExternalFilesDir(type: String?)` Returns the absolute path to the directory on the primary shared/external storage device where the application can place persistent files it owns.
open Array<File!>!	`getExternalFilesDirs(type: String!)` Returns absolute paths to application-specific directories on all shared/external storage devices where the application can place persistent files it owns.
open Array<File!>!	`getExternalMediaDirs()` Returns absolute paths to application-specific directories on all shared/external storage devices where the application can place media files.
open File!	`getFileStreamPath(name: String!)` Returns the absolute path on the filesystem where a file created with `openFileOutput` is stored.
open File!	`getFilesDir()` Returns the absolute path to the directory on the filesystem where files created with `openFileOutput` are stored.
open Executor!	`getMainExecutor()` Return an `Executor` that will run enqueued tasks on the main thread associated with this context.
open Looper!	`getMainLooper()` Return the Looper for the main thread of the current process.
open File!	`getNoBackupFilesDir()` Returns the absolute path to the directory on the filesystem similar to `getFilesDir()`.
open File!	`getObbDir()` Return the primary shared/external storage directory where this application's OBB files (if there are any) can be found.
open Array<File!>!	`getObbDirs()` Returns absolute paths to application-specific directories on all shared/external storage devices where the application's OBB files (if there are any) can be found.
open String	`getOpPackageName()`
open String!	`getPackageCodePath()` Return the full path to this context's primary Android package.
open PackageManager!	`getPackageManager()` Return PackageManager instance to find global package information.
open String!	`getPackageName()` Return the name of this application's package.
open String!	`getPackageResourcePath()` Return the full path to this context's primary Android package.
open Resources!	`getResources()` Returns a Resources instance for the application's package.
open SharedPreferences!	`getSharedPreferences(name: String!, mode: Int)` Retrieve and hold the contents of the preferences file 'name', returning a SharedPreferences through which you can retrieve and modify its values.
open Any!	`getSystemService(name: String)` Return the handle to a system-level service by name.
open String?	`getSystemServiceName(serviceClass: Class<*>)` Gets the name of the system-level service that is represented by the specified class.
open Resources.Theme!	`getTheme()` Return the Theme object associated with this Context.
open Drawable!	`getWallpaper()`
open Int	`getWallpaperDesiredMinimumHeight()`
open Int	`getWallpaperDesiredMinimumWidth()`
open Unit	`grantUriPermission(toPackage: String!, uri: Uri!, modeFlags: Int)` Grant permission to access a specific Uri to another package, regardless of whether that package has general permission to access the Uri's content provider.
open Boolean	`isDeviceProtectedStorage()` Indicates if the storage APIs of this Context are backed by device-protected storage.
open Boolean	`isRestricted()` Indicates whether this Context is restricted.
open Boolean	`isUiContext()`
open Boolean	`moveDatabaseFrom(sourceContext: Context!, name: String!)` Move an existing database file from the given source storage context to this context.
open Boolean	`moveSharedPreferencesFrom(sourceContext: Context!, name: String!)` Move an existing shared preferences file from the given source storage context to this context.
open FileInputStream!	`openFileInput(name: String!)` Open a private file associated with this Context's application package for reading.
open FileOutputStream!	`openFileOutput(name: String!, mode: Int)` Open a private file associated with this Context's application package for writing.
open SQLiteDatabase!	`openOrCreateDatabase(file: String!, mode: Int, factory: SQLiteDatabase.CursorFactory!)` Open a new private SQLiteDatabase associated with this Context's application package.
open SQLiteDatabase!	`openOrCreateDatabase(file: String!, mode: Int, factory: SQLiteDatabase.CursorFactory!, errorHandler: DatabaseErrorHandler?)` Open a new private SQLiteDatabase associated with this Context's application package.
open Drawable!	`peekWallpaper()`
open Intent?	`registerReceiver(receiver: BroadcastReceiver?, filter: IntentFilter!)` Register a BroadcastReceiver to be run in the main activity thread.
open Intent?	`registerReceiver(receiver: BroadcastReceiver?, filter: IntentFilter!, flags: Int)` Register to receive intent broadcasts, with the receiver optionally being exposed to Instant Apps.
open Intent?	`registerReceiver(receiver: BroadcastReceiver!, filter: IntentFilter!, broadcastPermission: String?, scheduler: Handler?)` Register to receive intent broadcasts, to run in the context of scheduler.
open Intent?	`registerReceiver(receiver: BroadcastReceiver!, filter: IntentFilter!, broadcastPermission: String?, scheduler: Handler?, flags: Int)` Register to receive intent broadcasts, to run in the context of scheduler.
open Unit	`removeStickyBroadcast(intent: Intent!)` Remove the data previously sent with #sendStickyBroadcast, so that it is as if the sticky broadcast had never happened.
open Unit	`removeStickyBroadcastAsUser(intent: Intent!, user: UserHandle!)` Version of `removeStickyBroadcast(android.content.Intent)` that allows you to specify the user the broadcast will be sent to.
open Unit	`revokeUriPermission(uri: Uri!, modeFlags: Int)` Remove all permissions to access a particular content provider Uri that were previously added with `grantUriPermission` or any other mechanism.
open Unit	`revokeUriPermission(targetPackage: String!, uri: Uri!, modeFlags: Int)` Remove permissions to access a particular content provider Uri that were previously added with `grantUriPermission` for a specific target package.
open Unit	`sendBroadcast(intent: Intent!)` Broadcast the given intent to all interested BroadcastReceivers.
open Unit	`sendBroadcast(intent: Intent!, receiverPermission: String?)` Broadcast the given intent to all interested BroadcastReceivers, allowing an optional required permission to be enforced.
open Unit	`sendBroadcast(intent: Intent, receiverPermission: String?, options: Bundle?)`
open Unit	`sendBroadcastAsUser(intent: Intent!, user: UserHandle!)` Version of `sendBroadcast(android.content.Intent)` that allows you to specify the user the broadcast will be sent to.
open Unit	`sendBroadcastAsUser(intent: Intent!, user: UserHandle!, receiverPermission: String?)` Version of `sendBroadcast(android.content.Intent,java.lang.String)` that allows you to specify the user the broadcast will be sent to.
open Unit	`sendOrderedBroadcast(intent: Intent!, receiverPermission: String?)` Broadcast the given intent to all interested BroadcastReceivers, delivering them one at a time to allow more preferred receivers to consume the broadcast before it is delivered to less preferred receivers.
open Unit	`sendOrderedBroadcast(intent: Intent, receiverPermission: String?, resultReceiver: BroadcastReceiver?, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)` Version of `sendBroadcast(android.content.Intent)` that allows you to receive data back from the broadcast.
open Unit	`sendOrderedBroadcast(intent: Intent, receiverPermission: String?, options: Bundle?, resultReceiver: BroadcastReceiver?, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)`
open Unit	`sendOrderedBroadcast(intent: Intent, receiverPermission: String?, receiverAppOp: String?, resultReceiver: BroadcastReceiver?, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)` Version of `sendOrderedBroadcast(android.content.Intent,java.lang.String,android.content.BroadcastReceiver,android.os.Handler,int,java.lang.String,android.os.Bundle)` that allows you to specify the App Op to enforce restrictions on which receivers the broadcast will be sent to.
open Unit	`sendOrderedBroadcastAsUser(intent: Intent!, user: UserHandle!, receiverPermission: String?, resultReceiver: BroadcastReceiver!, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)` Version of `sendOrderedBroadcast(android.content.Intent,java.lang.String,android.content.BroadcastReceiver,android.os.Handler,int,java.lang.String,android.os.Bundle)` that allows you to specify the user the broadcast will be sent to.
open Unit	`sendStickyBroadcast(intent: Intent!)` Perform a `sendBroadcast(android.content.Intent)` that is "sticky," meaning the Intent you are sending stays around after the broadcast is complete, so that others can quickly retrieve that data through the return value of `registerReceiver(android.content.BroadcastReceiver,android.content.IntentFilter)`.
open Unit	`sendStickyBroadcast(intent: Intent, options: Bundle?)` Perform a `sendBroadcast(android.content.Intent)` that is "sticky," meaning the Intent you are sending stays around after the broadcast is complete, so that others can quickly retrieve that data through the return value of `registerReceiver(android.content.BroadcastReceiver,android.content.IntentFilter)`.
open Unit	`sendStickyBroadcastAsUser(intent: Intent!, user: UserHandle!)` Version of `sendStickyBroadcast(android.content.Intent)` that allows you to specify the user the broadcast will be sent to.
open Unit	`sendStickyOrderedBroadcast(intent: Intent!, resultReceiver: BroadcastReceiver!, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)` Version of #sendStickyBroadcast that allows you to receive data back from the broadcast.
open Unit	`sendStickyOrderedBroadcastAsUser(intent: Intent!, user: UserHandle!, resultReceiver: BroadcastReceiver!, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)` Version of `sendStickyOrderedBroadcast(android.content.Intent,android.content.BroadcastReceiver,android.os.Handler,int,java.lang.String,android.os.Bundle)` that allows you to specify the user the broadcast will be sent to.
open Unit	`setTheme(resid: Int)` Set the base theme for this context.
open Unit	`setWallpaper(bitmap: Bitmap!)`
open Unit	`setWallpaper(data: InputStream!)`
open Unit	`startActivities(intents: Array<Intent!>!)` Same as `startActivities(android.content.Intent[],android.os.Bundle)` with no options specified.
open Unit	`startActivities(intents: Array<Intent!>!, options: Bundle!)` Launch multiple new activities.
open Unit	`startActivity(intent: Intent!)` Same as `startActivity(android.content.Intent,android.os.Bundle)` with no options specified.
open Unit	`startActivity(intent: Intent!, options: Bundle?)` Launch a new activity.
open ComponentName?	`startForegroundService(service: Intent!)` Similar to `startService(android.content.Intent)`, but with an implicit promise that the Service will call `startForeground(int, android.app.Notification)` once it begins running.
open Boolean	`startInstrumentation(className: ComponentName, profileFile: String?, arguments: Bundle?)` Start executing an `android.app.Instrumentation` class.
open Unit	`startIntentSender(intent: IntentSender!, fillInIntent: Intent?, flagsMask: Int, flagsValues: Int, extraFlags: Int)` Same as `startIntentSender(android.content.IntentSender,android.content.Intent,int,int,int,android.os.Bundle)` with no options specified.
open Unit	`startIntentSender(intent: IntentSender!, fillInIntent: Intent?, flagsMask: Int, flagsValues: Int, extraFlags: Int, options: Bundle?)` Like `startActivity(android.content.Intent,android.os.Bundle)`, but taking a IntentSender to start.
open ComponentName?	`startService(service: Intent!)` Request that a given application service be started.
open Boolean	`stopService(service: Intent!)` Request that a given application service be stopped.
open Unit	`unbindService(conn: ServiceConnection)` Disconnect from an application service.
open Unit	`unregisterReceiver(receiver: BroadcastReceiver!)` Unregister a previously registered BroadcastReceiver.
open Unit	`updateServiceGroup(conn: ServiceConnection, group: Int, importance: Int)` For a service previously bound with #bindService or a related method, change how the system manages that service's process in relation to other processes.

Inherited functions

From class Context

`Boolean`	`bindIsolatedService(service: Intent, flags: Context.BindServiceFlags, instanceName: String, executor: Executor, conn: ServiceConnection)` See `bindIsolatedService(android.content.Intent,int,java.lang.String,java.util.concurrent.Executor,android.content.ServiceConnection)` Call `BindServiceFlags.of(long)` to obtain a BindServiceFlags object.
`Boolean`	`bindService(service: Intent, flags: Context.BindServiceFlags, executor: Executor, conn: ServiceConnection)` See `bindService(android.content.Intent,int,java.util.concurrent.Executor,android.content.ServiceConnection)` Call `BindServiceFlags.of(long)` to obtain a BindServiceFlags object.
`Boolean`	`bindService(service: Intent, conn: ServiceConnection, flags: Context.BindServiceFlags)` See `bindService(android.content.Intent,android.content.ServiceConnection,int)` Call `BindServiceFlags.of(long)` to obtain a BindServiceFlags object.
`Boolean`	`bindServiceAsUser(service: Intent, conn: ServiceConnection, flags: Context.BindServiceFlags, user: UserHandle)` See `bindServiceAsUser(android.content.Intent,android.content.ServiceConnection,int,android.os.UserHandle)` Call `BindServiceFlags.of(long)` to obtain a BindServiceFlags object.
`IntArray`	`checkCallingOrSelfUriPermissions(uris: MutableList<Uri!>, modeFlags: Int)` Determine whether the calling process of an IPC or you has been granted permission to access a list of URIs. This is the same as `checkCallingUriPermission`, except it grants your own permissions if you are not currently processing an IPC. Use with care!
`IntArray`	`checkCallingUriPermissions(uris: MutableList<Uri!>, modeFlags: Int)` Determine whether the calling process and uid has been granted permission to access a list of URIs. This is basically the same as calling `checkUriPermissions(java.util.List,int,int,int)` with the pid and uid returned by `android.os.Binder#getCallingPid` and `android.os.Binder#getCallingUid`. One important difference is that if you are not currently processing an IPC, this function will always fail.
`Int`	`checkContentUriPermissionFull(uri: Uri, pid: Int, uid: Int, modeFlags: Int)` Determine whether a particular process and uid has been granted permission to access a specific content URI. Unlike `checkUriPermission(android.net.Uri,int,int,int)`, this method checks for general access to the URI's content provider, as well as explicitly granted permissions. Note, this check will throw an `IllegalArgumentException` for non-content URIs.
`IntArray`	`checkUriPermissions(uris: MutableList<Uri!>, pid: Int, uid: Int, modeFlags: Int)` Determine whether a particular process and uid has been granted permission to access a list of URIs. This only checks for permissions that have been explicitly granted -- if the given process/uid has more general access to the URI's content provider then this check will always fail. Note: On SDK Version `android.os.Build.VERSION_CODES#S`, calling this method from a secondary-user's context will incorrectly return `PackageManager.PERMISSION_DENIED` for all {code uris}.
`Context`	`createAttributionContext(attributionTag: String?)` Return a new Context object for the current Context but attribute to a different tag. In complex apps attribution tagging can be used to distinguish between separate logical parts.
`Context`	`createContext(contextParams: ContextParams)` Creates a context with specific properties and behaviors.
`AttributionSource`	`getAttributionSource()`
`String?`	`getAttributionTag()` Attribution can be used in complex apps to logically separate parts of the app. E.g. a blogging app might also have a instant messaging app built in. In this case two separate tags can for used each sub-feature.
`Int`	`getColor(id: Int)` Returns a color associated with a particular resource ID and styled for the current theme.
`ColorStateList`	`getColorStateList(id: Int)` Returns a color state list associated with a particular resource ID and styled for the current theme.
`Drawable?`	`getDrawable(id: Int)` Returns a drawable object associated with a particular resource ID and styled for the current theme.
`ContextParams?`	`getParams()` Return the set of parameters which this Context was created with, if it was created via `createContext(android.content.ContextParams)`.
`String`	`getString(resId: Int)` Returns a localized string from the application's package's default string table.
`String`	`getString(resId: Int, vararg formatArgs: Any!)` Returns a localized formatted string from the application's package's default string table, substituting the format arguments as defined in `java.util.Formatter` and java.lang.String#format.
`T`	`getSystemService(serviceClass: Class<T>)` Return the handle to a system-level service by class. Currently available classes are: `android.view.WindowManager`, `android.view.LayoutInflater`, `android.app.ActivityManager`, `android.os.PowerManager`, `android.app.AlarmManager`, `android.app.NotificationManager`, `android.app.KeyguardManager`, `android.location.LocationManager`, `android.app.SearchManager`, `android.os.Vibrator`, `android.net.ConnectivityManager`, `android.net.wifi.WifiManager`, `android.media.AudioManager`, `android.media.MediaRouter`, `android.telephony.TelephonyManager`, `android.telephony.SubscriptionManager`, `android.view.inputmethod.InputMethodManager`, `android.app.UiModeManager`, `android.app.DownloadManager`, `android.os.BatteryManager`, `android.app.job.JobScheduler`, `android.app.usage.NetworkStatsManager`, `android.content.pm.verify.domain.DomainVerificationManager`, `android.view.displayhash.DisplayHashManager` `android.security.authenticationpolicy.AuthenticationPolicyManager`. Note: System services obtained via this API may be closely associated with the Context in which they are obtained from. In general, do not share the service objects between various different contexts (Activities, Applications, Services, Providers, etc.) Note: Instant apps, for which `PackageManager.isInstantApp()` returns true, don't have access to the following system services: `DEVICE_POLICY_SERVICE`, #FINGERPRINT_SERVICE, `KEYGUARD_SERVICE`, `SHORTCUT_SERVICE`, `USB_SERVICE`, `WALLPAPER_SERVICE`, `WIFI_P2P_SERVICE`, `WIFI_SERVICE`, `WIFI_AWARE_SERVICE`. For these services this method will return `null`. Generally, if you are running as an instant app you should always check whether the result of this method is `null`.
`CharSequence`	`getText(resId: Int)` Return a localized, styled CharSequence from the application's package's default string table.
`TypedArray`	`obtainStyledAttributes(set: AttributeSet?, attrs: IntArray)` Retrieve styled attribute information in this Context's theme. See `android.content.res.Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)` for more information.
`TypedArray`	`obtainStyledAttributes(set: AttributeSet?, attrs: IntArray, defStyleAttr: Int, defStyleRes: Int)` Retrieve styled attribute information in this Context's theme. See `android.content.res.Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)` for more information.
`TypedArray`	`obtainStyledAttributes(resid: Int, attrs: IntArray)` Retrieve styled attribute information in this Context's theme. See `android.content.res.Resources.Theme#obtainStyledAttributes(int, int[])` for more information.
`TypedArray`	`obtainStyledAttributes(attrs: IntArray)` Retrieve styled attribute information in this Context's theme. See `android.content.res.Resources.Theme#obtainStyledAttributes(int[])` for more information.
`Unit`	`registerComponentCallbacks(callback: ComponentCallbacks!)` Add a new `ComponentCallbacks` to the base application of the Context, which will be called at the same times as the ComponentCallbacks methods of activities and other components are called. Note that you must be sure to use `unregisterComponentCallbacks` when appropriate in the future; this will not be removed for you. After `Build.VERSION_CODES.S`, registering the ComponentCallbacks to Context created via `createWindowContext(int,android.os.Bundle)` or `createWindowContext(android.view.Display,int,android.os.Bundle)` will receive `ComponentCallbacks.onConfigurationChanged(Configuration)` from Window Context rather than its base application. It is helpful if you want to handle UI components that associated with the Window Context when the Window Context has configuration changes. After `Build.VERSION_CODES.TIRAMISU`, registering the ComponentCallbacks to `Activity` context will receive `ComponentCallbacks.onConfigurationChanged(Configuration)` from `Activity.onConfigurationChanged(Configuration)` rather than its base application. After `Build.VERSION_CODES.UPSIDE_DOWN_CAKE`, registering the ComponentCallbacks to `android.inputmethodservice.InputMethodService` will receive `ComponentCallbacks.onConfigurationChanged(Configuration)` from InputmethodService rather than its base application. It is helpful if you want to handle UI components when the IME has configuration changes.
`Unit`	`registerDeviceIdChangeListener(executor: Executor, listener: IntConsumer)` Adds a new device ID changed listener to the `Context`, which will be called when the device association is changed by the system. The callback can be called when an app is moved to a different device and the `Context` is not explicitly associated with a specific device. When an application receives a device id update callback, this Context is guaranteed to also have an updated display ID(if any) and `Configuration`.
`Unit`	`revokeSelfPermissionOnKill(permName: String)` Triggers the asynchronous revocation of a runtime permission. If the permission is not currently granted, nothing happens (even if later granted by the user).
`Unit`	`revokeSelfPermissionsOnKill(permissions: MutableCollection<String!>)` Triggers the revocation of one or more permissions for the calling package. A package is only able to revoke runtime permissions. If a permission is not currently granted, it is ignored and will not get revoked (even if later granted by the user). Ultimately, you should never make assumptions about a permission status as users may grant or revoke them at any time. Background permissions which have no corresponding foreground permission still granted once the revocation is effective will also be revoked. The revocation happens asynchronously and kills all processes running in the calling UID. It will be triggered once it is safe to do so. In particular, it will not be triggered as long as the package remains in the foreground, or has any active manifest components (e.g. when another app is accessing a content provider in the package). If you want to revoke the permissions right away, you could call `System.exit()` in `Handler.postDelayed` with a delay to allow completion of async IPC, But `System.exit()` could affect other apps that are accessing your app at the moment. For example, apps accessing a content provider in your app will all crash. Note that the settings UI shows a permission group as granted as long as at least one permission in the group is granted. If you want the user to observe the revocation in the settings, you should revoke every permission in the target group. To learn the current list of permissions in a group, you may use `PackageManager.getGroupOfPlatformPermission(String, Executor, Consumer)` and `PackageManager.getPlatformPermissionsForGroup(String, Executor, Consumer)`. This list of permissions may evolve over time, so it is recommended to check whether it contains any permission you wish to retain before trying to revoke an entire group.
`Unit`	`sendBroadcastWithMultiplePermissions(intent: Intent, receiverPermissions: Array<String!>)` Broadcast the given intent to all interested BroadcastReceivers, allowing an array of required permissions to be enforced. This call is asynchronous; it returns immediately, and you will continue executing while the receivers are run. No results are propagated from receivers and receivers can not abort the broadcast. If you want to allow receivers to propagate results or abort the broadcast, you must send an ordered broadcast using `sendOrderedBroadcast(android.content.Intent,java.lang.String)`. See `BroadcastReceiver` for more information on Intent broadcasts.
`Unit`	`sendOrderedBroadcast(intent: Intent, receiverPermission: String?, options: Bundle?)` Broadcast the given intent to all interested BroadcastReceivers, delivering them one at a time to allow more preferred receivers to consume the broadcast before it is delivered to less preferred receivers. This call is asynchronous; it returns immediately, and you will continue executing while the receivers are run. See `BroadcastReceiver` for more information on Intent broadcasts.
`Unit`	`unregisterComponentCallbacks(callback: ComponentCallbacks!)` Remove a `ComponentCallbacks` object that was previously registered with `registerComponentCallbacks(android.content.ComponentCallbacks)`.
`Unit`	`unregisterDeviceIdChangeListener(listener: IntConsumer)` Removes a device ID changed listener from the Context. It's a no-op if the listener is not already registered.

Public constructors

MockContext

MockContext()

Public methods

bindIsolatedService

Added in API level 29

open fun bindIsolatedService(
    service: Intent, 
    flags: Int, 
    instanceName: String, 
    executor: Executor, 
    conn: ServiceConnection
): Boolean

Variation of #bindService that, in the specific case of isolated services, allows the caller to generate multiple instances of a service from a single component declaration. In other words, you can use this to bind to a service that has specified android.R.attr#isolatedProcess and, in addition to the existing behavior of running in an isolated process, you can also through the arguments here have the system bring up multiple concurrent processes hosting their own instances of that service. The instanceName you provide here identifies the different instances, and you can use updateServiceGroup(android.content.ServiceConnection,int,int) to tell the system how it should manage each of these instances.

Parameters
`service`	Intent: Identifies the service to connect to. The Intent must specify an explicit component name. This value cannot be `null`.
`flags`	Int: Operation options for the binding as per #bindService.
`instanceName`	String: Unique identifier for the service instance. Each unique name here will result in a different service instance being created. Identifiers must only contain ASCII letters, digits, underscores, and periods. This value cannot be `null`.
`executor`	Executor: Callbacks on ServiceConnection will be called on executor. Must use same instance for the same instance of ServiceConnection. This value cannot be `null`. Callback and listener events are dispatched through this `Executor`, providing an easy way to control which thread is used. To dispatch events through the main thread of your application, you can use `Context.getMainExecutor()`. Otherwise, provide an `Executor` that dispatches to an appropriate thread.
`conn`	ServiceConnection: Receives information as the service is started and stopped. This must be a valid ServiceConnection object; it must not be null.

Return
`Boolean`	Returns success of binding as per #bindService.

Exceptions
`java.lang.IllegalArgumentException`	If the instanceName is invalid.
`java.lang.SecurityException`	If the caller does not have permission to access the service

Parameters
`service`	Intent: This value cannot be `null`.
`flags`	Int: Value is either `0` or a combination of the following: `BIND_AUTO_CREATE` `BIND_DEBUG_UNBIND` `BIND_NOT_FOREGROUND` `BIND_ABOVE_CLIENT` `BIND_ALLOW_OOM_MANAGEMENT` `BIND_WAIVE_PRIORITY` `BIND_IMPORTANT` `BIND_ADJUST_WITH_ACTIVITY` `BIND_NOT_PERCEPTIBLE` `BIND_ALLOW_ACTIVITY_STARTS` `BIND_INCLUDE_CAPABILITIES` `BIND_SHARED_ISOLATED_PROCESS` `BIND_PACKAGE_ISOLATED_PROCESS` `BIND_EXTERNAL_SERVICE`
`executor`	Executor: Callbacks on ServiceConnection will be called on executor. Must use same instance for the same instance of ServiceConnection. This value cannot be `null`. Callback and listener events are dispatched through this `Executor`, providing an easy way to control which thread is used. To dispatch events through the main thread of your application, you can use `Context.getMainExecutor()`. Otherwise, provide an `Executor` that dispatches to an appropriate thread.
`conn`	ServiceConnection: This value cannot be `null`.

Parameters
`uri`	Uri!: The uri that is being checked.
`modeFlags`	Int: The access modes to check. Value is either `0` or a combination of the following: `android.content.Intent#FLAG_GRANT_READ_URI_PERMISSION` `android.content.Intent#FLAG_GRANT_WRITE_URI_PERMISSION`

Parameters
`permission`	String: The name of the permission being checked. This value cannot be `null`.
`pid`	Int: The process ID being checked against. Must be > 0.
`uid`	Int: The UID being checked against. A uid of 0 is the root user, which will pass every permission check.

Parameters
`uri`	Uri?: The Uri whose permission is to be checked, or null to not do this check.
`readPermission`	String?: The permission that provides overall read access, or null to not do this check.
`writePermission`	String?: The permission that provides overall write access, or null to not do this check.
`pid`	Int: The process ID being checked against. Must be > 0.
`uid`	Int: The UID being checked against. A uid of 0 is the root user, which will pass every permission check.
`modeFlags`	Int: The access modes to check. Value is either `0` or a combination of the following: `android.content.Intent#FLAG_GRANT_READ_URI_PERMISSION` `android.content.Intent#FLAG_GRANT_WRITE_URI_PERMISSION`

Parameters
`packageName`	String!: Name of the application's package.
`flags`	Int: Option flags. Value is either `0` or a combination of the following: `CONTEXT_INCLUDE_CODE` `CONTEXT_IGNORE_SECURITY` `CONTEXT_RESTRICTED`

Exceptions
`android.content.pm.PackageManager.NameNotFoundException`	if there is no application with the given package name.
`java.lang.SecurityException`

Parameters
`display`	Display: The `Display` to associate with. This value cannot be `null`.
`type`	Int: Window type in `WindowManager.LayoutParams` Value is one of the following: `android.view.WindowManager.LayoutParams#TYPE_BASE_APPLICATION` `android.view.WindowManager.LayoutParams#TYPE_APPLICATION` `android.view.WindowManager.LayoutParams#TYPE_APPLICATION_STARTING` `android.view.WindowManager.LayoutParams#TYPE_DRAWN_APPLICATION` `android.view.WindowManager.LayoutParams#TYPE_APPLICATION_PANEL` `android.view.WindowManager.LayoutParams#TYPE_APPLICATION_MEDIA` `android.view.WindowManager.LayoutParams#TYPE_APPLICATION_SUB_PANEL` `android.view.WindowManager.LayoutParams#TYPE_APPLICATION_ATTACHED_DIALOG` `android.view.WindowManager.LayoutParams#TYPE_STATUS_BAR` `android.view.WindowManager.LayoutParams#TYPE_SEARCH_BAR` `android.view.WindowManager.LayoutParams#TYPE_PHONE` `android.view.WindowManager.LayoutParams#TYPE_SYSTEM_ALERT` `android.view.WindowManager.LayoutParams#TYPE_TOAST` `android.view.WindowManager.LayoutParams#TYPE_SYSTEM_OVERLAY` `android.view.WindowManager.LayoutParams#TYPE_PRIORITY_PHONE` `android.view.WindowManager.LayoutParams#TYPE_SYSTEM_DIALOG` `android.view.WindowManager.LayoutParams#TYPE_KEYGUARD_DIALOG` `android.view.WindowManager.LayoutParams#TYPE_SYSTEM_ERROR` `android.view.WindowManager.LayoutParams#TYPE_INPUT_METHOD` `android.view.WindowManager.LayoutParams#TYPE_INPUT_METHOD_DIALOG` `android.view.WindowManager.LayoutParams#TYPE_WALLPAPER` `android.view.WindowManager.LayoutParams#TYPE_PRIVATE_PRESENTATION` `android.view.WindowManager.LayoutParams#TYPE_ACCESSIBILITY_OVERLAY` `android.view.WindowManager.LayoutParams#TYPE_APPLICATION_OVERLAY`
`options`	Bundle?: A bundle used to pass window-related options. This value may be `null`.

Parameters
`permission`	String: The name of the permission being checked. This value cannot be `null`.
`message`	String?: A message to include in the exception if it is thrown. This value may be `null`.

Parameters
`name`	String!: Name of the directory to retrieve. This is a directory that is created as part of your application data.
`mode`	Int: Operating mode. Value is either `0` or a combination of the following: `MODE_PRIVATE` `MODE_WORLD_READABLE` `MODE_WORLD_WRITEABLE` `MODE_APPEND`

Parameters
`name`	String!: Desired preferences file.
`mode`	Int: Operating mode. Value is either `0` or a combination of the following: `MODE_PRIVATE` `MODE_WORLD_READABLE` `MODE_WORLD_WRITEABLE` `MODE_MULTI_PROCESS`

Parameters
`toPackage`	String!: The package you would like to allow to access the Uri.
`uri`	Uri!: The Uri you would like to grant access to.
`modeFlags`	Int: The desired access modes. Value is either `0` or a combination of the following: `android.content.Intent#FLAG_GRANT_READ_URI_PERMISSION` `android.content.Intent#FLAG_GRANT_WRITE_URI_PERMISSION` `android.content.Intent#FLAG_GRANT_PERSISTABLE_URI_PERMISSION` `android.content.Intent#FLAG_GRANT_PREFIX_URI_PERMISSION`

Parameters
`sourceContext`	Context!: The source context which contains the existing database to move.
`name`	String!: The name of the database file.

Parameters
`name`	String!: The name of the file to open; can not contain path separators.
`mode`	Int: Operating mode. Value is either `0` or a combination of the following: `MODE_PRIVATE` `MODE_WORLD_READABLE` `MODE_WORLD_WRITEABLE` `MODE_APPEND`

Parameters
`name`	The name (unique in the application package) of the database.
`mode`	Int: Operating mode. Value is either `0` or a combination of the following: `MODE_PRIVATE` `MODE_WORLD_READABLE` `MODE_WORLD_WRITEABLE` `MODE_ENABLE_WRITE_AHEAD_LOGGING` `MODE_NO_LOCALIZED_COLLATORS`
`factory`	SQLiteDatabase.CursorFactory!: An optional factory class that is called to instantiate a cursor when query is called.

Parameters
`receiver`	BroadcastReceiver?: The BroadcastReceiver to handle the broadcast. This value may be `null`.
`filter`	IntentFilter!: Selects the Intent broadcasts to be received.

Parameters
`receiver`	BroadcastReceiver!: The BroadcastReceiver to handle the broadcast.
`filter`	IntentFilter!: Selects the Intent broadcasts to be received.
`broadcastPermission`	String?: String naming a permissions that a broadcaster must hold in order to send an Intent to you. If null, no permission is required.
`scheduler`	Handler?: Handler identifying the thread that will receive the Intent. If null, the main thread of the process will be used.

Parameters
`intent`	Intent!: The Intent that was previously broadcast.
`user`	UserHandle!: UserHandle to remove the sticky broadcast from.

Parameters
`uri`	Uri!: The Uri you would like to revoke access to.
`modeFlags`	Int: The access modes to revoke. Value is either `0` or a combination of the following: `android.content.Intent#FLAG_GRANT_READ_URI_PERMISSION` `android.content.Intent#FLAG_GRANT_WRITE_URI_PERMISSION`

Parameters
`toPackage`	The package you had previously granted access to.
`uri`	Uri!: The Uri you would like to revoke access to.
`modeFlags`	Int: The access modes to revoke. Value is either `0` or a combination of the following: `android.content.Intent#FLAG_GRANT_READ_URI_PERMISSION` `android.content.Intent#FLAG_GRANT_WRITE_URI_PERMISSION`

Parameters
`intent`	Intent!: The Intent to broadcast; all receivers matching this Intent will receive the broadcast.
`receiverPermission`	String?: (optional) String naming a permission that a receiver must hold in order to receive your broadcast. If null, no permission is required.

MockContext

Summary

Public constructors

MockContext

Public methods

bindIsolatedService

bindService

bindService

bindServiceAsUser

checkCallingOrSelfPermission

checkCallingOrSelfUriPermission

checkCallingPermission

checkCallingUriPermission

checkPermission

checkSelfPermission

checkUriPermission

checkUriPermission

clearWallpaper

createConfigurationContext

createContextForSplit

createDeviceContext

createDeviceProtectedStorageContext

createDisplayContext

createPackageContext

createWindowContext

createWindowContext

databaseList

deleteDatabase

deleteFile

deleteSharedPreferences

enforceCallingOrSelfPermission

enforceCallingOrSelfUriPermission

enforceCallingPermission

enforceCallingUriPermission

enforcePermission

enforceUriPermission

enforceUriPermission

fileList

getApplicationContext

getApplicationInfo

getAssets

getCacheDir

getClassLoader

getCodeCacheDir

getContentResolver

getDataDir

getDatabasePath

getDeviceId

getDir

getDisplay

getExternalCacheDir

getExternalCacheDirs

getExternalFilesDir

getExternalFilesDirs

getExternalMediaDirs

getFileStreamPath

getFilesDir

getMainExecutor

getMainLooper

getNoBackupFilesDir

getObbDir

getObbDirs

getOpPackageName

getPackageCodePath

getPackageManager

getPackageName

getPackageResourcePath

getResources

getSharedPreferences

getSystemService

getSystemServiceName

getTheme

getWallpaper

getWallpaperDesiredMinimumHeight

getWallpaperDesiredMinimumWidth

grantUriPermission

isDeviceProtectedStorage

isRestricted

isUiContext

moveDatabaseFrom

Parameters
`intent`	Intent: The Intent to broadcast; all receivers matching this Intent will receive the broadcast. This value cannot be `null`.
`receiverPermission`	String?: (optional) String naming a permission that a receiver must hold in order to receive your broadcast. If null, no permission is required.
`options`	Bundle?: (optional) Additional sending options, generated from a `android.app.BroadcastOptions`. This value may be `null`.

Parameters
`intent`	Intent!: The intent to broadcast
`user`	UserHandle!: UserHandle to send the intent to.

Parameters
`intent`	Intent!: The Intent to broadcast; all receivers matching this Intent will receive the broadcast.
`resultReceiver`	BroadcastReceiver!: Your own BroadcastReceiver to treat as the final receiver of the broadcast.
`scheduler`	Handler?: A custom Handler with which to schedule the resultReceiver callback; if null it will be scheduled in the Context's main thread.
`initialCode`	Int: An initial value for the result code. Often Activity.RESULT_OK.
`initialData`	String?: An initial value for the result data. Often null.
`initialExtras`	Bundle?: An initial value for the result extras. Often null.

Parameters
`intents`	Array<Intent!>!: An array of Intents to be started.
`options`	Bundle!: Additional options for how the Activity should be started. See `android.content.Context#startActivity(Intent, Bundle)` Context.startActivity(Intent, Bundle)} for more details.

Parameters
`intent`	Intent!: The description of the activity to start.
`options`	Bundle?: Additional options for how the Activity should be started. May be null if there are no options. See `android.app.ActivityOptions` for how to build the Bundle supplied here; there are no supported definitions for building it manually.

Exceptions
`android.app.ForegroundServiceStartNotAllowedException`	If the caller app's targeting API is `android.os.Build.VERSION_CODES#S` or later, and the foreground service is restricted from start due to background restriction.
`java.lang.SecurityException`	If the caller does not have permission to access the service or the service can not be found.

Parameters
`className`	ComponentName: Name of the Instrumentation component to be run. This value cannot be `null`.
`profileFile`	String?: Optional path to write profiling data as the instrumentation runs, or null for no profiling.
`arguments`	Bundle?: Additional optional arguments to pass to the instrumentation, or null.

Parameters
`intent`	IntentSender!: The IntentSender to launch.
`fillInIntent`	Intent?: If non-null, this will be provided as the intent parameter to android.content.IntentSender#sendIntent.
`flagsMask`	Int: Intent flags in the original IntentSender that you would like to change. Value is either `0` or a combination of the following: `android.content.Intent#FLAG_FROM_BACKGROUND` `android.content.Intent#FLAG_DEBUG_LOG_RESOLUTION` `android.content.Intent#FLAG_EXCLUDE_STOPPED_PACKAGES` `android.content.Intent#FLAG_INCLUDE_STOPPED_PACKAGES` `android.content.Intent#FLAG_ACTIVITY_MATCH_EXTERNAL` `android.content.Intent#FLAG_ACTIVITY_NO_HISTORY` `android.content.Intent#FLAG_ACTIVITY_SINGLE_TOP` `android.content.Intent#FLAG_ACTIVITY_NEW_TASK` `android.content.Intent#FLAG_ACTIVITY_MULTIPLE_TASK` `android.content.Intent#FLAG_ACTIVITY_CLEAR_TOP` `android.content.Intent#FLAG_ACTIVITY_FORWARD_RESULT` `android.content.Intent#FLAG_ACTIVITY_PREVIOUS_IS_TOP` `android.content.Intent#FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS` `android.content.Intent#FLAG_ACTIVITY_BROUGHT_TO_FRONT` `android.content.Intent#FLAG_ACTIVITY_RESET_TASK_IF_NEEDED` `android.content.Intent#FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY` `android.content.Intent#FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET` `android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT` `android.content.Intent#FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET` `android.content.Intent#FLAG_ACTIVITY_NO_USER_ACTION` `android.content.Intent#FLAG_ACTIVITY_REORDER_TO_FRONT` `android.content.Intent#FLAG_ACTIVITY_NO_ANIMATION` `android.content.Intent#FLAG_ACTIVITY_CLEAR_TASK` `android.content.Intent#FLAG_ACTIVITY_TASK_ON_HOME` `android.content.Intent#FLAG_ACTIVITY_RETAIN_IN_RECENTS` `android.content.Intent#FLAG_ACTIVITY_LAUNCH_ADJACENT` `android.content.Intent#FLAG_RECEIVER_REGISTERED_ONLY` `android.content.Intent#FLAG_RECEIVER_REPLACE_PENDING` `android.content.Intent#FLAG_RECEIVER_FOREGROUND` `android.content.Intent#FLAG_RECEIVER_NO_ABORT` `android.content.Intent#FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS`
`flagsValues`	Int: Desired values for any bits set in flagsMask. Value is either `0` or a combination of the following: `android.content.Intent#FLAG_FROM_BACKGROUND` `android.content.Intent#FLAG_DEBUG_LOG_RESOLUTION` `android.content.Intent#FLAG_EXCLUDE_STOPPED_PACKAGES` `android.content.Intent#FLAG_INCLUDE_STOPPED_PACKAGES` `android.content.Intent#FLAG_ACTIVITY_MATCH_EXTERNAL` `android.content.Intent#FLAG_ACTIVITY_NO_HISTORY` `android.content.Intent#FLAG_ACTIVITY_SINGLE_TOP` `android.content.Intent#FLAG_ACTIVITY_NEW_TASK` `android.content.Intent#FLAG_ACTIVITY_MULTIPLE_TASK` `android.content.Intent#FLAG_ACTIVITY_CLEAR_TOP` `android.content.Intent#FLAG_ACTIVITY_FORWARD_RESULT` `android.content.Intent#FLAG_ACTIVITY_PREVIOUS_IS_TOP` `android.content.Intent#FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS` `android.content.Intent#FLAG_ACTIVITY_BROUGHT_TO_FRONT` `android.content.Intent#FLAG_ACTIVITY_RESET_TASK_IF_NEEDED` `android.content.Intent#FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY` `android.content.Intent#FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET` `android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT` `android.content.Intent#FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET` `android.content.Intent#FLAG_ACTIVITY_NO_USER_ACTION` `android.content.Intent#FLAG_ACTIVITY_REORDER_TO_FRONT` `android.content.Intent#FLAG_ACTIVITY_NO_ANIMATION` `android.content.Intent#FLAG_ACTIVITY_CLEAR_TASK` `android.content.Intent#FLAG_ACTIVITY_TASK_ON_HOME` `android.content.Intent#FLAG_ACTIVITY_RETAIN_IN_RECENTS` `android.content.Intent#FLAG_ACTIVITY_LAUNCH_ADJACENT` `android.content.Intent#FLAG_RECEIVER_REGISTERED_ONLY` `android.content.Intent#FLAG_RECEIVER_REPLACE_PENDING` `android.content.Intent#FLAG_RECEIVER_FOREGROUND` `android.content.Intent#FLAG_RECEIVER_NO_ABORT` `android.content.Intent#FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS`
`extraFlags`	Int: Always set to 0.

Exceptions
`android.app.BackgroundServiceStartNotAllowedException`	On Android `android.os.Build.VERSION_CODES#S` and later, if the application is in a state where the service can not be started (such as not in the foreground in a state when services are allowed), `android.app.BackgroundServiceStartNotAllowedException` is thrown. This exception extends `IllegalStateException`, so apps can use `catch (IllegalStateException)` to catch both.
`java.lang.IllegalStateException`	Before Android `android.os.Build.VERSION_CODES#S`, if the application is in a state where the service can not be started (such as not in the foreground in a state when services are allowed), `IllegalStateException` was thrown.
`java.lang.SecurityException`	If the caller does not have permission to access the service or the service can not be found.

Exceptions
`java.lang.IllegalStateException`	If the application is in a state where the service can not be started (such as not in the foreground in a state when services are allowed).
`java.lang.SecurityException`	If the caller does not have permission to access the service or the service can not be found.