/**@class android.content.Context
@extends java.lang.Object
Interface to global information about an application environment. This is
an abstract class whose implementation is provided by
the Android system. It
allows access to application-specific resources and classes, as well as
up-calls for application-level operations such as launching activities,
broadcasting and receiving intents, etc.
*/
var Context = {
/** 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).
*/
MODE_PRIVATE : "0",
/** File creation mode: allow all other applications to have read access to
the created file.
<p>
Starting from {@link android.os.Build.VERSION_CODES#N}, attempting to use this
mode throws a {@link SecurityException}.
@deprecated Creating world-readable files is very dangerous, and likely
to cause security holes in applications. It is strongly
discouraged; instead, applications should use more formal
mechanism for interactions such as {@link android.content.ContentProvider},
{@link android.content.BroadcastReceiver}, and {@link android.app.Service}.
There are no guarantees that this access mode will remain on
a file, such as when it goes through a backup and restore.
@see android.support.v4.content.FileProvider
@see Intent#FLAG_GRANT_WRITE_URI_PERMISSION
*/
MODE_WORLD_READABLE : "1",
/** File creation mode: allow all other applications to have write access to
the created file.
<p>
Starting from {@link android.os.Build.VERSION_CODES#N}, attempting to use this
mode will throw a {@link SecurityException}.
@deprecated Creating world-writable files is very dangerous, and likely
to cause security holes in applications. It is strongly
discouraged; instead, applications should use more formal
mechanism for interactions such as {@link android.content.ContentProvider},
{@link android.content.BroadcastReceiver}, and {@link android.app.Service}.
There are no guarantees that this access mode will remain on
a file, such as when it goes through a backup and restore.
@see android.support.v4.content.FileProvider
@see Intent#FLAG_GRANT_WRITE_URI_PERMISSION
*/
MODE_WORLD_WRITEABLE : "2",
/** File creation mode: for use with {@link #openFileOutput}, if the file
already exists then write data to the end of the existing file
instead of erasing it.
@see #openFileOutput
*/
MODE_APPEND : "32768",
/** 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.
<p>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 <em>greater than</em> Android 2.3, this flag must be
explicitly set if desired.
@see #getSharedPreferences
@deprecated MODE_MULTI_PROCESS does not work reliably in
some versions of Android, and furthermore does not provide any
mechanism for reconciling concurrent modifications across
processes. Applications should not attempt to use it. Instead,
they should use an explicit cross-process data management
approach such as {@link android.content.ContentProvider ContentProvider}.
*/
MODE_MULTI_PROCESS : "4",
/** Database open flag: when set, the database is opened with write-ahead
logging enabled by default.
@see #openOrCreateDatabase(String, int, CursorFactory)
@see #openOrCreateDatabase(String, int, CursorFactory, DatabaseErrorHandler)
@see SQLiteDatabase#enableWriteAheadLogging
*/
MODE_ENABLE_WRITE_AHEAD_LOGGING : "8",
/** Database open flag: when set, the database is opened without support for
localized collators.
@see #openOrCreateDatabase(String, int, CursorFactory)
@see #openOrCreateDatabase(String, int, CursorFactory, DatabaseErrorHandler)
@see SQLiteDatabase#NO_LOCALIZED_COLLATORS
*/
MODE_NO_LOCALIZED_COLLATORS : "16",
/** Flag for {@link #bindService}: automatically create the service as long
as the binding exists. Note that while this will create the service,
its {@link android.app.Service#onStartCommand}
method will still only be called due to an
explicit call to {@link #startService}. Even without that, though,
this still provides you with access to the service object while the
service is created.
<p>Note that prior to {@link 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
{@link #BIND_ADJUST_WITH_ACTIVITY}. For compatibility, old applications
that don't specify {@link #BIND_AUTO_CREATE} will automatically have
the flags {@link #BIND_WAIVE_PRIORITY} and
{@link #BIND_ADJUST_WITH_ACTIVITY} set for them in order to achieve
the same result.
*/
BIND_AUTO_CREATE : "1",
/** Flag for {@link #bindService}: include debugging help for mismatched
calls to unbind. When this flag is set, the callstack of the following
{@link #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.
*/
BIND_DEBUG_UNBIND : "2",
/** Flag for {@link #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.
*/
BIND_NOT_FOREGROUND : "4",
/** Flag for {@link #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.
*/
BIND_ABOVE_CLIENT : "8",
/** Flag for {@link #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.
*/
BIND_ALLOW_OOM_MANAGEMENT : "16",
/** Flag for {@link #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.
*/
BIND_WAIVE_PRIORITY : "32",
/** Flag for {@link #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.
*/
BIND_IMPORTANT : "64",
/** Flag for {@link #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.
*/
BIND_ADJUST_WITH_ACTIVITY : "128",
/** Flag for {@link #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.
*/
BIND_NOT_PERCEPTIBLE : "256",
/** Flag for {@link #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.
*/
BIND_INCLUDE_CAPABILITIES : "4096",
/** Flag for {@link #bindService}: This flag is intended to be used only by the system to adjust
the scheduling policy for IMEs (and any other out-of-process user-visible components that
work closely with the top app) so that UI hosted in such services can have the same
scheduling policy (e.g. SCHED_FIFO when it is enabled and TOP_APP_PRIORITY_BOOST otherwise)
as the actual top-app.
@hide
*/
BIND_SCHEDULE_LIKE_TOP_APP : "524288",
/** Flag for {@link #bindService}: allow background activity starts from the bound service's
process.
This flag is only respected if the caller is holding
{@link android.Manifest.permission#START_ACTIVITIES_FROM_BACKGROUND}.
@hide
*/
BIND_ALLOW_BACKGROUND_ACTIVITY_STARTS : "1048576",
/** @hide Flag for {@link #bindService}: the service being bound to represents a
protected system component, so must have association restrictions applied to it.
That is, a system config must have one or more allow-association tags limiting
which packages it can interact with. If it does not have any such association
restrictions, a default empty set will be created.
*/
BIND_RESTRICT_ASSOCIATIONS : "2097152",
/** @hide Flag for {@link #bindService}: allows binding to a service provided
by an instant app. Note that the caller may not have access to the instant
app providing the service which is a violation of the instant app sandbox.
This flag is intended ONLY for development/testing and should be used with
great care. Only the system is allowed to use this flag.
*/
BIND_ALLOW_INSTANT : "4194304",
/** @hide Flag for {@link #bindService}: like {@link #BIND_NOT_FOREGROUND}, but puts it
up in to the important background state (instead of transient).
*/
BIND_IMPORTANT_BACKGROUND : "8388608",
/** @hide Flag for {@link #bindService}: allows application hosting service to manage whitelists
such as temporary allowing a {@code PendingIntent} to bypass Power Save mode.
*/
BIND_ALLOW_WHITELIST_MANAGEMENT : "16777216",
/** @hide Flag for {@link #bindService}: Like {@link #BIND_FOREGROUND_SERVICE},
but only applies while the device is awake.
*/
BIND_FOREGROUND_SERVICE_WHILE_AWAKE : "33554432",
/** @hide Flag for {@link #bindService}: For only the case where the binding
is coming from the system, set the process state to FOREGROUND_SERVICE
instead of the normal maximum of IMPORTANT_FOREGROUND. That is, this is
saying that the process shouldn't participate in the normal power reduction
modes (removing network access etc).
*/
BIND_FOREGROUND_SERVICE : "67108864",
/** @hide Flag for {@link #bindService}: Treat the binding as hosting
an activity, an unbinding as the activity going in the background.
That is, when unbinding, the process when empty will go on the activity
LRU list instead of the regular one, keeping it around more aggressively
than it otherwise would be. This is intended for use with IMEs to try
to keep IME processes around for faster keyboard switching.
*/
BIND_TREAT_LIKE_ACTIVITY : "134217728",
/** @hide An idea that is not yet implemented.
Flag for {@link #bindService}: If binding from an activity, consider
this service to be visible like the binding activity is. That is,
it will be treated as something more important to keep around than
invisible background activities. This will impact the number of
recent activities the user can switch between without having them
restart. There is no guarantee this will be respected, as the system
tries to balance such requests from one app vs. the importance of
keeping other apps around.
*/
BIND_VISIBLE : "268435456",
/** @hide
Flag for {@link #bindService}: Consider this binding to be causing the target
process to be showing UI, so it will be do a UI_HIDDEN memory trim when it goes
away.
*/
BIND_SHOWING_UI : "536870912",
/** Flag for {@link #bindService}: Don't consider the bound service to be
visible, even if the caller is visible.
@hide
*/
BIND_NOT_VISIBLE : "1073741824",
/** Flag for {@link #bindService}: The service being bound is an
{@link android.R.attr#isolatedProcess isolated},
{@link android.R.attr#externalService external} service. This binds the service into the
calling application's package, rather than the package in which the service is declared.
<p>
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.
</p>
*/
BIND_EXTERNAL_SERVICE : "-2147483648",
/** These bind flags reduce the strength of the binding such that we shouldn't
consider it as pulling the process up to the level of the one that is bound to it.
@hide
*/
BIND_REDUCTION_FLAGS : "1073742128",
/** Flag for {@link #registerReceiver}: The receiver can receive broadcasts from Instant Apps.
*/
RECEIVER_VISIBLE_TO_INSTANT_APPS : "1",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.os.PowerManager} for controlling power management,
including "wake locks," which let you keep the device on while
you're running long tasks.
*/
POWER_SERVICE : "power",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.os.RecoverySystem} for accessing the recovery system
service.
@see #getSystemService(String)
@hide
*/
RECOVERY_SERVICE : "recovery",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.os.SystemUpdateManager} for accessing the system update
manager service.
@see #getSystemService(String)
@hide
*/
SYSTEM_UPDATE_SERVICE : "system_update",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.view.WindowManager} for accessing the system's window
manager.
@see #getSystemService(String)
@see android.view.WindowManager
*/
WINDOW_SERVICE : "window",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.view.LayoutInflater} for inflating layout resources in this
context.
@see #getSystemService(String)
@see android.view.LayoutInflater
*/
LAYOUT_INFLATER_SERVICE : "layout_inflater",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.accounts.AccountManager} for receiving intents at a
time of your choosing.
@see #getSystemService(String)
@see android.accounts.AccountManager
*/
ACCOUNT_SERVICE : "account",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.ActivityManager} for interacting with the global
system state.
@see #getSystemService(String)
@see android.app.ActivityManager
*/
ACTIVITY_SERVICE : "activity",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.ActivityTaskManager} for interacting with the global system state.
@see #getSystemService(String)
@see android.app.ActivityTaskManager
@hide
*/
ACTIVITY_TASK_SERVICE : "activity_task",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.UriGrantsManager} for interacting with the global system state.
@see #getSystemService(String)
@see android.app.UriGrantsManager
@hide
*/
URI_GRANTS_SERVICE : "uri_grants",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.AlarmManager} for receiving intents at a
time of your choosing.
@see #getSystemService(String)
@see android.app.AlarmManager
*/
ALARM_SERVICE : "alarm",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.NotificationManager} for informing the user of
background events.
@see #getSystemService(String)
@see android.app.NotificationManager
*/
NOTIFICATION_SERVICE : "notification",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.view.accessibility.AccessibilityManager} for giving the user
feedback for UI events through the registered event listeners.
@see #getSystemService(String)
@see android.view.accessibility.AccessibilityManager
*/
ACCESSIBILITY_SERVICE : "accessibility",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.view.accessibility.CaptioningManager} for obtaining
captioning properties and listening for changes in captioning
preferences.
@see #getSystemService(String)
@see android.view.accessibility.CaptioningManager
*/
CAPTIONING_SERVICE : "captioning",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.KeyguardManager} for controlling keyguard.
@see #getSystemService(String)
@see android.app.KeyguardManager
*/
KEYGUARD_SERVICE : "keyguard",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.location.LocationManager} for controlling location
updates.
@see #getSystemService(String)
@see android.location.LocationManager
*/
LOCATION_SERVICE : "location",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.location.CountryDetector} for detecting the country that
the user is in.
@hide
*/
COUNTRY_DETECTOR : "country_detector",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.app.SearchManager} for handling searches.
<p>
{@link Configuration#UI_MODE_TYPE_WATCH} does not support
{@link android.app.SearchManager}.
@see #getSystemService
@see android.app.SearchManager
*/
SEARCH_SERVICE : "search",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.hardware.SensorManager} for accessing sensors.
@see #getSystemService(String)
@see android.hardware.SensorManager
*/
SENSOR_SERVICE : "sensor",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.hardware.SensorPrivacyManager} for accessing sensor privacy
functions.
@see #getSystemService(String)
@see android.hardware.SensorPrivacyManager
@hide
*/
SENSOR_PRIVACY_SERVICE : "sensor_privacy",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.os.storage.StorageManager} for accessing system storage
functions.
@see #getSystemService(String)
@see android.os.storage.StorageManager
*/
STORAGE_SERVICE : "storage",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.app.usage.StorageStatsManager} for accessing system storage
statistics.
@see #getSystemService(String)
@see android.app.usage.StorageStatsManager
*/
STORAGE_STATS_SERVICE : "storagestats",
/** Use with {@link #getSystemService}(String) to retrieve a
com.android.server.WallpaperService for accessing wallpapers.
@see #getSystemService(String)
*/
WALLPAPER_SERVICE : "wallpaper",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.os.Vibrator} for interacting with the vibration hardware.
@see #getSystemService(String)
@see android.os.Vibrator
*/
VIBRATOR_SERVICE : "vibrator",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.app.StatusBarManager} for interacting with the status bar.
@see #getSystemService(String)
@see android.app.StatusBarManager
@hide
*/
STATUS_BAR_SERVICE : "statusbar",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.ConnectivityManager} for handling management of
network connections.
@see #getSystemService(String)
@see android.net.ConnectivityManager
*/
CONNECTIVITY_SERVICE : "connectivity",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.net.INetd} for communicating with the network stack
@hide
@see #getSystemService(String)
@hide
*/
NETD_SERVICE : "netd",
/** Use with {@link android.os.ServiceManager.getService()} to retrieve a
{@link NetworkStackClient} IBinder for communicating with the network stack
@hide
@see NetworkStackClient
*/
NETWORK_STACK_SERVICE : "network_stack",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.net.IpSecManager} for encrypting Sockets or Networks with
IPSec.
@see #getSystemService(String)
*/
IPSEC_SERVICE : "ipsec",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.TestNetworkManager} for building TUNs and limited-use Networks
@see #getSystemService(String)
@hide
*/
TEST_NETWORK_SERVICE : "test_network",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.os.IUpdateLock} for managing runtime sequences that
must not be interrupted by headless OTA application or similar.
@hide
@see #getSystemService(String)
@see android.os.UpdateLock
*/
UPDATE_LOCK_SERVICE : "updatelock",
/** Constant for the internal network management service, not really a Context service.
@hide
*/
NETWORKMANAGEMENT_SERVICE : "network_management",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link com.android.server.slice.SliceManagerService} for managing slices.
@hide
@see #getSystemService(String)
*/
SLICE_SERVICE : "slice",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.app.usage.NetworkStatsManager} for querying network usage stats.
@see #getSystemService(String)
@see android.app.usage.NetworkStatsManager
*/
NETWORK_STATS_SERVICE : "netstats",
/**{@hide} */
NETWORK_POLICY_SERVICE : "netpolicy",
/**{@hide} */
NETWORK_WATCHLIST_SERVICE : "network_watchlist",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.wifi.WifiManager} for handling management of
Wi-Fi access.
@see #getSystemService(String)
@see android.net.wifi.WifiManager
*/
WIFI_SERVICE : "wifi",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.wifi.p2p.WifiP2pManager} for handling management of
Wi-Fi peer-to-peer connections.
@see #getSystemService(String)
@see android.net.wifi.p2p.WifiP2pManager
*/
WIFI_P2P_SERVICE : "wifip2p",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.net.wifi.aware.WifiAwareManager} for handling management of
Wi-Fi Aware.
@see #getSystemService(String)
@see android.net.wifi.aware.WifiAwareManager
*/
WIFI_AWARE_SERVICE : "wifiaware",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.wifi.WifiScanner} for scanning the wifi universe
@see #getSystemService(String)
@see android.net.wifi.WifiScanner
@hide
*/
WIFI_SCANNING_SERVICE : "wifiscanner",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.wifi.RttManager} for ranging devices with wifi
@see #getSystemService(String)
@see android.net.wifi.RttManager
@hide
*/
WIFI_RTT_SERVICE : "rttmanager",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.wifi.rtt.WifiRttManager} for ranging devices with wifi.
@see #getSystemService(String)
@see android.net.wifi.rtt.WifiRttManager
*/
WIFI_RTT_RANGING_SERVICE : "wifirtt",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.lowpan.LowpanManager} for handling management of
LoWPAN access.
@see #getSystemService(String)
@see android.net.lowpan.LowpanManager
@hide
*/
LOWPAN_SERVICE : "lowpan",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.EthernetManager} for handling management of
Ethernet access.
@see #getSystemService(String)
@see android.net.EthernetManager
@hide
*/
ETHERNET_SERVICE : "ethernet",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.net.nsd.NsdManager} for handling management of network service
discovery
@see #getSystemService(String)
@see android.net.nsd.NsdManager
*/
NSD_SERVICE : "servicediscovery",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.media.AudioManager} for handling management of volume,
ringer modes and audio routing.
@see #getSystemService(String)
@see android.media.AudioManager
*/
AUDIO_SERVICE : "audio",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.fingerprint.FingerprintManager} for handling management
of fingerprints.
@see #getSystemService(String)
@see android.hardware.fingerprint.FingerprintManager
*/
FINGERPRINT_SERVICE : "fingerprint",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.face.FaceManager} for handling management
of face authentication.
@hide
@see #getSystemService
@see android.hardware.face.FaceManager
*/
FACE_SERVICE : "face",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.iris.IrisManager} for handling management
of iris authentication.
@hide
@see #getSystemService
@see android.hardware.iris.IrisManager
*/
IRIS_SERVICE : "iris",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.biometrics.BiometricManager} for handling management
of face authentication.
@see #getSystemService
@see android.hardware.biometrics.BiometricManager
*/
BIOMETRIC_SERVICE : "biometric",
/** Use with {@link #getSystemService} to retrieve a
{@link android.media.MediaRouter} for controlling and managing
routing of media.
@see #getSystemService(String)
@see android.media.MediaRouter
*/
MEDIA_ROUTER_SERVICE : "media_router",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.media.session.MediaSessionManager} for managing media Sessions.
@see #getSystemService(String)
@see android.media.session.MediaSessionManager
*/
MEDIA_SESSION_SERVICE : "media_session",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.telephony.TelephonyManager} for handling management the
telephony features of the device.
@see #getSystemService(String)
@see android.telephony.TelephonyManager
*/
TELEPHONY_SERVICE : "phone",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.telephony.SubscriptionManager} for handling management the
telephony subscriptions of the device.
@see #getSystemService(String)
@see android.telephony.SubscriptionManager
*/
TELEPHONY_SUBSCRIPTION_SERVICE : "telephony_subscription_service",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.telecom.TelecomManager} to manage telecom-related features
of the device.
@see #getSystemService(String)
@see android.telecom.TelecomManager
*/
TELECOM_SERVICE : "telecom",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.telephony.CarrierConfigManager} for reading carrier configuration values.
@see #getSystemService(String)
@see android.telephony.CarrierConfigManager
*/
CARRIER_CONFIG_SERVICE : "carrier_config",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.telephony.euicc.EuiccManager} to manage the device eUICC (embedded SIM).
@see #getSystemService(String)
@see android.telephony.euicc.EuiccManager
*/
EUICC_SERVICE : "euicc",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.telephony.euicc.EuiccCardManager} to access the device eUICC (embedded SIM).
@see #getSystemService(String)
@see android.telephony.euicc.EuiccCardManager
@hide
*/
EUICC_CARD_SERVICE : "euicc_card",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.content.ClipboardManager} for accessing and modifying
the contents of the global clipboard.
@see #getSystemService(String)
@see android.content.ClipboardManager
*/
CLIPBOARD_SERVICE : "clipboard",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link TextClassificationManager} for text classification services.
@see #getSystemService(String)
@see TextClassificationManager
*/
TEXT_CLASSIFICATION_SERVICE : "textclassification",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link com.android.server.attention.AttentionManagerService} for attention services.
@see #getSystemService(String)
@see android.server.attention.AttentionManagerService
@hide
*/
ATTENTION_SERVICE : "attention",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.view.inputmethod.InputMethodManager} for accessing input
methods.
@see #getSystemService(String)
*/
INPUT_METHOD_SERVICE : "input_method",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.view.textservice.TextServicesManager} for accessing
text services.
@see #getSystemService(String)
*/
TEXT_SERVICES_MANAGER_SERVICE : "textservices",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.appwidget.AppWidgetManager} for accessing AppWidgets.
@see #getSystemService(String)
*/
APPWIDGET_SERVICE : "appwidget",
/** Official published name of the (internal) voice interaction manager service.
@hide
@see #getSystemService(String)
*/
VOICE_INTERACTION_MANAGER_SERVICE : "voiceinteraction",
/** Official published name of the (internal) autofill service.
@hide
@see #getSystemService(String)
*/
AUTOFILL_MANAGER_SERVICE : "autofill",
/** Official published name of the content capture service.
@hide
@see #getSystemService(String)
*/
CONTENT_CAPTURE_MANAGER_SERVICE : "content_capture",
/** Used for getting content selections and classifications for task snapshots.
@hide
@see #getSystemService(String)
*/
CONTENT_SUGGESTIONS_SERVICE : "content_suggestions",
/** Official published name of the app prediction service.
@hide
@see #getSystemService(String)
*/
APP_PREDICTION_SERVICE : "app_prediction",
/** Use with {@link #getSystemService}(String) to access the
{@link com.android.server.voiceinteraction.SoundTriggerService}.
@hide
@see #getSystemService(String)
*/
SOUND_TRIGGER_SERVICE : "soundtrigger",
/** Official published name of the (internal) permission service.
@see #getSystemService(String)
@hide
*/
PERMISSION_SERVICE : "permission",
/** Official published name of the (internal) permission controller service.
@see #getSystemService(String)
@hide
*/
PERMISSION_CONTROLLER_SERVICE : "permission_controller",
/** Use with {@link #getSystemService}(String) to retrieve an
{@link android.app.backup.IBackupManager IBackupManager} for communicating
with the backup mechanism.
@hide
@see #getSystemService(String)
*/
BACKUP_SERVICE : "backup",
/** Use with {@link #getSystemService}(String) to retrieve an
{@link android.content.rollback.RollbackManager} for communicating
with the rollback manager
@see #getSystemService(String)
@hide
*/
ROLLBACK_SERVICE : "rollback",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.os.DropBoxManager} instance for recording
diagnostic logs.
@see #getSystemService(String)
*/
DROPBOX_SERVICE : "dropbox",
/** System service name for the DeviceIdleManager.
@see #getSystemService(String)
@hide
*/
DEVICE_IDLE_CONTROLLER : "deviceidle",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.admin.DevicePolicyManager} for working with global
device policy management.
@see #getSystemService(String)
*/
DEVICE_POLICY_SERVICE : "device_policy",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.UiModeManager} for controlling UI modes.
@see #getSystemService(String)
*/
UI_MODE_SERVICE : "uimode",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.DownloadManager} for requesting HTTP downloads.
@see #getSystemService(String)
*/
DOWNLOAD_SERVICE : "download",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.os.BatteryManager} for managing battery state.
@see #getSystemService(String)
*/
BATTERY_SERVICE : "batterymanager",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.nfc.NfcManager} for using NFC.
@see #getSystemService(String)
*/
NFC_SERVICE : "nfc",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.bluetooth.BluetoothManager} for using Bluetooth.
@see #getSystemService(String)
*/
BLUETOOTH_SERVICE : "bluetooth",
/**@hide */
SIP_SERVICE : "sip",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.hardware.usb.UsbManager} for access to USB devices (as a USB host)
and for controlling this device's behavior as a USB device.
@see #getSystemService(String)
@see android.hardware.usb.UsbManager
*/
USB_SERVICE : "usb",
/** Use with {@link #getSystemService}(String) to retrieve a {@link Use with {@link #getSystemService} to retrieve a {@link android.debug.AdbManager} for access to ADB debug functions.
@see #getSystemService(String)
@see android.debug.AdbManager
@hide
*/
ADB_SERVICE : "adb",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.hardware.SerialManager} for access to serial ports.
@see #getSystemService(String)
@see android.hardware.SerialManager
@hide
*/
SERIAL_SERVICE : "serial",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.hdmi.HdmiControlManager} for controlling and managing
HDMI-CEC protocol.
@see #getSystemService(String)
@see android.hardware.hdmi.HdmiControlManager
@hide
*/
HDMI_CONTROL_SERVICE : "hdmi_control",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.input.InputManager} for interacting with input devices.
@see #getSystemService(String)
@see android.hardware.input.InputManager
*/
INPUT_SERVICE : "input",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.display.DisplayManager} for interacting with display devices.
@see #getSystemService(String)
@see android.hardware.display.DisplayManager
*/
DISPLAY_SERVICE : "display",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.display.ColorDisplayManager} for controlling color transforms.
@see #getSystemService(String)
@see android.hardware.display.ColorDisplayManager
@hide
*/
COLOR_DISPLAY_SERVICE : "color_display",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.os.UserManager} for managing users on devices that support multiple users.
@see #getSystemService(String)
@see android.os.UserManager
*/
USER_SERVICE : "user",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.content.pm.LauncherApps} for querying and monitoring launchable apps across
profiles of a user.
@see #getSystemService(String)
@see android.content.pm.LauncherApps
*/
LAUNCHER_APPS_SERVICE : "launcherapps",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.content.RestrictionsManager} for retrieving application restrictions
and requesting permissions for restricted operations.
@see #getSystemService(String)
@see android.content.RestrictionsManager
*/
RESTRICTIONS_SERVICE : "restrictions",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.app.AppOpsManager} for tracking application operations
on the device.
@see #getSystemService(String)
@see android.app.AppOpsManager
*/
APP_OPS_SERVICE : "appops",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.app.role.RoleManager}
for managing roles.
@see #getSystemService(String)
@see android.app.role.RoleManager
*/
ROLE_SERVICE : "role",
/** Official published name of the (internal) role controller service.
@see #getSystemService(String)
@see android.app.role.RoleControllerService
@hide
*/
ROLE_CONTROLLER_SERVICE : "role_controller",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.camera2.CameraManager} for interacting with
camera devices.
@see #getSystemService(String)
@see android.hardware.camera2.CameraManager
*/
CAMERA_SERVICE : "camera",
/** {@link android.print.PrintManager} for printing and managing
printers and print tasks.
@see #getSystemService(String)
@see android.print.PrintManager
*/
PRINT_SERVICE : "print",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.companion.CompanionDeviceManager} for managing companion devices
@see #getSystemService(String)
@see android.companion.CompanionDeviceManager
*/
COMPANION_DEVICE_SERVICE : "companiondevice",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.ConsumerIrManager} for transmitting infrared
signals from the device.
@see #getSystemService(String)
@see android.hardware.ConsumerIrManager
*/
CONSUMER_IR_SERVICE : "consumer_ir",
/** {@link android.app.trust.TrustManager} for managing trust agents.
@see #getSystemService(String)
@see android.app.trust.TrustManager
@hide
*/
TRUST_SERVICE : "trust",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.media.tv.TvInputManager} for interacting with TV inputs
on the device.
@see #getSystemService(String)
@see android.media.tv.TvInputManager
*/
TV_INPUT_SERVICE : "tv_input",
/** {@link android.net.NetworkScoreManager} for managing network scoring.
@see #getSystemService(String)
@see android.net.NetworkScoreManager
@hide
*/
NETWORK_SCORE_SERVICE : "network_score",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.app.usage.UsageStatsManager} for querying device usage stats.
@see #getSystemService(String)
@see android.app.usage.UsageStatsManager
*/
USAGE_STATS_SERVICE : "usagestats",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.app.job.JobScheduler} instance for managing occasional
background tasks.
@see #getSystemService(String)
@see android.app.job.JobScheduler
*/
JOB_SCHEDULER_SERVICE : "jobscheduler",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.service.persistentdata.PersistentDataBlockManager} instance
for interacting with a storage device that lives across factory resets.
@see #getSystemService(String)
@see android.service.persistentdata.PersistentDataBlockManager
@hide
*/
PERSISTENT_DATA_BLOCK_SERVICE : "persistent_data_block",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.service.oemlock.OemLockManager} instance for managing the OEM lock.
@see #getSystemService(String)
@see android.service.oemlock.OemLockManager
@hide
*/
OEM_LOCK_SERVICE : "oem_lock",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.media.projection.MediaProjectionManager} instance for managing
media projection sessions.
@see #getSystemService(String)
@see android.media.projection.MediaProjectionManager
*/
MEDIA_PROJECTION_SERVICE : "media_projection",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.media.midi.MidiManager} for accessing the MIDI service.
@see #getSystemService(String)
*/
MIDI_SERVICE : "midi",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.hardware.radio.RadioManager} for accessing the broadcast radio service.
@see #getSystemService(String)
@hide
*/
RADIO_SERVICE : "broadcastradio",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.os.HardwarePropertiesManager} for accessing the hardware properties service.
@see #getSystemService(String)
*/
HARDWARE_PROPERTIES_SERVICE : "hardware_properties",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.os.ThermalService} for accessing the thermal service.
@see #getSystemService(String)
@hide
*/
THERMAL_SERVICE : "thermalservice",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.content.pm.ShortcutManager} for accessing the launcher shortcut service.
@see #getSystemService(String)
@see android.content.pm.ShortcutManager
*/
SHORTCUT_SERVICE : "shortcut",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.hardware.location.ContextHubManager} for accessing context hubs.
@see #getSystemService(String)
@see android.hardware.location.ContextHubManager
@hide
*/
CONTEXTHUB_SERVICE : "contexthub",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.os.health.SystemHealthManager} for accessing system health (battery, power,
memory, etc) metrics.
@see #getSystemService(String)
*/
SYSTEM_HEALTH_SERVICE : "systemhealth",
/** Gatekeeper Service.
@hide
*/
GATEKEEPER_SERVICE : "android.service.gatekeeper.IGateKeeperService",
/** Service defining the policy for access to device identifiers.
@hide
*/
DEVICE_IDENTIFIERS_SERVICE : "device_identifiers",
/** Service to report a system health "incident"
@hide
*/
INCIDENT_SERVICE : "incident",
/** Service to assist incidentd and dumpstated in reporting status to the user
and in confirming authorization to take an incident report or bugreport
@hide
*/
INCIDENT_COMPANION_SERVICE : "incidentcompanion",
/** Service to assist statsd in obtaining general stats.
@hide
*/
STATS_COMPANION_SERVICE : "statscompanion",
/** Use with {@link #getSystemService}(String) to retrieve an {@link android.app.StatsManager}.
@hide
*/
STATS_MANAGER : "stats",
/** Service to capture a bugreport.
@see #getSystemService(String)
@see android.os.BugreportManager
@hide
*/
BUGREPORT_SERVICE : "bugreport",
/** Use with {@link #getSystemService}(String) to retrieve a {@link android.content.om.OverlayManager} for managing overlay packages.
@see #getSystemService(String)
@see android.content.om.OverlayManager
@hide
*/
OVERLAY_SERVICE : "overlay",
/** Use with {@link #getSystemService}(String) to retrieve a
{android.os.IIdmap2} for managing idmap files (used by overlay
packages).
@see #getSystemService(String)
@hide
*/
IDMAP_SERVICE : "idmap",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link VrManager} for accessing the VR service.
@see #getSystemService(String)
@hide
*/
VR_SERVICE : "vrmanager",
/** Use with {@link #getSystemService}(String) to retrieve an
{@link android.app.timezone.ITimeZoneRulesManager}.
@hide
@see #getSystemService(String)
*/
TIME_ZONE_RULES_MANAGER_SERVICE : "timezone",
/** Use with {@link #getSystemService}(String) to retrieve a
{@link android.content.pm.CrossProfileApps} for cross profile operations.
@see #getSystemService(String)
*/
CROSS_PROFILE_APPS_SERVICE : "crossprofileapps",
/** Use with {@link #getSystemService} to retrieve a
{@link android.se.omapi.ISecureElementService}
for accessing the SecureElementService.
@hide
*/
SECURE_ELEMENT_SERVICE : "secure_element",
/** Use with {@link #getSystemService}(String) to retrieve an
{@link android.app.timedetector.ITimeDetectorService}.
@hide
@see #getSystemService(String)
*/
TIME_DETECTOR_SERVICE : "time_detector",
/** Binder service name for {@link AppBindingService}.
@hide
*/
APP_BINDING_SERVICE : "app_binding",
/** Use with {@link #getSystemService}(String) to retrieve an
{@link android.telephony.ims.RcsManager}.
@hide
*/
TELEPHONY_RCS_SERVICE : "ircs",
/** Use with {@link #getSystemService}(String) to retrieve an
{@link android.os.image.DynamicSystemManager}.
@hide
*/
DYNAMIC_SYSTEM_SERVICE : "dynamic_system",
/** Flag for use with {@link #createPackageContext}: include the application
code with the context. This means loading code into the caller's
process, so that {@link #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 {@link #getClassLoader} will always return the default system
class loader.
*/
CONTEXT_INCLUDE_CODE : "1",
/** Flag for use with {@link #createPackageContext}: ignore any security
restrictions on the Context being requested, allowing it to always
be loaded. For use with {@link #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!
*/
CONTEXT_IGNORE_SECURITY : "2",
/** Flag for use with {@link #createPackageContext}: a restricted context may
disable specific features. For instance, a View associated with a restricted
context would ignore particular XML attributes.
*/
CONTEXT_RESTRICTED : "4",
/** Flag for use with {@link #createPackageContext}: point all file APIs at
device-protected storage.
@hide
*/
CONTEXT_DEVICE_PROTECTED_STORAGE : "8",
/** Flag for use with {@link #createPackageContext}: point all file APIs at
credential-protected storage.
@hide
*/
CONTEXT_CREDENTIAL_PROTECTED_STORAGE : "16",
/** @hide Used to indicate we should tell the activity manager about the process
loading this code.
*/
CONTEXT_REGISTER_PACKAGE : "1073741824",
/**Returns an AssetManager instance for the application's package.
<p>
<strong>Note:</strong> Implementations of this method should return
an AssetManager instance that is consistent with the Resources instance
returned by {@link #getResources}(). For example, they should share the
same {@link Configuration} object.
@return {Object {android.content.res.AssetManager}} an AssetManager instance for the application's package
@see #getResources()
*/
getAssets : function( ) {},
/**Returns a Resources instance for the application's package.
<p>
<strong>Note:</strong> Implementations of this method should return
a Resources instance that is consistent with the AssetManager instance
returned by {@link #getAssets}(). For example, they should share the
same {@link Configuration} object.
@return {Object {android.content.res.Resources}} a Resources instance for the application's package
@see #getAssets()
*/
getResources : function( ) {},
/**Return PackageManager instance to find global package information.
*/
getPackageManager : function( ) {},
/**Return a ContentResolver instance for your application's package.
*/
getContentResolver : function( ) {},
/**Return the Looper for the main thread of the current process. This is
the thread used to dispatch calls to application components (activities,
services, etc).
<p>
By definition, this method returns the same result as would be obtained
by calling {@link Looper#getMainLooper() Looper.getMainLooper()}.
</p>
@return {Object {android.os.Looper}} The main looper.
*/
getMainLooper : function( ) {},
/**Return an {@link Executor} that will run enqueued tasks on the main
thread associated with this context. This is the thread used to dispatch
calls to application components (activities, services, etc).
*/
getMainExecutor : function( ) {},
/**Return the context of the single, global Application object of the
current process. This generally should only be used if you need a
Context whose lifecycle is separate from the current context, that is
tied to the lifetime of the process rather than the current component.
<p>Consider for example how this interacts with
{@link #registerReceiver(BroadcastReceiver, android.content.IntentFilter)}:
<ul>
<li> <p>If used from an Activity context, the receiver is being registered
within that activity. This means that you are expected to unregister
before the activity is done being destroyed; in fact if you do not do
so, the framework will clean up your leaked registration as it removes
the activity and log an error. Thus, if you use the Activity context
to register a receiver that is static (global to the process, not
associated with an Activity instance) then that registration will be
removed on you at whatever point the activity you used is destroyed.
<li> <p>If used from the Context returned here, the receiver is being
registered with the global state associated with your application. Thus
it will never be unregistered for you. This is necessary if the receiver
is associated with static data, not a particular component. However
using the ApplicationContext elsewhere can easily lead to serious leaks
if you forget to unregister, unbind, etc.
</ul>
*/
getApplicationContext : function( ) {},
/**Gets the next autofill ID.
<p>All IDs will be smaller or the same as {@link View#LAST_APP_AUTOFILL_ID}. All IDs
returned will be unique.
@return {Number} A ID that is unique in the process
{@hide}
*/
getNextAutofillId : function( ) {},
/**Add a new {@link android.content.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
<em>must</em> be sure to use {@link #unregisterComponentCallbacks} when
appropriate in the future; this will not be removed for you.
@param {Object {ComponentCallbacks}} callback The interface to call. This can be either a
{@link ComponentCallbacks} or {@link ComponentCallbacks2} interface.
*/
registerComponentCallbacks : function( ) {},
/**Remove a {@link android.content.ComponentCallbacks} object that was previously registered
with {@link #registerComponentCallbacks}(ComponentCallbacks).
*/
unregisterComponentCallbacks : function( ) {},
/**Return a localized, styled CharSequence from the application's package's
default string table.
@param {Number} resId Resource id for the CharSequence text
*/
getText : function( ) {},
/**Returns a localized string from the application's package's
default string table.
@param {Number} resId Resource id for the string
@return {String} The string data associated with the resource, stripped of styled
text information.
*/
getString : function( ) {},
/**Returns a localized formatted string from the application's package's
default string table, substituting the format arguments as defined in
{@link java.util.Formatter} and {@link java.lang.String#format}.
@param {Number} resId Resource id for the format string
@param {Object {java.lang.Object[]}} formatArgs The format arguments that will be used for
substitution.
@return {String} The string data associated with the resource, formatted and
stripped of styled text information.
*/
getString : function( ) {},
/**Returns a color associated with a particular resource ID and styled for
the current theme.
@param {Number} id The desired resource identifier, as generated by the aapt
tool. This integer encodes the package, type, and resource
entry. The value 0 is an invalid identifier.
@return {Number} A single color value in the form 0xAARRGGBB.
@throws android.content.res.Resources.NotFoundException if the given ID
does not exist.
*/
getColor : function( ) {},
/**Returns a drawable object associated with a particular resource ID and
styled for the current theme.
@param {Number} id The desired resource identifier, as generated by the aapt
tool. This integer encodes the package, type, and resource
entry. The value 0 is an invalid identifier.
@return {Object {android.graphics.drawable.Drawable}} An object that can be used to draw this resource.
@throws android.content.res.Resources.NotFoundException if the given ID
does not exist.
*/
getDrawable : function( ) {},
/**Returns a color state list associated with a particular resource ID and
styled for the current theme.
@param {Number} id The desired resource identifier, as generated by the aapt
tool. This integer encodes the package, type, and resource
entry. The value 0 is an invalid identifier.
@return {Object {android.content.res.ColorStateList}} A color state list.
@throws android.content.res.Resources.NotFoundException if the given ID
does not exist.
*/
getColorStateList : function( ) {},
/**Set the base theme for this context. Note that this should be called
before any views are instantiated in the Context (for example before
calling {@link android.app.Activity#setContentView} or
{@link android.view.LayoutInflater#inflate}).
@param {Number} resid The style resource describing the theme.
*/
setTheme : function( ) {},
/**
@hide Needed for some internal implementation... not public because
you can't assume this actually means anything.
*/
getThemeResId : function( ) {},
/**Return the Theme object associated with this Context.
*/
getTheme : function( ) {},
/**Retrieve styled attribute information in this Context's theme. See
{@link android.content.res.Resources.Theme#obtainStyledAttributes(int[])}
for more information.
@see android.content.res.Resources.Theme#obtainStyledAttributes(int[])
*/
obtainStyledAttributes : function( ) {},
/**Retrieve styled attribute information in this Context's theme. See
{@link android.content.res.Resources.Theme#obtainStyledAttributes(int, int[])}
for more information.
@see android.content.res.Resources.Theme#obtainStyledAttributes(int, int[])
*/
obtainStyledAttributes : function( ) {},
/**Retrieve styled attribute information in this Context's theme. See
{@link android.content.res.Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)}
for more information.
@see android.content.res.Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)
*/
obtainStyledAttributes : function( ) {},
/**Retrieve styled attribute information in this Context's theme. See
{@link android.content.res.Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)}
for more information.
@see android.content.res.Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)
*/
obtainStyledAttributes : function( ) {},
/**Return a class loader you can use to retrieve classes in this package.
*/
getClassLoader : function( ) {},
/**Return the name of this application's package.
*/
getPackageName : function( ) {},
/**
@hide Return the name of the base context this context is derived from.
This is the same as {@link #getOpPackageName()} except in
cases where system components are loaded into other app processes, in which
case {@link #getOpPackageName()} will be the name of the primary package in
that process (so that app ops uid verification will work with the name).
*/
getBasePackageName : function( ) {},
/**Return the package name that should be used for {@link android.app.AppOpsManager} calls from
this context, so that app ops manager's uid verification will work with the name.
<p>
This is not generally intended for third party application developers.
*/
getOpPackageName : function( ) {},
/**Return the full application info for this context's package.
*/
getApplicationInfo : function( ) {},
/**Return the full path to this context's primary Android package.
The Android package is a ZIP file which contains the application's
primary resources.
<p>Note: this is not generally useful for applications, since they should
not be directly accessing the file system.
@return {String} String Path to the resources.
*/
getPackageResourcePath : function( ) {},
/**Return the full path to this context's primary Android package.
The Android package is a ZIP file which contains application's
primary code and assets.
<p>Note: this is not generally useful for applications, since they should
not be directly accessing the file system.
@return {String} String Path to the code and assets.
*/
getPackageCodePath : function( ) {},
/**
@hide
@deprecated use {@link #getSharedPreferencesPath(String)}
*/
getSharedPrefsFile : function( ) {},
/**Retrieve and hold the contents of the preferences file 'name', returning
a SharedPreferences through which you can retrieve and modify its
values. Only one instance of the SharedPreferences object is returned
to any callers for the same name, meaning they will see each other's
edits as soon as they are made.
This method is thead-safe.
@param {String} name Desired preferences file. If a preferences file by this name
does not exist, it will be created when you retrieve an
editor (SharedPreferences.edit()) and then commit changes (Editor.commit()).
@param {Number} mode Operating mode.
@return {Object {android.content.SharedPreferences}} The single {@link SharedPreferences} instance that can be used
to retrieve and modify the preference values.
@see #MODE_PRIVATE
*/
getSharedPreferences : function( ) {},
/**Retrieve and hold the contents of the preferences file, returning
a SharedPreferences through which you can retrieve and modify its
values. Only one instance of the SharedPreferences object is returned
to any callers for the same name, meaning they will see each other's
edits as soon as they are made.
@param {Object {File}} file Desired preferences file. If a preferences file by this name
does not exist, it will be created when you retrieve an
editor (SharedPreferences.edit()) and then commit changes (Editor.commit()).
@param {Number} mode Operating mode.
@return {Object {android.content.SharedPreferences}} The single {@link SharedPreferences} instance that can be used
to retrieve and modify the preference values.
@see #getSharedPreferencesPath(String)
@see #MODE_PRIVATE
@removed
*/
getSharedPreferences : function( ) {},
/**Move an existing shared preferences file from the given source storage
context to this context. This is typically used to migrate data between
storage locations after an upgrade, such as moving to device protected
storage.
@param {Object {Context}} sourceContext The source context which contains the existing
shared preferences to move.
@param {String} name The name of the shared preferences file.
@return {Boolean} {@code true} if the move was successful or if the shared
preferences didn't exist in the source context, otherwise
{@code false}.
@see #createDeviceProtectedStorageContext()
*/
moveSharedPreferencesFrom : function( ) {},
/**Delete an existing shared preferences file.
@param {String} name The name (unique in the application package) of the shared
preferences file.
@return {Boolean} {@code true} if the shared preferences file was successfully
deleted; else {@code false}.
@see #getSharedPreferences(String, int)
*/
deleteSharedPreferences : function( ) {},
/**
@hide
*/
reloadSharedPreferences : function( ) {},
/**Open a private file associated with this Context's application package
for reading.
@param {String} name The name of the file to open; can not contain path
separators.
@return {Object {java.io.FileInputStream}} The resulting {@link FileInputStream}.
@see #openFileOutput
@see #fileList
@see #deleteFile
@see java.io.FileInputStream#FileInputStream(String)
*/
openFileInput : function( ) {},
/**Open a private file associated with this Context's application package
for writing. Creates the file if it doesn't already exist.
<p>
No additional permissions are required for the calling app to read or
write the returned file.
@param {String} name The name of the file to open; can not contain path
separators.
@param {Number} mode Operating mode.
@return {Object {java.io.FileOutputStream}} The resulting {@link FileOutputStream}.
@see #MODE_APPEND
@see #MODE_PRIVATE
@see #openFileInput
@see #fileList
@see #deleteFile
@see java.io.FileOutputStream#FileOutputStream(String)
*/
openFileOutput : function( ) {},
/**Delete the given private file associated with this Context's
application package.
@param {String} name The name of the file to delete; can not contain path
separators.
@return {Boolean} {@code true} if the file was successfully deleted; else
{@code false}.
@see #openFileInput
@see #openFileOutput
@see #fileList
@see java.io.File#delete()
*/
deleteFile : function( ) {},
/**Returns the absolute path on the filesystem where a file created with
{@link #openFileOutput} is stored.
<p>
The returned path may change over time if the calling app is moved to an
adopted storage device, so only relative paths should be persisted.
@param {String} name The name of the file for which you would like to get
its path.
@return {Object {java.io.File}} An absolute path to the given file.
@see #openFileOutput
@see #getFilesDir
@see #getDir
*/
getFileStreamPath : function( ) {},
/**Returns the absolute path on the filesystem where a file created with
{@link #getSharedPreferences(String, int)} is stored.
<p>
The returned path may change over time if the calling app is moved to an
adopted storage device, so only relative paths should be persisted.
@param {String} name The name of the shared preferences for which you would like
to get a path.
@return {Object {java.io.File}} An absolute path to the given file.
@see #getSharedPreferences(String, int)
@removed
*/
getSharedPreferencesPath : function( ) {},
/**Returns the absolute path to the directory on the filesystem where all
private files belonging to this app are stored. Apps should not use this
path directly; they should instead use {@link #getFilesDir}(),
{@link #getCacheDir}(), {@link #getDir(String, int)}, or other storage
APIs on this class.
<p>
The returned path may change over time if the calling app is moved to an
adopted storage device, so only relative paths should be persisted.
<p>
No additional permissions are required for the calling app to read or
write files under the returned path.
@see ApplicationInfo#dataDir
*/
getDataDir : function( ) {},
/**Returns the absolute path to the directory on the filesystem where files
created with {@link #openFileOutput} are stored.
<p>
The returned path may change over time if the calling app is moved to an
adopted storage device, so only relative paths should be persisted.
<p>
No additional permissions are required for the calling app to read or
write files under the returned path.
@return {Object {java.io.File}} The path of the directory holding application files.
@see #openFileOutput
@see #getFileStreamPath
@see #getDir
*/
getFilesDir : function( ) {},
/**Returns the absolute path to the directory on the filesystem similar to
{@link #getFilesDir}(). The difference is that files placed under this
directory will be excluded from automatic backup to remote storage. See
{@link android.app.backup.BackupAgent BackupAgent} for a full discussion
of the automatic backup mechanism in Android.
<p>
The returned path may change over time if the calling app is moved to an
adopted storage device, so only relative paths should be persisted.
<p>
No additional permissions are required for the calling app to read or
write files under the returned path.
@return {Object {java.io.File}} The path of the directory holding application files that will not
be automatically backed up to remote storage.
@see #openFileOutput
@see #getFileStreamPath
@see #getDir
@see android.app.backup.BackupAgent
*/
getNoBackupFilesDir : function( ) {},
/**Returns the absolute path to the directory on the primary shared/external
storage device where the application can place persistent files it owns.
These files are internal to the applications, and not typically visible
to the user as media.
<p>
This is like {@link #getFilesDir}() in that these files will be deleted
when the application is uninstalled, however there are some important
differences:
<ul>
<li>Shared storage may not always be available, since removable media can
be ejected by the user. Media state can be checked using
{@link Environment#getExternalStorageState(File)}.
<li>There is no security enforced with these files. For example, any
application holding
{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} can write to
these files.
</ul>
<p>
If a shared storage device is emulated (as determined by
{@link Environment#isExternalStorageEmulated(File)}), it's contents are
backed by a private user data partition, which means there is little
benefit to storing data here instead of the private directories returned
by {@link #getFilesDir}(), etc.
<p>
Starting in {@link android.os.Build.VERSION_CODES#KITKAT}, no permissions
are required to read or write to the returned path; it's always
accessible to the calling app. This only applies to paths generated for
package name of the calling application. To access paths belonging to
other packages,
{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} and/or
{@link android.Manifest.permission#READ_EXTERNAL_STORAGE} are required.
<p>
On devices with multiple users (as described by {@link UserManager}),
each user has their own isolated shared storage. Applications only have
access to the shared storage for the user they're running as.
<p>
The returned path may change over time if different shared storage media
is inserted, so only relative paths should be persisted.
<p>
Here is an example of typical code to manipulate a file in an
application's shared storage:
</p>
{@sample development/samples/ApiDemos/src/com/example/android/apis/content/ExternalStorage.java
private_file}
<p>
If you supply a non-null <var>type</var> to this function, the returned
file will be a path to a sub-directory of the given type. Though these
files are not automatically scanned by the media scanner, you can
explicitly add them to the media database with
{@link android.media.MediaScannerConnection#scanFile(Context, String[], String[], android.media.MediaScannerConnection.OnScanCompletedListener)
MediaScannerConnection.scanFile}. Note that this is not the same as
{@link android.os.Environment#getExternalStoragePublicDirectory
Environment.getExternalStoragePublicDirectory()}, which provides
directories of media shared by all applications. The directories returned
here are owned by the application, and their contents will be removed
when the application is uninstalled. Unlike
{@link android.os.Environment#getExternalStoragePublicDirectory
Environment.getExternalStoragePublicDirectory()}, the directory returned
here will be automatically created for you.
<p>
Here is an example of typical code to manipulate a picture in an
application's shared storage and add it to the media database:
</p>
{@sample development/samples/ApiDemos/src/com/example/android/apis/content/ExternalStorage.java
private_picture}
@param {String} type The type of files directory to return. May be {@code null}
for the root of the files directory or one of the following
constants for a subdirectory:
{@link android.os.Environment#DIRECTORY_MUSIC},
{@link android.os.Environment#DIRECTORY_PODCASTS},
{@link android.os.Environment#DIRECTORY_RINGTONES},
{@link android.os.Environment#DIRECTORY_ALARMS},
{@link android.os.Environment#DIRECTORY_NOTIFICATIONS},
{@link android.os.Environment#DIRECTORY_PICTURES}, or
{@link android.os.Environment#DIRECTORY_MOVIES}.
@return {Object {java.io.File}} the absolute path to application-specific directory. May return
{@code null} if shared storage is not currently available.
@see #getFilesDir
@see #getExternalFilesDirs(String)
@see Environment#getExternalStorageState(File)
@see Environment#isExternalStorageEmulated(File)
@see Environment#isExternalStorageRemovable(File)
*/
getExternalFilesDir : function( ) {},
/**Returns absolute paths to application-specific directories on all
shared/external storage devices where the application can place
persistent files it owns. These files are internal to the application,
and not typically visible to the user as media.
<p>
This is like {@link #getFilesDir}() in that these files will be deleted
when the application is uninstalled, however there are some important
differences:
<ul>
<li>Shared storage may not always be available, since removable media can
be ejected by the user. Media state can be checked using
{@link Environment#getExternalStorageState(File)}.
<li>There is no security enforced with these files. For example, any
application holding
{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} can write to
these files.
</ul>
<p>
If a shared storage device is emulated (as determined by
{@link Environment#isExternalStorageEmulated(File)}), it's contents are
backed by a private user data partition, which means there is little
benefit to storing data here instead of the private directories returned
by {@link #getFilesDir}(), etc.
<p>
Shared storage devices returned here are considered a stable part of the
device, including physical media slots under a protective cover. The
returned paths do not include transient devices, such as USB flash drives
connected to handheld devices.
<p>
An application may store data on any or all of the returned devices. For
example, an app may choose to store large files on the device with the
most available space, as measured by {@link StatFs}.
<p>
No additional permissions are required for the calling app to read or
write files under the returned path. Write access outside of these paths
on secondary external storage devices is not available.
<p>
The returned path may change over time if different shared storage media
is inserted, so only relative paths should be persisted.
@param {String} type The type of files directory to return. May be {@code null}
for the root of the files directory or one of the following
constants for a subdirectory:
{@link android.os.Environment#DIRECTORY_MUSIC},
{@link android.os.Environment#DIRECTORY_PODCASTS},
{@link android.os.Environment#DIRECTORY_RINGTONES},
{@link android.os.Environment#DIRECTORY_ALARMS},
{@link android.os.Environment#DIRECTORY_NOTIFICATIONS},
{@link android.os.Environment#DIRECTORY_PICTURES}, or
{@link android.os.Environment#DIRECTORY_MOVIES}.
@return {Object {java.io.File}} the absolute paths to application-specific directories. Some
individual paths may be {@code null} if that shared storage is
not currently available. The first path returned is the same as
{@link #getExternalFilesDir(String)}.
@see #getExternalFilesDir(String)
@see Environment#getExternalStorageState(File)
@see Environment#isExternalStorageEmulated(File)
@see Environment#isExternalStorageRemovable(File)
*/
getExternalFilesDirs : function( ) {},
/**Return the primary shared/external storage directory where this
application's OBB files (if there are any) can be found. Note if the
application does not have any OBB files, this directory may not exist.
<p>
This is like {@link #getFilesDir}() in that these files will be deleted
when the application is uninstalled, however there are some important
differences:
<ul>
<li>Shared storage may not always be available, since removable media can
be ejected by the user. Media state can be checked using
{@link Environment#getExternalStorageState(File)}.
<li>There is no security enforced with these files. For example, any
application holding
{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} can write to
these files.
</ul>
<p>
Starting in {@link android.os.Build.VERSION_CODES#KITKAT}, no permissions
are required to read or write to the path that this method returns.
However, starting from {@link android.os.Build.VERSION_CODES#M},
to read the OBB expansion files, you must declare the
{@link android.Manifest.permission#READ_EXTERNAL_STORAGE} permission in the app manifest and ask for
permission at runtime as follows:
</p>
<p>
{@code <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
android:maxSdkVersion="23" />}
</p>
<p>
Starting from {@link android.os.Build.VERSION_CODES#N},
{@link android.Manifest.permission#READ_EXTERNAL_STORAGE}
permission is not required, so don’t ask for this
permission at runtime. To handle both cases, your app must first try to read the OBB file,
and if it fails, you must request
{@link android.Manifest.permission#READ_EXTERNAL_STORAGE} permission at runtime.
</p>
<p>
The following code snippet shows how to do this:
</p>
<pre>
File obb = new File(obb_filename);
boolean open_failed = false;
try {
BufferedReader br = new BufferedReader(new FileReader(obb));
open_failed = false;
ReadObbFile(br);
} catch (IOException e) {
open_failed = true;
}
if (open_failed) {
// request READ_EXTERNAL_STORAGE permission before reading OBB file
ReadObbFileWithPermission();
}
</pre>
On devices with multiple users (as described by {@link UserManager}),
multiple users may share the same OBB storage location. Applications
should ensure that multiple instances running under different users don't
interfere with each other.
@return {Object {java.io.File}} the absolute path to application-specific directory. May return
{@code null} if shared storage is not currently available.
@see #getObbDirs()
@see Environment#getExternalStorageState(File)
@see Environment#isExternalStorageEmulated(File)
@see Environment#isExternalStorageRemovable(File)
*/
getObbDir : function( ) {},
/**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. Note if the application does not have any
OBB files, these directories may not exist.
<p>
This is like {@link #getFilesDir}() in that these files will be deleted
when the application is uninstalled, however there are some important
differences:
<ul>
<li>Shared storage may not always be available, since removable media can
be ejected by the user. Media state can be checked using
{@link Environment#getExternalStorageState(File)}.
<li>There is no security enforced with these files. For example, any
application holding
{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} can write to
these files.
</ul>
<p>
Shared storage devices returned here are considered a stable part of the
device, including physical media slots under a protective cover. The
returned paths do not include transient devices, such as USB flash drives
connected to handheld devices.
<p>
An application may store data on any or all of the returned devices. For
example, an app may choose to store large files on the device with the
most available space, as measured by {@link StatFs}.
<p>
No additional permissions are required for the calling app to read or
write files under the returned path. Write access outside of these paths
on secondary external storage devices is not available.
@return {Object {java.io.File}} the absolute paths to application-specific directories. Some
individual paths may be {@code null} if that shared storage is
not currently available. The first path returned is the same as
{@link #getObbDir()}
@see #getObbDir()
@see Environment#getExternalStorageState(File)
@see Environment#isExternalStorageEmulated(File)
@see Environment#isExternalStorageRemovable(File)
*/
getObbDirs : function( ) {},
/**Returns the absolute path to the application specific cache directory on
the filesystem.
<p>
The system will automatically delete files in this directory as disk
space is needed elsewhere on the device. The system will always delete
older files first, as reported by {@link File#lastModified()}. If
desired, you can exert more control over how files are deleted using
{@link StorageManager#setCacheBehaviorGroup(File, boolean)} and
{@link StorageManager#setCacheBehaviorTombstone(File, boolean)}.
<p>
Apps are strongly encouraged to keep their usage of cache space below the
quota returned by
{@link StorageManager#getCacheQuotaBytes(java.util.UUID)}. If your app
goes above this quota, your cached files will be some of the first to be
deleted when additional disk space is needed. Conversely, if your app
stays under this quota, your cached files will be some of the last to be
deleted when additional disk space is needed.
<p>
Note that your cache quota will change over time depending on how
frequently the user interacts with your app, and depending on how much
system-wide disk space is used.
<p>
The returned path may change over time if the calling app is moved to an
adopted storage device, so only relative paths should be persisted.
<p>
Apps require no extra permissions to read or write to the returned path,
since this path lives in their private storage.
@return {Object {java.io.File}} The path of the directory holding application cache files.
@see #openFileOutput
@see #getFileStreamPath
@see #getDir
@see #getExternalCacheDir
*/
getCacheDir : function( ) {},
/**Returns the absolute path to the application specific cache directory on
the filesystem designed for storing cached code.
<p>
The system will delete any files stored in this location both when your
specific application is upgraded, and when the entire platform is
upgraded.
<p>
This location is optimal for storing compiled or optimized code generated
by your application at runtime.
<p>
The returned path may change over time if the calling app is moved to an
adopted storage device, so only relative paths should be persisted.
<p>
Apps require no extra permissions to read or write to the returned path,
since this path lives in their private storage.
@return {Object {java.io.File}} The path of the directory holding application code cache files.
*/
getCodeCacheDir : function( ) {},
/**Returns absolute path to application-specific directory on the primary
shared/external storage device where the application can place cache
files it owns. These files are internal to the application, and not
typically visible to the user as media.
<p>
This is like {@link #getCacheDir}() in that these files will be deleted
when the application is uninstalled, however there are some important
differences:
<ul>
<li>The platform does not always monitor the space available in shared
storage, and thus may not automatically delete these files. Apps should
always manage the maximum space used in this location. Currently the only
time files here will be deleted by the platform is when running on
{@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1} or later and
{@link Environment#isExternalStorageEmulated(File)} returns true.
<li>Shared storage may not always be available, since removable media can
be ejected by the user. Media state can be checked using
{@link Environment#getExternalStorageState(File)}.
<li>There is no security enforced with these files. For example, any
application holding
{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} can write to
these files.
</ul>
<p>
If a shared storage device is emulated (as determined by
{@link Environment#isExternalStorageEmulated(File)}), its contents are
backed by a private user data partition, which means there is little
benefit to storing data here instead of the private directory returned by
{@link #getCacheDir}().
<p>
Starting in {@link android.os.Build.VERSION_CODES#KITKAT}, no permissions
are required to read or write to the returned path; it's always
accessible to the calling app. This only applies to paths generated for
package name of the calling application. To access paths belonging to
other packages,
{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} and/or
{@link android.Manifest.permission#READ_EXTERNAL_STORAGE} are required.
<p>
On devices with multiple users (as described by {@link UserManager}),
each user has their own isolated shared storage. Applications only have
access to the shared storage for the user they're running as.
<p>
The returned path may change over time if different shared storage media
is inserted, so only relative paths should be persisted.
@return {Object {java.io.File}} the absolute path to application-specific directory. May return
{@code null} if shared storage is not currently available.
@see #getCacheDir
@see #getExternalCacheDirs()
@see Environment#getExternalStorageState(File)
@see Environment#isExternalStorageEmulated(File)
@see Environment#isExternalStorageRemovable(File)
*/
getExternalCacheDir : function( ) {},
/**Returns absolute path to application-specific directory in the preloaded cache.
<p>Files stored in the cache directory can be deleted when the device runs low on storage.
There is no guarantee when these files will be deleted.
@hide
*/
getPreloadsFileCache : function( ) {},
/**Returns absolute paths to application-specific directories on all
shared/external storage devices where the application can place cache
files it owns. These files are internal to the application, and not
typically visible to the user as media.
<p>
This is like {@link #getCacheDir}() in that these files will be deleted
when the application is uninstalled, however there are some important
differences:
<ul>
<li>The platform does not always monitor the space available in shared
storage, and thus may not automatically delete these files. Apps should
always manage the maximum space used in this location. Currently the only
time files here will be deleted by the platform is when running on
{@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1} or later and
{@link Environment#isExternalStorageEmulated(File)} returns true.
<li>Shared storage may not always be available, since removable media can
be ejected by the user. Media state can be checked using
{@link Environment#getExternalStorageState(File)}.
<li>There is no security enforced with these files. For example, any
application holding
{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} can write to
these files.
</ul>
<p>
If a shared storage device is emulated (as determined by
{@link Environment#isExternalStorageEmulated(File)}), it's contents are
backed by a private user data partition, which means there is little
benefit to storing data here instead of the private directory returned by
{@link #getCacheDir}().
<p>
Shared storage devices returned here are considered a stable part of the
device, including physical media slots under a protective cover. The
returned paths do not include transient devices, such as USB flash drives
connected to handheld devices.
<p>
An application may store data on any or all of the returned devices. For
example, an app may choose to store large files on the device with the
most available space, as measured by {@link StatFs}.
<p>
No additional permissions are required for the calling app to read or
write files under the returned path. Write access outside of these paths
on secondary external storage devices is not available.
<p>
The returned paths may change over time if different shared storage media
is inserted, so only relative paths should be persisted.
@return {Object {java.io.File}} the absolute paths to application-specific directories. Some
individual paths may be {@code null} if that shared storage is
not currently available. The first path returned is the same as
{@link #getExternalCacheDir()}.
@see #getExternalCacheDir()
@see Environment#getExternalStorageState(File)
@see Environment#isExternalStorageEmulated(File)
@see Environment#isExternalStorageRemovable(File)
*/
getExternalCacheDirs : function( ) {},
/**Returns absolute paths to application-specific directories on all
shared/external storage devices where the application can place media
files. These files are scanned and made available to other apps through
{@link MediaStore}.
<p>
This is like {@link #getExternalFilesDirs} in that these files will be
deleted when the application is uninstalled, however there are some
important differences:
<ul>
<li>Shared storage may not always be available, since removable media can
be ejected by the user. Media state can be checked using
{@link Environment#getExternalStorageState(File)}.
<li>There is no security enforced with these files. For example, any
application holding
{@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} can write to
these files.
</ul>
<p>
Shared storage devices returned here are considered a stable part of the
device, including physical media slots under a protective cover. The
returned paths do not include transient devices, such as USB flash drives
connected to handheld devices.
<p>
An application may store data on any or all of the returned devices. For
example, an app may choose to store large files on the device with the
most available space, as measured by {@link StatFs}.
<p>
No additional permissions are required for the calling app to read or
write files under the returned path. Write access outside of these paths
on secondary external storage devices is not available.
<p>
The returned paths may change over time if different shared storage media
is inserted, so only relative paths should be persisted.
@return {Object {java.io.File}} the absolute paths to application-specific directories. Some
individual paths may be {@code null} if that shared storage is
not currently available.
@see Environment#getExternalStorageState(File)
@see Environment#isExternalStorageEmulated(File)
@see Environment#isExternalStorageRemovable(File)
*/
getExternalMediaDirs : function( ) {},
/**Returns an array of strings naming the private files associated with
this Context's application package.
@return {String} Array of strings naming the private files.
@see #openFileInput
@see #openFileOutput
@see #deleteFile
*/
fileList : function( ) {},
/**Retrieve, creating if needed, a new directory in which the application
can place its own custom data files. You can use the returned File
object to create and access files in this directory. Note that files
created through a File object will only be accessible by your own
application; you can only set the mode of the entire directory, not
of individual files.
<p>
The returned path may change over time if the calling app is moved to an
adopted storage device, so only relative paths should be persisted.
<p>
Apps require no extra permissions to read or write to the returned path,
since this path lives in their private storage.
@param {String} name Name of the directory to retrieve. This is a directory
that is created as part of your application data.
@param {Number} mode Operating mode.
@return {Object {java.io.File}} A {@link File} object for the requested directory. The directory
will have been created if it does not already exist.
@see #openFileOutput(String, int)
*/
getDir : function( ) {},
/**Open a new private SQLiteDatabase associated with this Context's
application package. Create the database file if it doesn't exist.
@param {String} name The name (unique in the application package) of the database.
@param {Number} mode Operating mode.
@param {Object {SQLiteDatabase.CursorFactory}} factory An optional factory class that is called to instantiate a
cursor when query is called.
@return {Object {android.database.sqlite.SQLiteDatabase}} The contents of a newly created database with the given name.
@throws android.database.sqlite.SQLiteException if the database file
could not be opened.
@see #MODE_PRIVATE
@see #MODE_ENABLE_WRITE_AHEAD_LOGGING
@see #MODE_NO_LOCALIZED_COLLATORS
@see #deleteDatabase
*/
openOrCreateDatabase : function( ) {},
/**Open a new private SQLiteDatabase associated with this Context's
application package. Creates the database file if it doesn't exist.
<p>
Accepts input param: a concrete instance of {@link DatabaseErrorHandler}
to be used to handle corruption when sqlite reports database corruption.
</p>
@param {String} name The name (unique in the application package) of the database.
@param {Number} mode Operating mode.
@param {Object {SQLiteDatabase.CursorFactory}} factory An optional factory class that is called to instantiate a
cursor when query is called.
@param {Object {DatabaseErrorHandler}} errorHandler the {@link DatabaseErrorHandler} to be used when
sqlite reports database corruption. if null,
{@link android.database.DefaultDatabaseErrorHandler} is
assumed.
@return {Object {android.database.sqlite.SQLiteDatabase}} The contents of a newly created database with the given name.
@throws android.database.sqlite.SQLiteException if the database file
could not be opened.
@see #MODE_PRIVATE
@see #MODE_ENABLE_WRITE_AHEAD_LOGGING
@see #MODE_NO_LOCALIZED_COLLATORS
@see #deleteDatabase
*/
openOrCreateDatabase : function( ) {},
/**Move an existing database file from the given source storage context to
this context. This is typically used to migrate data between storage
locations after an upgrade, such as migrating to device protected
storage.
<p>
The database must be closed before being moved.
@param {Object {Context}} sourceContext The source context which contains the existing
database to move.
@param {String} name The name of the database file.
@return {Boolean} {@code true} if the move was successful or if the database didn't
exist in the source context, otherwise {@code false}.
@see #createDeviceProtectedStorageContext()
*/
moveDatabaseFrom : function( ) {},
/**Delete an existing private SQLiteDatabase associated with this Context's
application package.
@param {String} name The name (unique in the application package) of the
database.
@return {Boolean} {@code true} if the database was successfully deleted; else {@code false}.
@see #openOrCreateDatabase
*/
deleteDatabase : function( ) {},
/**Returns the absolute path on the filesystem where a database created with
{@link #openOrCreateDatabase} is stored.
<p>
The returned path may change over time if the calling app is moved to an
adopted storage device, so only relative paths should be persisted.
@param {String} name The name of the database for which you would like to get
its path.
@return {Object {java.io.File}} An absolute path to the given database.
@see #openOrCreateDatabase
*/
getDatabasePath : function( ) {},
/**Returns an array of strings naming the private databases associated with
this Context's application package.
@return {String} Array of strings naming the private databases.
@see #openOrCreateDatabase
@see #deleteDatabase
*/
databaseList : function( ) {},
/**
@deprecated Use {@link android.app.WallpaperManager#getDrawable
WallpaperManager.get()} instead.
*/
getWallpaper : function( ) {},
/**
@deprecated Use {@link android.app.WallpaperManager#peekDrawable
WallpaperManager.peek()} instead.
*/
peekWallpaper : function( ) {},
/**
@deprecated Use {@link android.app.WallpaperManager#getDesiredMinimumWidth()
WallpaperManager.getDesiredMinimumWidth()} instead.
*/
getWallpaperDesiredMinimumWidth : function( ) {},
/**
@deprecated Use {@link android.app.WallpaperManager#getDesiredMinimumHeight()
WallpaperManager.getDesiredMinimumHeight()} instead.
*/
getWallpaperDesiredMinimumHeight : function( ) {},
/**
@deprecated Use {@link android.app.WallpaperManager#setBitmap(Bitmap)
WallpaperManager.set()} instead.
<p>This method requires the caller to hold the permission
{@link android.Manifest.permission#SET_WALLPAPER}.
*/
setWallpaper : function( ) {},
/**
@deprecated Use {@link android.app.WallpaperManager#setStream(InputStream)
WallpaperManager.set()} instead.
<p>This method requires the caller to hold the permission
{@link android.Manifest.permission#SET_WALLPAPER}.
*/
setWallpaper : function( ) {},
/**
@deprecated Use {@link android.app.WallpaperManager#clear
WallpaperManager.clear()} instead.
<p>This method requires the caller to hold the permission
{@link android.Manifest.permission#SET_WALLPAPER}.
*/
clearWallpaper : function( ) {},
/**Same as {@link #startActivity(Intent, Bundle)} with no options
specified.
@param {Object {Intent}} intent The description of the activity to start.
@throws ActivityNotFoundException
`
@see #startActivity(Intent, Bundle)
@see PackageManager#resolveActivity
*/
startActivity : function( ) {},
/**Version of {@link #startActivity}(Intent) that allows you to specify the
user the activity will be started for. This is not available to applications
that are not pre-installed on the system image.
@param {Object {Intent}} intent The description of the activity to start.
@param {Object {UserHandle}} user The UserHandle of the user to start this activity for.
@throws ActivityNotFoundException
@hide
*/
startActivityAsUser : function( ) {},
/**Launch a new activity. You will not receive any information about when
the activity exits.
<p>Note that if this method is being called from outside of an
{@link android.app.Activity} Context, then the Intent must include
the {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK} launch flag. This is because,
without being started from an existing Activity, there is no existing
task in which to place the new activity and thus it needs to be placed
in its own separate task.
<p>This method throws {@link android.content.ActivityNotFoundException}
if there was no Activity found to run the given Intent.
@param {Object {Intent}} intent The description of the activity to start.
@param {Object {Bundle}} options Additional options for how the Activity should be started.
May be null if there are no options. See {@link android.app.ActivityOptions}
for how to build the Bundle supplied here; there are no supported definitions
for building it manually.
@throws ActivityNotFoundException
@see #startActivity(Intent)
@see PackageManager#resolveActivity
*/
startActivity : function( ) {},
/**Version of {@link #startActivity(Intent, Bundle)} that allows you to specify the
user the activity will be started for. This is not available to applications
that are not pre-installed on the system image.
@param {Object {Intent}} intent The description of the activity to start.
@param {Object {Bundle}} options Additional options for how the Activity should be started.
May be null if there are no options. See {@link android.app.ActivityOptions}
for how to build the Bundle supplied here; there are no supported definitions
for building it manually.
@param {Object {UserHandle}} userId The UserHandle of the user to start this activity for.
@throws ActivityNotFoundException
@hide
*/
startActivityAsUser : function( ) {},
/**Version of {@link #startActivity(Intent, Bundle)} that returns a result to the caller. This
is only supported for Views and Fragments.
@param {String} who The identifier for the calling element that will receive the result.
@param {Object {Intent}} intent The intent to start.
@param {Number} requestCode The code that will be returned with onActivityResult() identifying this
request.
@param {Object {Bundle}} options Additional options for how the Activity should be started.
May be null if there are no options. See {@link android.app.ActivityOptions}
for how to build the Bundle supplied here; there are no supported definitions
for building it manually.
@hide
*/
startActivityForResult : function( ) {},
/**Identifies whether this Context instance will be able to process calls to
{@link #startActivityForResult(String, android.content.Intent, int, Bundle)}.
@hide
*/
canStartActivityForResult : function( ) {},
/**Same as {@link #startActivities(Intent[], Bundle)} with no options
specified.
@param {Object {android.content.Intent[]}} intents An array of Intents to be started.
@throws ActivityNotFoundException
@see #startActivities(Intent[], Bundle)
@see PackageManager#resolveActivity
*/
startActivities : function( ) {},
/**Launch multiple new activities. This is generally the same as calling
{@link #startActivity}(Intent) for the first Intent in the array,
that activity during its creation calling {@link #startActivity}(Intent)
for the second entry, etc. Note that unlike that approach, generally
none of the activities except the last in the array will be created
at this point, but rather will be created when the user first visits
them (due to pressing back from the activity on top).
<p>This method throws {@link android.content.ActivityNotFoundException}
if there was no Activity found for <em>any</em> given Intent. In this
case the state of the activity stack is undefined (some Intents in the
list may be on it, some not), so you probably want to avoid such situations.
@param {Object {android.content.Intent[]}} intents An array of Intents to be started.
@param {Object {Bundle}} options Additional options for how the Activity should be started.
See {@link android.content.Context#startActivity(Intent, Bundle)}
Context.startActivity(Intent, Bundle)} for more details.
@throws ActivityNotFoundException
@see #startActivities(Intent[])
@see PackageManager#resolveActivity
*/
startActivities : function( ) {},
/**
@param {Object {android.content.Intent[]}} intents An array of Intents to be started.
@param {Object {Bundle}} options Additional options for how the Activity should be started.
@param {Object {UserHandle}} userHandle The user for whom to launch the activities
See {@link android.content.Context#startActivity(Intent, Bundle)}
Context.startActivity(Intent, Bundle)} for more details.
@param userHandle The user for whom to launch the activities
See {@link android.content.Context#startActivity(Intent, Bundle)}
Context.startActivity(Intent, Bundle)} for more details.
@return {Number} The corresponding flag {@link ActivityManager#START_CANCELED},
{@link ActivityManager#START_SUCCESS} etc. indicating whether the launch was
successful.
@throws ActivityNotFoundException
@see #startActivities(Intent[])
@see PackageManager#resolveActivity
*/
startActivitiesAsUser : function( ) {},
/**Same as {@link #startandroid.content.IntentSender(android.content.IntentSender, android.content.Intent, int, int, int, Bundle)}
with no options specified.
@param {Object {IntentSender}} intent The IntentSender to launch.
@param {Object {Intent}} fillInIntent If non-null, this will be provided as the
intent parameter to {@link IntentSender#sendIntent}.
@param {Number} flagsMask Intent flags in the original IntentSender that you
would like to change.
@param {Number} flagsValues Desired values for any bits set in
<var>flagsMask</var>
@param {Number} extraFlags Always set to 0.
@see #startActivity(Intent)
@see #startIntentSender(IntentSender, Intent, int, int, int, Bundle)
*/
startIntentSender : function( ) {},
/**Like {@link #startActivity(Intent, Bundle)}, but taking a IntentSender
to start. If the IntentSender is for an activity, that activity will be started
as if you had called the regular {@link #startActivity}(Intent)
here; otherwise, its associated action will be executed (such as
sending a broadcast) as if you had called
{@link android.content.IntentSender#sendandroid.content.Intent android.content.IntentSender.sendandroid.content.Intent} on it.
@param {Object {IntentSender}} intent The IntentSender to launch.
@param {Object {Intent}} fillInIntent If non-null, this will be provided as the
intent parameter to {@link IntentSender#sendIntent}.
@param {Number} flagsMask Intent flags in the original IntentSender that you
would like to change.
@param {Number} flagsValues Desired values for any bits set in
<var>flagsMask</var>
@param {Number} extraFlags Always set to 0.
@param {Object {Bundle}} options Additional options for how the Activity should be started.
See {@link android.content.Context#startActivity(Intent, Bundle)}
Context.startActivity(Intent, Bundle)} for more details. If options
have also been supplied by the IntentSender, options given here will
override any that conflict with those given by the IntentSender.
@see #startActivity(Intent, Bundle)
@see #startIntentSender(IntentSender, Intent, int, int, int)
*/
startIntentSender : function( ) {},
/**Broadcast the given intent to all interested BroadcastReceivers. 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
{@link #sendOrderedBroadcast(Intent, String)}.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@see android.content.BroadcastReceiver
@see #registerReceiver
@see #sendBroadcast(Intent, String)
@see #sendOrderedBroadcast(Intent, String)
@see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
*/
sendBroadcast : function( ) {},
/**Broadcast the given intent to all interested BroadcastReceivers, allowing
an optional required permission 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
{@link #sendOrderedBroadcast(Intent, String)}.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {String} receiverPermission (optional) String naming a permission that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
@see android.content.BroadcastReceiver
@see #registerReceiver
@see #sendBroadcast(Intent)
@see #sendOrderedBroadcast(Intent, String)
@see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
*/
sendBroadcast : function( ) {},
/**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 {@link #sendOrderedBroadcast(Intent, String)}.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {Object {java.lang.String[]}} receiverPermissions Array of names of permissions that a receiver must hold
in order to receive your broadcast.
If null or empty, no permissions are required.
@see android.content.BroadcastReceiver
@see #registerReceiver
@see #sendBroadcast(Intent)
@see #sendOrderedBroadcast(Intent, String)
@see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
@hide
*/
sendBroadcastMultiplePermissions : function( ) {},
/**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 {@link #sendOrderedBroadcast(Intent, String)}.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {Object {UserHandle}} user The user to send the broadcast to.
@param {Object {java.lang.String[]}} receiverPermissions Array of names of permissions that a receiver must hold
in order to receive your broadcast.
If null or empty, no permissions are required.
@see android.content.BroadcastReceiver
@see #registerReceiver
@see #sendBroadcast(Intent)
@see #sendOrderedBroadcast(Intent, String)
@see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
@hide
*/
sendBroadcastAsUserMultiplePermissions : function( ) {},
/**Broadcast the given intent to all interested BroadcastReceivers, allowing
an optional required permission 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
{@link #sendOrderedBroadcast(Intent, String)}.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {String} receiverPermission (optional) String naming a permission that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
@param {Object {Bundle}} options (optional) Additional sending options, generated from a
{@link android.app.BroadcastOptions}.
@see android.content.BroadcastReceiver
@see #registerReceiver
@see #sendBroadcast(Intent)
@see #sendOrderedBroadcast(Intent, String)
@see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
@hide
*/
sendBroadcast : function( ) {},
/**Like {@link #sendBroadcast(Intent, String)}, but also allows specification
of an associated app op as per {@link android.app.AppOpsManager}.
@hide
*/
sendBroadcast : function( ) {},
/**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.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {String} receiverPermission (optional) String naming a permissions that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
@see android.content.BroadcastReceiver
@see #registerReceiver
@see #sendBroadcast(Intent)
@see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
*/
sendOrderedBroadcast : function( ) {},
/**Version of {@link #sendBroadcast}(Intent) that allows you to
receive data back from the broadcast. This is accomplished by
supplying your own BroadcastReceiver when calling, which will be
treated as a final receiver at the end of the broadcast -- its
{@link android.content.BroadcastReceiver#onReceive} method will be called with
the result values collected from the other receivers. The broadcast will
be serialized in the same way as calling
{@link #sendOrderedBroadcast(Intent, String)}.
<p>Like {@link #sendBroadcast}(Intent), this method is
asynchronous; it will return before
resultReceiver.onReceive() is called.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {String} receiverPermission String naming a permissions that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
@param {Object {BroadcastReceiver}} resultReceiver Your own BroadcastReceiver to treat as the final
receiver of the broadcast.
@param {Object {Handler}} scheduler A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.
@param {Number} initialCode An initial value for the result code. Often
Activity.RESULT_OK.
@param {String} initialData An initial value for the result data. Often
null.
@param {Object {Bundle}} initialExtras An initial value for the result extras. Often
null.
@see #sendBroadcast(Intent)
@see #sendBroadcast(Intent, String)
@see #sendOrderedBroadcast(Intent, String)
@see android.content.BroadcastReceiver
@see #registerReceiver
@see android.app.Activity#RESULT_OK
*/
sendOrderedBroadcast : function( ) {},
/**Version of {@link #sendBroadcast}(Intent) that allows you to
receive data back from the broadcast. This is accomplished by
supplying your own BroadcastReceiver when calling, which will be
treated as a final receiver at the end of the broadcast -- its
{@link android.content.BroadcastReceiver#onReceive} method will be called with
the result values collected from the other receivers. The broadcast will
be serialized in the same way as calling
{@link #sendOrderedBroadcast(Intent, String)}.
<p>Like {@link #sendBroadcast}(Intent), this method is
asynchronous; it will return before
resultReceiver.onReceive() is called.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {String} receiverPermission String naming a permissions that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
@param {Object {Bundle}} options (optional) Additional sending options, generated from a
{@link android.app.BroadcastOptions}.
@param {Object {BroadcastReceiver}} resultReceiver Your own BroadcastReceiver to treat as the final
receiver of the broadcast.
@param {Object {Handler}} scheduler A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.
@param {Number} initialCode An initial value for the result code. Often
Activity.RESULT_OK.
@param {String} initialData An initial value for the result data. Often
null.
@param {Object {Bundle}} initialExtras An initial value for the result extras. Often
null.
@see #sendBroadcast(Intent)
@see #sendBroadcast(Intent, String)
@see #sendOrderedBroadcast(Intent, String)
@see android.content.BroadcastReceiver
@see #registerReceiver
@see android.app.Activity#RESULT_OK
@hide
*/
sendOrderedBroadcast : function( ) {},
/**Like {@link #sendOrderedBroadcast(Intent, String, android.content.BroadcastReceiver, android.os.Handler,
int, String, android.os.Bundle)}, but also allows specification
of an associated app op as per {@link android.app.AppOpsManager}.
@hide
*/
sendOrderedBroadcast : function( ) {},
/**Version of {@link #sendBroadcast}(Intent) that allows you to specify the
user the broadcast will be sent to. This is not available to applications
that are not pre-installed on the system image.
@param {Object {Intent}} intent The intent to broadcast
@param {Object {UserHandle}} user UserHandle to send the intent to.
@see #sendBroadcast(Intent)
*/
sendBroadcastAsUser : function( ) {},
/**Version of {@link #sendBroadcast(Intent, String)} that allows you to specify the
user the broadcast will be sent to. This is not available to applications
that are not pre-installed on the system image.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {Object {UserHandle}} user UserHandle to send the intent to.
@param {String} receiverPermission (optional) String naming a permission that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
@see #sendBroadcast(Intent, String)
*/
sendBroadcastAsUser : function( ) {},
/**Version of {@link #sendBroadcast(Intent, String, Bundle)} that allows you to specify the
user the broadcast will be sent to. This is not available to applications
that are not pre-installed on the system image.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {Object {UserHandle}} user UserHandle to send the intent to.
@param {String} receiverPermission (optional) String naming a permission that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
@param {Object {Bundle}} options (optional) Additional sending options, generated from a
{@link android.app.BroadcastOptions}.
@see #sendBroadcast(Intent, String, Bundle)
@hide
*/
sendBroadcastAsUser : function( ) {},
/**Version of {@link #sendBroadcast(Intent, String)} that allows you to specify the
user the broadcast will be sent to. This is not available to applications
that are not pre-installed on the system image.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {Object {UserHandle}} user UserHandle to send the intent to.
@param {String} receiverPermission (optional) String naming a permission that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
@param {Number} appOp The app op associated with the broadcast.
@see #sendBroadcast(Intent, String)
@hide
*/
sendBroadcastAsUser : function( ) {},
/**Version of
{@link #sendOrderedBroadcast(Intent, String, android.content.BroadcastReceiver, Handler, int, String, Bundle)}
that allows you to specify the
user the broadcast will be sent to. This is not available to applications
that are not pre-installed on the system image.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {Object {UserHandle}} user UserHandle to send the intent to.
@param {String} receiverPermission String naming a permissions that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
@param {Object {BroadcastReceiver}} resultReceiver Your own BroadcastReceiver to treat as the final
receiver of the broadcast.
@param {Object {Handler}} scheduler A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.
@param {Number} initialCode An initial value for the result code. Often
Activity.RESULT_OK.
@param {String} initialData An initial value for the result data. Often
null.
@param {Object {Bundle}} initialExtras An initial value for the result extras. Often
null.
@see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
*/
sendOrderedBroadcastAsUser : function( ) {},
/**Similar to above but takes an appOp as well, to enforce restrictions.
@see #sendOrderedBroadcastAsUser(Intent, UserHandle, String,
BroadcastReceiver, Handler, int, String, Bundle)
@hide
*/
sendOrderedBroadcastAsUser : function( ) {},
/**Similar to above but takes an appOp as well, to enforce restrictions, and an options Bundle.
@see #sendOrderedBroadcastAsUser(Intent, UserHandle, String,
BroadcastReceiver, Handler, int, String, Bundle)
@hide
*/
sendOrderedBroadcastAsUser : function( ) {},
/**<p>Perform a {@link #sendBroadcast}(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 {@link #registerReceiver(BroadcastReceiver, android.content.IntentFilter)}. In
all other ways, this behaves the same as
{@link #sendBroadcast}(Intent).
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast, and the Intent will be held to
be re-broadcast to future receivers.
@param intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast, and the Intent will be held to
be re-broadcast to future receivers.
@see #sendBroadcast(Intent)
@see #sendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, int, String, Bundle)
*/
sendStickyBroadcast : function( ) {},
/**<p>Version of {@link #sendStickyBroadcast} that allows you to
receive data back from the broadcast. This is accomplished by
supplying your own BroadcastReceiver when calling, which will be
treated as a final receiver at the end of the broadcast -- its
{@link android.content.BroadcastReceiver#onReceive} method will be called with
the result values collected from the other receivers. The broadcast will
be serialized in the same way as calling
{@link #sendOrderedBroadcast(Intent, String)}.
<p>Like {@link #sendBroadcast}(Intent), this method is
asynchronous; it will return before
resultReceiver.onReceive() is called. Note that the sticky data
stored is only the data you initially supply to the broadcast, not
the result of any changes made by the receivers.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {Object {BroadcastReceiver}} resultReceiver Your own BroadcastReceiver to treat as the final
receiver of the broadcast.
@param {Object {Handler}} scheduler A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.
@param {Number} initialCode An initial value for the result code. Often
Activity.RESULT_OK.
@param {String} initialData An initial value for the result data. Often
null.
@param {Object {Bundle}} initialExtras An initial value for the result extras. Often
null.
@param initialExtras An initial value for the result extras. Often
null.
@see #sendBroadcast(Intent)
@see #sendBroadcast(Intent, String)
@see #sendOrderedBroadcast(Intent, String)
@see #sendStickyBroadcast(Intent)
@see android.content.BroadcastReceiver
@see #registerReceiver
@see android.app.Activity#RESULT_OK
*/
sendStickyOrderedBroadcast : function( ) {},
/**<p>Remove the data previously sent with {@link #sendStickyBroadcast},
so that it is as if the sticky broadcast had never happened.
@param {Object {Intent}} intent The Intent that was previously broadcast.
@param intent The Intent that was previously broadcast.
@see #sendStickyBroadcast
*/
removeStickyBroadcast : function( ) {},
/**<p>Version of {@link #sendStickyBroadcast}(Intent) that allows you to specify the
user the broadcast will be sent to. This is not available to applications
that are not pre-installed on the system image.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast, and the Intent will be held to
be re-broadcast to future receivers.
@param {Object {UserHandle}} user UserHandle to send the intent to.
@param user UserHandle to send the intent to.
@see #sendBroadcast(Intent)
*/
sendStickyBroadcastAsUser : function( ) {},
/**
@hide This is just here for sending CONNECTIVITY_ACTION.
*/
sendStickyBroadcastAsUser : function( ) {},
/**<p>Version of
{@link #sendStickyOrderedBroadcast(Intent, android.content.BroadcastReceiver, Handler, int, String, Bundle)}
that allows you to specify the
user the broadcast will be sent to. This is not available to applications
that are not pre-installed on the system image.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
@param {Object {Intent}} intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
@param {Object {UserHandle}} user UserHandle to send the intent to.
@param {Object {BroadcastReceiver}} resultReceiver Your own BroadcastReceiver to treat as the final
receiver of the broadcast.
@param {Object {Handler}} scheduler A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.
@param {Number} initialCode An initial value for the result code. Often
Activity.RESULT_OK.
@param {String} initialData An initial value for the result data. Often
null.
@param {Object {Bundle}} initialExtras An initial value for the result extras. Often
null.
@param initialExtras An initial value for the result extras. Often
null.
@see #sendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, int, String, Bundle)
*/
sendStickyOrderedBroadcastAsUser : function( ) {},
/**<p>Version of {@link #removeStickyBroadcast}(Intent) that allows you to specify the
user the broadcast will be sent to. This is not available to applications
that are not pre-installed on the system image.
<p>You must hold the {@link android.Manifest.permission#BROADCAST_STICKY}
permission in order to use this API. If you do not hold that
permission, {@link SecurityException} will be thrown.
@param {Object {Intent}} intent The Intent that was previously broadcast.
@param {Object {UserHandle}} user UserHandle to remove the sticky broadcast from.
@param user UserHandle to remove the sticky broadcast from.
@see #sendStickyBroadcastAsUser
*/
removeStickyBroadcastAsUser : function( ) {},
/**Register a BroadcastReceiver to be run in the main activity thread. The
<var>receiver</var> will be called with any broadcast Intent that
matches <var>filter</var>, in the main application thread.
<p>The system may broadcast Intents that are "sticky" -- these stay
around after the broadcast has finished, to be sent to any later
registrations. If your IntentFilter matches one of these sticky
Intents, that Intent will be returned by this function
<strong>and</strong> sent to your <var>receiver</var> as if it had just
been broadcast.
<p>There may be multiple sticky Intents that match <var>filter</var>,
in which case each of these will be sent to <var>receiver</var>. In
this case, only one of these can be returned directly by the function;
which of these that is returned is arbitrarily decided by the system.
<p>If you know the Intent your are registering for is sticky, you can
supply null for your <var>receiver</var>. In this case, no receiver is
registered -- the function simply returns the sticky Intent that
matches <var>filter</var>. In the case of multiple matches, the same
rules as described above apply.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
<p>As of {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH}, receivers
registered with this method will correctly respect the
{@link android.content.Intent#setPackage(String)} specified for an Intent being broadcast.
Prior to that, it would be ignored and delivered to all matching registered
receivers. Be careful if using this for security.</p>
<p class="note">Note: this method <em>cannot be called from a
{@link android.content.BroadcastReceiver} component;</em> that is, from a BroadcastReceiver
that is declared in an application's manifest. It is okay, however, to call
this method from another BroadcastReceiver that has itself been registered
at run time with {@link #registerReceiver}, since the lifetime of such a
registered BroadcastReceiver is tied to the object that registered it.</p>
@param {Object {BroadcastReceiver}} receiver The BroadcastReceiver to handle the broadcast.
@param {Object {IntentFilter}} filter Selects the Intent broadcasts to be received.
@return {Object {android.content.Intent}} The first sticky intent found that matches <var>filter</var>,
or null if there are none.
@see #registerReceiver(BroadcastReceiver, IntentFilter, String, Handler)
@see #sendBroadcast
@see #unregisterReceiver
*/
registerReceiver : function( ) {},
/**Register to receive intent broadcasts, with the receiver optionally being
exposed to Instant Apps. See
{@link #registerReceiver(BroadcastReceiver, android.content.IntentFilter)} for more
information. By default Instant Apps cannot interact with receivers in other
applications, this allows you to expose a receiver that Instant Apps can
interact with.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
<p>As of {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH}, receivers
registered with this method will correctly respect the
{@link android.content.Intent#setPackage(String)} specified for an Intent being broadcast.
Prior to that, it would be ignored and delivered to all matching registered
receivers. Be careful if using this for security.</p>
@param {Object {BroadcastReceiver}} receiver The BroadcastReceiver to handle the broadcast.
@param {Object {IntentFilter}} filter Selects the Intent broadcasts to be received.
@param {Number} flags Additional options for the receiver. May be 0 or
{@link #RECEIVER_VISIBLE_TO_INSTANT_APPS}.
@return {Object {android.content.Intent}} The first sticky intent found that matches <var>filter</var>,
or null if there are none.
@see #registerReceiver(BroadcastReceiver, IntentFilter)
@see #sendBroadcast
@see #unregisterReceiver
*/
registerReceiver : function( ) {},
/**Register to receive intent broadcasts, to run in the context of
<var>scheduler</var>. See
{@link #registerReceiver(BroadcastReceiver, android.content.IntentFilter)} for more
information. This allows you to enforce permissions on who can
broadcast intents to your receiver, or have the receiver run in
a different thread than the main application thread.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
<p>As of {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH}, receivers
registered with this method will correctly respect the
{@link android.content.Intent#setPackage(String)} specified for an Intent being broadcast.
Prior to that, it would be ignored and delivered to all matching registered
receivers. Be careful if using this for security.</p>
@param {Object {BroadcastReceiver}} receiver The BroadcastReceiver to handle the broadcast.
@param {Object {IntentFilter}} filter Selects the Intent broadcasts to be received.
@param {String} broadcastPermission String naming a permissions that a
broadcaster must hold in order to send an Intent to you. If null,
no permission is required.
@param {Object {Handler}} scheduler Handler identifying the thread that will receive
the Intent. If null, the main thread of the process will be used.
@return {Object {android.content.Intent}} The first sticky intent found that matches <var>filter</var>,
or null if there are none.
@see #registerReceiver(BroadcastReceiver, IntentFilter)
@see #sendBroadcast
@see #unregisterReceiver
*/
registerReceiver : function( ) {},
/**Register to receive intent broadcasts, to run in the context of
<var>scheduler</var>. See
{@link #registerReceiver(BroadcastReceiver, android.content.IntentFilter, int)} and
{@link #registerReceiver(BroadcastReceiver, android.content.IntentFilter, String, Handler)}
for more information.
<p>See {@link android.content.BroadcastReceiver} for more information on Intent broadcasts.
<p>As of {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH}, receivers
registered with this method will correctly respect the
{@link android.content.Intent#setPackage(String)} specified for an Intent being broadcast.
Prior to that, it would be ignored and delivered to all matching registered
receivers. Be careful if using this for security.</p>
@param {Object {BroadcastReceiver}} receiver The BroadcastReceiver to handle the broadcast.
@param {Object {IntentFilter}} filter Selects the Intent broadcasts to be received.
@param {String} broadcastPermission String naming a permissions that a
broadcaster must hold in order to send an Intent to you. If null,
no permission is required.
@param {Object {Handler}} scheduler Handler identifying the thread that will receive
the Intent. If null, the main thread of the process will be used.
@param {Number} flags Additional options for the receiver. May be 0 or
{@link #RECEIVER_VISIBLE_TO_INSTANT_APPS}.
@return {Object {android.content.Intent}} The first sticky intent found that matches <var>filter</var>,
or null if there are none.
@see #registerReceiver(BroadcastReceiver, IntentFilter, int)
@see #registerReceiver(BroadcastReceiver, IntentFilter, String, Handler)
@see #sendBroadcast
@see #unregisterReceiver
*/
registerReceiver : function( ) {},
/**
@param {Object {BroadcastReceiver}} receiver The BroadcastReceiver to handle the broadcast.
@param {Object {UserHandle}} user UserHandle to send the intent to.
@param {Object {IntentFilter}} filter Selects the Intent broadcasts to be received.
@param {String} broadcastPermission String naming a permissions that a
broadcaster must hold in order to send an Intent to you. If null,
no permission is required.
@param {Object {Handler}} scheduler Handler identifying the thread that will receive
the Intent. If null, the main thread of the process will be used.
@param scheduler Handler identifying the thread that will receive
the Intent. If null, the main thread of the process will be used.
@return {Object {android.content.Intent}} The first sticky intent found that matches <var>filter</var>,
or null if there are none.
@see #registerReceiver(BroadcastReceiver, IntentFilter, String, Handler)
@see #sendBroadcast
@see #unregisterReceiver
*/
registerReceiverAsUser : function( ) {},
/**Unregister a previously registered BroadcastReceiver. <em>All</em>
filters that have been registered for this BroadcastReceiver will be
removed.
@param {Object {BroadcastReceiver}} receiver The BroadcastReceiver to unregister.
@see #registerReceiver
*/
unregisterReceiver : function( ) {},
/**Request that a given application service be started. The Intent
should either contain the complete class name of a specific service
implementation to start, or a specific package name to target. If the
Intent is less specified, it logs a warning about this. In this case any of the
multiple matching services may be used. If this service
is not already running, it will be instantiated and started (creating a
process for it if needed); if it is running then it remains running.
<p>Every call to this method will result in a corresponding call to
the target service's {@link android.app.Service#onStartCommand} method,
with the <var>intent</var> given here. This provides a convenient way
to submit jobs to a service without having to bind and call on to its
interface.
<p>Using startService() overrides the default service lifetime that is
managed by {@link #bindService}: it requires the service to remain
running until {@link #stopService} is called, regardless of whether
any clients are connected to it. Note that calls to startService()
do not nest: no matter how many times you call startService(),
a single call to {@link #stopService} will stop it.
<p>The system attempts to keep running services around as much as
possible. The only time they should be stopped is if the current
foreground application is using so many resources that the service needs
to be killed. If any errors happen in the service's process, it will
automatically be restarted.
<p>This function will throw {@link SecurityException} if you do not
have permission to start the given service.
<p class="note"><strong>Note:</strong> Each call to startService()
results in significant work done by the system to manage service
lifecycle surrounding the processing of the intent, which can take
multiple milliseconds of CPU time. Due to this cost, startService()
should not be used for frequent intent delivery to a service, and only
for scheduling significant work. Use {@link #bindService bound services}
for high frequency calls.
</p>
@param {Object {Intent}} service Identifies the service to be started. The Intent must be
fully explicit (supplying a component name). Additional values
may be included in the Intent extras to supply arguments along with
this specific start call.
@return {Object {android.content.ComponentName}} If the service is being started or is already running, the
{@link ComponentName} of the actual service that was started is
returned; else if the service does not exist null is returned.
@throws SecurityException If the caller does not have permission to access the service
or the service can not be found.
@throws 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).
@see #stopService
@see #bindService
*/
startService : function( ) {},
/**Similar to {@link #startService}(Intent), but with an implicit promise that the
Service will call {@link android.app.Service#startForeground(int, android.app.Notification)
startForeground(int, android.app.Notification)} once it begins running. The service is given
an amount of time comparable to the ANR interval to do this, otherwise the system
will automatically stop the service and declare the app ANR.
<p>Unlike the ordinary {@link #startService}(Intent), this method can be used
at any time, regardless of whether the app hosting the service is in a foreground
state.
@param {Object {Intent}} service Identifies the service to be started. The Intent must be
fully explicit (supplying a component name). Additional values
may be included in the Intent extras to supply arguments along with
this specific start call.
@return {Object {android.content.ComponentName}} If the service is being started or is already running, the
{@link ComponentName} of the actual service that was started is
returned; else if the service does not exist null is returned.
@throws SecurityException If the caller does not have permission to access the service
or the service can not be found.
@see #stopService
@see android.app.Service#startForeground(int, android.app.Notification)
*/
startForegroundService : function( ) {},
/**
@hide like {@link #startForegroundService(Intent)} but for a specific user.
*/
startForegroundServiceAsUser : function( ) {},
/**Request that a given application service be stopped. If the service is
not running, nothing happens. Otherwise it is stopped. Note that calls
to startService() are not counted -- this stops the service no matter
how many times it was started.
<p>Note that if a stopped service still has {@link android.content.ServiceConnection}
objects bound to it with the {@link #BIND_AUTO_CREATE} set, it will
not be destroyed until all of these bindings are removed. See
the {@link android.app.Service} documentation for more details on a
service's lifecycle.
<p>This function will throw {@link SecurityException} if you do not
have permission to stop the given service.
@param {Object {Intent}} service Description of the service to be stopped. The Intent must be either
fully explicit (supplying a component name) or specify a specific package
name it is targeted to.
@return {Boolean} If there is a service matching the given Intent that is already
running, then it is stopped and {@code true} is returned; else {@code false} is returned.
@throws SecurityException If the caller does not have permission to access the service
or the service can not be found.
@throws 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).
@see #startService
*/
stopService : function( ) {},
/**
@hide like {@link #startService(Intent)} but for a specific user.
*/
startServiceAsUser : function( ) {},
/**
@hide like {@link #stopService(Intent)} but for a specific user.
*/
stopServiceAsUser : function( ) {},
/**Connect to an application service, creating it if needed. This defines
a dependency between your application and the service. The given
<var>conn</var> will receive the service object when it is created and be
told if it dies and restarts. The service will be considered required
by the system only for as long as the calling context exists. For
example, if this Context is an Activity that is stopped, the service will
not be required to continue running until the Activity is resumed.
<p>If the service does not support binding, it may return {@code null} from
its {@link android.app.Service#onBind(Intent) onBind()} method. If it does, then
the ServiceConnection's
{@link android.content.ServiceConnection#onNullBinding(ComponentName) onNullBinding()} method
will be invoked instead of
{@link android.content.ServiceConnection#onServiceConnected(ComponentName, IBinder) onServiceConnected()}.
<p>This method will throw {@link SecurityException} if the calling app does not
have permission to bind to the given service.
<p class="note">Note: this method <em>cannot be called from a
{@link android.content.BroadcastReceiver} component</em>. A pattern you can use to
communicate from a BroadcastReceiver to a Service is to call
{@link #startService} with the arguments containing the command to be
sent, with the service calling its
{@link android.app.Service#stopSelf(int)} method when done executing
that command. See the API demo App/Service/Service Start Arguments
Controller for an illustration of this. It is okay, however, to use
this method from a BroadcastReceiver that has been registered with
{@link #registerReceiver}, since the lifetime of this BroadcastReceiver
is tied to another object (the one that registered it).</p>
@param {Object {Intent}} service Identifies the service to connect to. The Intent must
specify an explicit component name.
@param {Object {ServiceConnection}} conn Receives information as the service is started and stopped.
This must be a valid ServiceConnection object; it must not be null.
@param {Number} flags Operation options for the binding. May be 0,
{@link #BIND_AUTO_CREATE}, {@link #BIND_DEBUG_UNBIND},
{@link #BIND_NOT_FOREGROUND}, {@link #BIND_ABOVE_CLIENT},
{@link #BIND_ALLOW_OOM_MANAGEMENT}, {@link #BIND_WAIVE_PRIORITY}.
{@link #BIND_IMPORTANT}, or
{@link #BIND_ADJUST_WITH_ACTIVITY}.
@return {Boolean} {@code true} if the system is in the process of bringing up a
service that your client has permission to bind to; {@code false}
if the system couldn't find the service or if your client doesn't
have permission to bind to it. If this value is {@code true}, you
should later call {@link #unbindService} to release the
connection.
@throws SecurityException If the caller does not have permission to access the service
or the service can not be found.
@see #unbindService
@see #startService
@see #BIND_AUTO_CREATE
@see #BIND_DEBUG_UNBIND
@see #BIND_NOT_FOREGROUND
@see #BIND_ABOVE_CLIENT
@see #BIND_ALLOW_OOM_MANAGEMENT
@see #BIND_WAIVE_PRIORITY
@see #BIND_IMPORTANT
@see #BIND_ADJUST_WITH_ACTIVITY
*/
bindService : function( ) {},
/**Same as {@link #bindService(Intent, android.content.ServiceConnection, int)} with executor to control
ServiceConnection callbacks.
@param {Object {Intent}} executor Callbacks on ServiceConnection will be called on executor. Must use same
instance for the same instance of ServiceConnection.
*/
bindService : function( ) {},
/**Variation of {@link #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 {@link 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 <var>instanceName</var>
you provide here identifies the different instances, and you can use
{@link #updateServiceGroup(ServiceConnection, int, int)} to tell the system how it
should manage each of these instances.
@param {Object {Intent}} service Identifies the service to connect to. The Intent must
specify an explicit component name.
@param {Number} flags Operation options for the binding as per {@link #bindService}.
@param {String} instanceName 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.
@param {Object {Executor}} executor Callbacks on ServiceConnection will be called on executor.
Must use same instance for the same instance of ServiceConnection.
@param {Object {ServiceConnection}} conn Receives information as the service is started and stopped.
This must be a valid ServiceConnection object; it must not be null.
@param conn Receives information as the service is started and stopped.
This must be a valid ServiceConnection object; it must not be null.
@throws SecurityException If the caller does not have permission to access the service
@throws IllegalArgumentException If the instanceName is invalid.
@see #bindService
@see #updateServiceGroup
@see android.R.attr#isolatedProcess
*/
bindIsolatedService : function( ) {},
/**Same as {@link #bindService(Intent, android.content.ServiceConnection, int)}, but with an explicit userHandle
argument for use by system server and other multi-user aware code.
@hide
*/
bindServiceAsUser : function( ) {},
/**Same as {@link #bindServiceAsUser(Intent, android.content.ServiceConnection, int, UserHandle)}, but with an
explicit non-null Handler to run the ServiceConnection callbacks on.
@hide
*/
bindServiceAsUser : function( ) {},
/**For a service previously bound with {@link #bindService} or a related method, change
how the system manages that service's process in relation to other processes. This
doesn't modify the original bind flags that were passed in when binding, but adjusts
how the process will be managed in some cases based on those flags. Currently only
works on isolated processes (will be ignored for non-isolated processes).
<p>Note that this call does not take immediate effect, but will be applied the next
time the impacted process is adjusted for some other reason. Typically you would
call this before then calling a new {@link #bindIsolatedService} on the service
of interest, with that binding causing the process to be shuffled accordingly.</p>
@param {Object {ServiceConnection}} conn The connection interface previously supplied to bindService(). This
parameter must not be null.
@param {Number} group A group to put this connection's process in. Upon calling here, this
will override any previous group that was set for that process. The group
tells the system about processes that are logically grouped together, so
should be managed as one unit of importance (such as when being considered
a recently used app). All processes in the same app with the same group
are considered to be related. Supplying 0 reverts to the default behavior
of not grouping.
@param {Number} importance Additional importance of the processes within a group. Upon calling
here, this will override any previous importance that was set for that
process. The most important process is 0, and higher values are
successively less important. You can view this as describing how
to order the processes in an array, with the processes at the end of
the array being the least important. This value has no meaning besides
indicating how processes should be ordered in that array one after the
other. This provides a way to fine-tune the system's process killing,
guiding it to kill processes at the end of the array first.
@see #bindIsolatedService
*/
updateServiceGroup : function( ) {},
/**Disconnect from an application service. You will no longer receive
calls as the service is restarted, and the service is now allowed to
stop at any time.
@param {Object {ServiceConnection}} conn The connection interface previously supplied to
bindService(). This parameter must not be null.
@see #bindService
*/
unbindService : function( ) {},
/**Start executing an {@link android.app.Instrumentation} class. The given
Instrumentation component will be run by killing its target application
(if currently running), starting the target process, instantiating the
instrumentation component, and then letting it drive the application.
<p>This function is not synchronous -- it returns as soon as the
instrumentation has started and while it is running.
<p>Instrumentation is normally only allowed to run against a package
that is either unsigned or signed with a signature that the
the instrumentation package is also signed with (ensuring the target
trusts the instrumentation).
@param {Object {ComponentName}} className Name of the Instrumentation component to be run.
@param {String} profileFile Optional path to write profiling data as the
instrumentation runs, or null for no profiling.
@param {Object {Bundle}} arguments Additional optional arguments to pass to the
instrumentation, or null.
@return {Boolean} {@code true} if the instrumentation was successfully started,
else {@code false} if it could not be found.
*/
startInstrumentation : function( ) {},
/**Return the handle to a system-level service by name. The class of the
returned object varies by the requested name. Currently available names
are:
<dl>
<dt> {@link #WINDOW_SERVICE} ("window")
<dd> The top-level window manager in which you can place custom
windows. The returned object is a {@link android.view.WindowManager}.
<dt> {@link #LAYOUT_INFLATER_SERVICE} ("layout_inflater")
<dd> A {@link android.view.LayoutInflater} for inflating layout resources
in this context.
<dt> {@link #ACTIVITY_SERVICE} ("activity")
<dd> A {@link android.app.ActivityManager} for interacting with the
global activity state of the system.
<dt> {@link #POWER_SERVICE} ("power")
<dd> A {@link android.os.PowerManager} for controlling power
management.
<dt> {@link #ALARM_SERVICE} ("alarm")
<dd> A {@link android.app.AlarmManager} for receiving intents at the
time of your choosing.
<dt> {@link #NOTIFICATION_SERVICE} ("notification")
<dd> A {@link android.app.NotificationManager} for informing the user
of background events.
<dt> {@link #KEYGUARD_SERVICE} ("keyguard")
<dd> A {@link android.app.KeyguardManager} for controlling keyguard.
<dt> {@link #LOCATION_SERVICE} ("location")
<dd> A {@link android.location.LocationManager} for controlling location
(e.g., GPS) updates.
<dt> {@link #SEARCH_SERVICE} ("search")
<dd> A {@link android.app.SearchManager} for handling search.
<dt> {@link #VIBRATOR_SERVICE} ("vibrator")
<dd> A {@link android.os.Vibrator} for interacting with the vibrator
hardware.
<dt> {@link #CONNECTIVITY_SERVICE} ("connection")
<dd> A {@link android.net.ConnectivityManager ConnectivityManager} for
handling management of network connections.
<dt> {@link #IPSEC_SERVICE} ("ipsec")
<dd> A {@link android.net.IpSecManager IpSecManager} for managing IPSec on
sockets and networks.
<dt> {@link #WIFI_SERVICE} ("wifi")
<dd> A {@link android.net.wifi.WifiManager WifiManager} for management of Wi-Fi
connectivity. On releases before NYC, it should only be obtained from an application
context, and not from any other derived context to avoid memory leaks within the calling
process.
<dt> {@link #WIFI_AWARE_SERVICE} ("wifiaware")
<dd> A {@link android.net.wifi.aware.WifiAwareManager WifiAwareManager} for management of
Wi-Fi Aware discovery and connectivity.
<dt> {@link #WIFI_P2P_SERVICE} ("wifip2p")
<dd> A {@link android.net.wifi.p2p.WifiP2pManager WifiP2pManager} for management of
Wi-Fi Direct connectivity.
<dt> {@link #INPUT_METHOD_SERVICE} ("input_method")
<dd> An {@link android.view.inputmethod.InputMethodManager InputMethodManager}
for management of input methods.
<dt> {@link #UI_MODE_SERVICE} ("uimode")
<dd> An {@link android.app.UiModeManager} for controlling UI modes.
<dt> {@link #DOWNLOAD_SERVICE} ("download")
<dd> A {@link android.app.DownloadManager} for requesting HTTP downloads
<dt> {@link #BATTERY_SERVICE} ("batterymanager")
<dd> A {@link android.os.BatteryManager} for managing battery state
<dt> {@link #JOB_SCHEDULER_SERVICE} ("taskmanager")
<dd> A {@link android.app.job.JobScheduler} for managing scheduled tasks
<dt> {@link #NETWORK_STATS_SERVICE} ("netstats")
<dd> A {@link android.app.usage.NetworkStatsManager NetworkStatsManager} for querying network
usage statistics.
<dt> {@link #HARDWARE_PROPERTIES_SERVICE} ("hardware_properties")
<dd> A {@link android.os.HardwarePropertiesManager} for accessing hardware properties.
</dl>
<p>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.)
<p>Note: Instant apps, for which {@link PackageManager#isInstantApp()} returns true,
don't have access to the following system services: {@link #DEVICE_POLICY_SERVICE},
{@link #FINGERPRINT_SERVICE}, {@link #KEYGUARD_SERVICE}, {@link #SHORTCUT_SERVICE},
{@link #USB_SERVICE}, {@link #WALLPAPER_SERVICE}, {@link #WIFI_P2P_SERVICE},
{@link #WIFI_SERVICE}, {@link #WIFI_AWARE_SERVICE}. For these services this method will
return <code>null</code>. Generally, if you are running as an instant app you should always
check whether the result of this method is {@code null}.
<p>Note: When implementing this method, keep in mind that new services can be added on newer
Android releases, so if you're looking for just the explicit names mentioned above, make sure
to return {@code null} when you don't recognize the name — if you throw a
{@link RuntimeException} exception instead, you're app might break on new Android releases.
@param {String} name The name of the desired service.
@return {Object {java.lang.Object}} The service or {@code null} if the name does not exist.
@see #WINDOW_SERVICE
@see android.view.WindowManager
@see #LAYOUT_INFLATER_SERVICE
@see android.view.LayoutInflater
@see #ACTIVITY_SERVICE
@see android.app.ActivityManager
@see #POWER_SERVICE
@see android.os.PowerManager
@see #ALARM_SERVICE
@see android.app.AlarmManager
@see #NOTIFICATION_SERVICE
@see android.app.NotificationManager
@see #KEYGUARD_SERVICE
@see android.app.KeyguardManager
@see #LOCATION_SERVICE
@see android.location.LocationManager
@see #SEARCH_SERVICE
@see android.app.SearchManager
@see #SENSOR_SERVICE
@see android.hardware.SensorManager
@see #STORAGE_SERVICE
@see android.os.storage.StorageManager
@see #VIBRATOR_SERVICE
@see android.os.Vibrator
@see #CONNECTIVITY_SERVICE
@see android.net.ConnectivityManager
@see #WIFI_SERVICE
@see android.net.wifi.WifiManager
@see #AUDIO_SERVICE
@see android.media.AudioManager
@see #MEDIA_ROUTER_SERVICE
@see android.media.MediaRouter
@see #TELEPHONY_SERVICE
@see android.telephony.TelephonyManager
@see #TELEPHONY_SUBSCRIPTION_SERVICE
@see android.telephony.SubscriptionManager
@see #CARRIER_CONFIG_SERVICE
@see android.telephony.CarrierConfigManager
@see #INPUT_METHOD_SERVICE
@see android.view.inputmethod.InputMethodManager
@see #UI_MODE_SERVICE
@see android.app.UiModeManager
@see #DOWNLOAD_SERVICE
@see android.app.DownloadManager
@see #BATTERY_SERVICE
@see android.os.BatteryManager
@see #JOB_SCHEDULER_SERVICE
@see android.app.job.JobScheduler
@see #NETWORK_STATS_SERVICE
@see android.app.usage.NetworkStatsManager
@see android.os.HardwarePropertiesManager
@see #HARDWARE_PROPERTIES_SERVICE
*/
getSystemService : function( ) {},
/**Return the handle to a system-level service by class.
<p>
Currently available classes are:
{@link android.view.WindowManager}, {@link android.view.LayoutInflater},
{@link android.app.ActivityManager}, {@link android.os.PowerManager},
{@link android.app.AlarmManager}, {@link android.app.NotificationManager},
{@link android.app.KeyguardManager}, {@link android.location.LocationManager},
{@link android.app.SearchManager}, {@link android.os.Vibrator},
{@link android.net.ConnectivityManager},
{@link android.net.wifi.WifiManager},
{@link android.media.AudioManager}, {@link android.media.MediaRouter},
{@link android.telephony.TelephonyManager}, {@link android.telephony.SubscriptionManager},
{@link android.view.inputmethod.InputMethodManager},
{@link android.app.UiModeManager}, {@link android.app.DownloadManager},
{@link android.os.BatteryManager}, {@link android.app.job.JobScheduler},
{@link android.app.usage.NetworkStatsManager}.
</p>
<p>
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.)
</p>
<p>Note: Instant apps, for which {@link PackageManager#isInstantApp()} returns true,
don't have access to the following system services: {@link #DEVICE_POLICY_SERVICE},
{@link #FINGERPRINT_SERVICE}, {@link #KEYGUARD_SERVICE}, {@link #SHORTCUT_SERVICE},
{@link #USB_SERVICE}, {@link #WALLPAPER_SERVICE}, {@link #WIFI_P2P_SERVICE},
{@link #WIFI_SERVICE}, {@link #WIFI_AWARE_SERVICE}. For these services this method will
return {@code null}. Generally, if you are running as an instant app you should always
check whether the result of this method is {@code null}.
</p>
@param {Object {java.lang.Class}} serviceClass The class of the desired service.
@return {Object {java.lang.Object}} The service or {@code null} if the class is not a supported system service. Note:
<b>never</b> throw a {@link RuntimeException} if the name is not supported.
*/
getSystemService : function( ) {},
/**Gets the name of the system-level service that is represented by the specified class.
@param {Object {java.lang.Class}} serviceClass The class of the desired service.
@return {String} The service name or null if the class is not a supported system service.
*/
getSystemServiceName : function( ) {},
/**Determine whether the given permission is allowed for a particular
process and user ID running in the system.
@param {String} permission The name of the permission being checked.
@param {Number} pid The process ID being checked against. Must be > 0.
@param {Number} uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
@return {Number} {@link PackageManager#PERMISSION_GRANTED} if the given
pid/uid is allowed that permission, or
{@link PackageManager#PERMISSION_DENIED} if it is not.
@see PackageManager#checkPermission(String, String)
@see #checkCallingPermission
*/
checkPermission : function( ) {},
/**
@hide
*/
checkPermission : function( ) {},
/**Determine whether the calling process of an IPC you are handling has been
granted a particular permission. This is basically the same as calling
{@link #checkPermission(String, int, int)} with the pid and uid returned
by {@link android.os.Binder#getCallingPid} and
{@link android.os.Binder#getCallingUid}. One important difference
is that if you are not currently processing an IPC, this function
will always fail. This is done to protect against accidentally
leaking permissions; you can use {@link #checkCallingOrSelfPermission}
to avoid this protection.
@param {String} permission The name of the permission being checked.
@return {Number} {@link PackageManager#PERMISSION_GRANTED} if the calling
pid/uid is allowed that permission, or
{@link PackageManager#PERMISSION_DENIED} if it is not.
@see PackageManager#checkPermission(String, String)
@see #checkPermission
@see #checkCallingOrSelfPermission
*/
checkCallingPermission : function( ) {},
/**Determine whether the calling process of an IPC <em>or you</em> have been
granted a particular permission. This is the same as
{@link #checkCallingPermission}, except it grants your own permissions
if you are not currently processing an IPC. Use with care!
@param {String} permission The name of the permission being checked.
@return {Number} {@link PackageManager#PERMISSION_GRANTED} if the calling
pid/uid is allowed that permission, or
{@link PackageManager#PERMISSION_DENIED} if it is not.
@see PackageManager#checkPermission(String, String)
@see #checkPermission
@see #checkCallingPermission
*/
checkCallingOrSelfPermission : function( ) {},
/**Determine whether <em>you</em> have been granted a particular permission.
@param {String} permission The name of the permission being checked.
@return {Number} {@link PackageManager#PERMISSION_GRANTED} if you have the
permission, or {@link PackageManager#PERMISSION_DENIED} if not.
@see PackageManager#checkPermission(String, String)
@see #checkCallingPermission(String)
*/
checkSelfPermission : function( ) {},
/**If the given permission is not allowed for a particular process
and user ID running in the system, throw a {@link SecurityException}.
@param {String} permission The name of the permission being checked.
@param {Number} pid The process ID being checked against. Must be > 0.
@param {Number} uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
@param {String} message A message to include in the exception if it is thrown.
@see #checkPermission(String, int, int)
*/
enforcePermission : function( ) {},
/**If the calling process of an IPC you are handling has not been
granted a particular permission, throw a {@link SecurityException}. This is basically the same as calling
{@link #enforcePermission(String, int, int, String)} with the
pid and uid returned by {@link android.os.Binder#getCallingPid}
and {@link android.os.Binder#getCallingUid}. One important
difference is that if you are not currently processing an IPC,
this function will always throw the SecurityException. This is
done to protect against accidentally leaking permissions; you
can use {@link #enforceCallingOrSelfPermission} to avoid this
protection.
@param {String} permission The name of the permission being checked.
@param {String} message A message to include in the exception if it is thrown.
@see #checkCallingPermission(String)
*/
enforceCallingPermission : function( ) {},
/**If neither you nor the calling process of an IPC you are
handling has been granted a particular permission, throw a
{@link SecurityException}. This is the same as {@link #enforceCallingPermission}, except it grants your own
permissions if you are not currently processing an IPC. Use
with care!
@param {String} permission The name of the permission being checked.
@param {String} message A message to include in the exception if it is thrown.
@see #checkCallingOrSelfPermission(String)
*/
enforceCallingOrSelfPermission : function( ) {},
/**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. This can be used to grant specific, temporary
permissions, typically in response to user interaction (such as the
user opening an attachment that you would like someone else to
display).
<p>Normally you should use {@link android.content.Intent#FLAG_GRANT_READ_URI_PERMISSION
android.content.Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link android.content.Intent#FLAG_GRANT_WRITE_URI_PERMISSION
android.content.Intent.FLAG_GRANT_WRITE_URI_PERMISSION} with the Intent being used to
start an activity instead of this function directly. If you use this
function directly, you should be sure to call
{@link #revokeUriPermission} when the target should no longer be allowed
to access it.
<p>To succeed, the content provider owning the Uri must have set the
{@link android.R.styleable#AndroidManifestProvider_grantUriPermissions
grantUriPermissions} attribute in its manifest or included the
{@link android.R.styleable#AndroidManifestGrantUriPermission
<grant-uri-permissions>} tag.
@param {String} toPackage The package you would like to allow to access the Uri.
@param {Object {Uri}} uri The Uri you would like to grant access to.
@param {Number} modeFlags The desired access modes.
@see #revokeUriPermission
*/
grantUriPermission : function( ) {},
/**Remove all permissions to access a particular content provider Uri
that were previously added with {@link #grantUriPermission} or <em>any other</em> mechanism.
The given Uri will match all previously granted Uris that are the same or a
sub-path of the given Uri. That is, revoking "content://foo/target" will
revoke both "content://foo/target" and "content://foo/target/sub", but not
"content://foo". It will not remove any prefix grants that exist at a
higher level.
<p>Prior to {@link android.os.Build.VERSION_CODES#LOLLIPOP}, if you did not have
regular permission access to a Uri, but had received access to it through
a specific Uri permission grant, you could not revoke that grant with this
function and a {@link SecurityException} would be thrown. As of
{@link android.os.Build.VERSION_CODES#LOLLIPOP}, this function will not throw a security
exception, but will remove whatever permission grants to the Uri had been given to the app
(or none).</p>
<p>Unlike {@link #revokeUriPermission(String, Uri, int)}, this method impacts all permission
grants matching the given Uri, for any package they had been granted to, through any
mechanism this had happened (such as indirectly through the clipboard, activity launch,
service start, etc). That means this can be potentially dangerous to use, as it can
revoke grants that another app could be strongly expecting to stick around.</p>
@param {Object {Uri}} uri The Uri you would like to revoke access to.
@param {Number} modeFlags The access modes to revoke.
@see #grantUriPermission
*/
revokeUriPermission : function( ) {},
/**Remove permissions to access a particular content provider Uri
that were previously added with {@link #grantUriPermission} for a specific target
package. The given Uri will match all previously granted Uris that are the same or a
sub-path of the given Uri. That is, revoking "content://foo/target" will
revoke both "content://foo/target" and "content://foo/target/sub", but not
"content://foo". It will not remove any prefix grants that exist at a
higher level.
<p>Unlike {@link #revokeUriPermission(Uri, int)}, this method will <em>only</em>
revoke permissions that had been explicitly granted through {@link #grantUriPermission}
and only for the package specified. Any matching grants that have happened through
other mechanisms (clipboard, activity launching, service starting, etc) will not be
removed.</p>
@param {String} toPackage The package you had previously granted access to.
@param {Object {Uri}} uri The Uri you would like to revoke access to.
@param {Number} modeFlags The access modes to revoke.
@see #grantUriPermission
*/
revokeUriPermission : function( ) {},
/**Determine whether a particular process and user ID has been granted
permission to access a specific URI. 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.
@param {Object {Uri}} uri The uri that is being checked.
@param {Number} pid The process ID being checked against. Must be > 0.
@param {Number} uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
@param {Number} modeFlags The access modes to check.
@return {Number} {@link PackageManager#PERMISSION_GRANTED} if the given
pid/uid is allowed to access that uri, or
{@link PackageManager#PERMISSION_DENIED} if it is not.
@see #checkCallingUriPermission
*/
checkUriPermission : function( ) {},
/**
@hide
*/
checkUriPermission : function( ) {},
/**Determine whether the calling process and user ID has been
granted permission to access a specific URI. This is basically
the same as calling {@link #checkUriPermission(Uri, int, int,
int)} with the pid and uid returned by {@link android.os.Binder#getCallingPid} and {@link android.os.Binder#getCallingUid}. One important difference is
that if you are not currently processing an IPC, this function
will always fail.
@param {Object {Uri}} uri The uri that is being checked.
@param {Number} modeFlags The access modes to check.
@return {Number} {@link PackageManager#PERMISSION_GRANTED} if the caller
is allowed to access that uri, or
{@link PackageManager#PERMISSION_DENIED} if it is not.
@see #checkUriPermission(Uri, int, int, int)
*/
checkCallingUriPermission : function( ) {},
/**Determine whether the calling process of an IPC <em>or you</em> has been granted
permission to access a specific URI. This is the same as
{@link #checkCallingUriPermission}, except it grants your own permissions
if you are not currently processing an IPC. Use with care!
@param {Object {Uri}} uri The uri that is being checked.
@param {Number} modeFlags The access modes to check.
@return {Number} {@link PackageManager#PERMISSION_GRANTED} if the caller
is allowed to access that uri, or
{@link PackageManager#PERMISSION_DENIED} if it is not.
@see #checkCallingUriPermission
*/
checkCallingOrSelfUriPermission : function( ) {},
/**Check both a Uri and normal permission. This allows you to perform
both {@link #checkPermission} and {@link #checkUriPermission} in one
call.
@param {Object {Uri}} uri The Uri whose permission is to be checked, or null to not
do this check.
@param {String} readPermission The permission that provides overall read access,
or null to not do this check.
@param {String} writePermission The permission that provides overall write
access, or null to not do this check.
@param {Number} pid The process ID being checked against. Must be > 0.
@param {Number} uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
@param {Number} modeFlags The access modes to check.
@return {Number} {@link PackageManager#PERMISSION_GRANTED} if the caller
is allowed to access that uri or holds one of the given permissions, or
{@link PackageManager#PERMISSION_DENIED} if it is not.
*/
checkUriPermission : function( ) {},
/**If a particular process and user ID has not been granted
permission to access a specific URI, throw {@link SecurityException}. 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.
@param {Object {Uri}} uri The uri that is being checked.
@param {Number} pid The process ID being checked against. Must be > 0.
@param {Number} uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
@param {Number} modeFlags The access modes to enforce.
@param {String} message A message to include in the exception if it is thrown.
@see #checkUriPermission(Uri, int, int, int)
*/
enforceUriPermission : function( ) {},
/**If the calling process and user ID has not been granted
permission to access a specific URI, throw {@link SecurityException}. This is basically the same as calling
{@link #enforceUriPermission(Uri, int, int, int, String)} with
the pid and uid returned by {@link android.os.Binder#getCallingPid} and {@link android.os.Binder#getCallingUid}. One important difference is
that if you are not currently processing an IPC, this function
will always throw a SecurityException.
@param {Object {Uri}} uri The uri that is being checked.
@param {Number} modeFlags The access modes to enforce.
@param {String} message A message to include in the exception if it is thrown.
@see #checkCallingUriPermission(Uri, int)
*/
enforceCallingUriPermission : function( ) {},
/**If the calling process of an IPC <em>or you</em> has not been
granted permission to access a specific URI, throw {@link SecurityException}. This is the same as {@link #enforceCallingUriPermission}, except it grants your own
permissions if you are not currently processing an IPC. Use
with care!
@param {Object {Uri}} uri The uri that is being checked.
@param {Number} modeFlags The access modes to enforce.
@param {String} message A message to include in the exception if it is thrown.
@see #checkCallingOrSelfUriPermission(Uri, int)
*/
enforceCallingOrSelfUriPermission : function( ) {},
/**Enforce both a Uri and normal permission. This allows you to perform
both {@link #enforcePermission} and {@link #enforceUriPermission} in one
call.
@param {Object {Uri}} uri The Uri whose permission is to be checked, or null to not
do this check.
@param {String} readPermission The permission that provides overall read access,
or null to not do this check.
@param {String} writePermission The permission that provides overall write
access, or null to not do this check.
@param {Number} pid The process ID being checked against. Must be > 0.
@param {Number} uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
@param {Number} modeFlags The access modes to enforce.
@param {String} message A message to include in the exception if it is thrown.
@see #checkUriPermission(Uri, String, String, int, int, int)
*/
enforceUriPermission : function( ) {},
/**Return a new Context object for the given application name. This
Context is the same as what the named application gets when it is
launched, containing the same resources and class loader. Each call to
this method returns a new instance of a Context object; Context objects
are not shared, however they share common state (Resources, ClassLoader,
etc) so the Context instance itself is fairly lightweight.
<p>Throws {@link android.content.pm.PackageManager.NameNotFoundException} if there is no
application with the given package name.
<p>Throws {@link java.lang.SecurityException} if the Context requested
can not be loaded into the caller's process for security reasons (see
{@link #CONTEXT_INCLUDE_CODE} for more information}.
@param {String} packageName Name of the application's package.
@param {Number} flags Option flags.
@return {Object {android.content.Context}} A {@link Context} for the application.
@throws SecurityException
@throws PackageManager.NameNotFoundException if there is no application with
the given package name.
*/
createPackageContext : function( ) {},
/**Similar to {@link #createPackageContext(String, int)}, but with a
different {@link UserHandle}. For example, {@link #getContentResolver}()
will open any {@link Uri} as the given user.
@hide
*/
createPackageContextAsUser : function( ) {},
/**Creates a context given an {@link android.content.pm.ApplicationInfo}.
@hide
*/
createApplicationContext : function( ) {},
/**Return a new Context object for the given split name. The new Context has a ClassLoader and
Resources object that can access the split's and all of its dependencies' code/resources.
Each call to this method returns a new instance of a Context object;
Context objects are not shared, however common state (ClassLoader, other Resources for
the same split) may be so the Context itself can be fairly lightweight.
@param {String} splitName The name of the split to include, as declared in the split's
<code>AndroidManifest.xml</code>.
@return {Object {android.content.Context}} A {@link Context} with the given split's code and/or resources loaded.
*/
createContextForSplit : function( ) {},
/**Get the user associated with this context
@hide
*/
getUser : function( ) {},
/**Get the user associated with this context
@hide
*/
getUserId : function( ) {},
/**Return a new Context object for the current Context but whose resources
are adjusted to match the given Configuration. Each call to this method
returns a new instance of a Context object; Context objects are not
shared, however common state (ClassLoader, other Resources for the
same configuration) may be so the Context itself can be fairly lightweight.
@param {Object {Configuration}} overrideConfiguration A {@link Configuration} specifying what
values to modify in the base Configuration of the original Context's
resources. If the base configuration changes (such as due to an
orientation change), the resources of this context will also change except
for those that have been explicitly overridden with a value here.
@return {Object {android.content.Context}} A {@link Context} with the given configuration override.
*/
createConfigurationContext : function( ) {},
/**Return a new Context object for the current Context but whose resources
are adjusted to match the metrics of the given Display. Each call to this method
returns a new instance of a Context object; Context objects are not
shared, however common state (ClassLoader, other Resources for the
same configuration) may be so the Context itself can be fairly lightweight.
The returned display Context provides a {@link WindowManager}
(see {@link #getSystemService}(String)) that is configured to show windows
on the given display. The WindowManager's {@link WindowManager#getDefaultDisplay}
method can be used to retrieve the Display from the returned Context.
@param {Object {Display}} display A {@link Display} object specifying the display
for whose metrics the Context's resources should be tailored and upon which
new windows should be shown.
@return {Object {android.content.Context}} A {@link Context} for the display.
*/
createDisplayContext : function( ) {},
/**Return a new Context object for the current Context but whose storage
APIs are backed by device-protected storage.
<p>
On devices with direct boot, data stored in this location is encrypted
with a key tied to the physical device, and it can be accessed
immediately after the device has booted successfully, both
<em>before and after</em> the user has authenticated with their
credentials (such as a lock pattern or PIN).
<p>
Because device-protected data is available without user authentication,
you should carefully limit the data you store using this Context. For
example, storing sensitive authentication tokens or passwords in the
device-protected area is strongly discouraged.
<p>
If the underlying device does not have the ability to store
device-protected and credential-protected data using different keys, then
both storage areas will become available at the same time. They remain as
two distinct storage locations on disk, and only the window of
availability changes.
<p>
Each call to this method returns a new instance of a Context object;
Context objects are not shared, however common state (ClassLoader, other
Resources for the same configuration) may be so the Context itself can be
fairly lightweight.
@see #isDeviceProtectedStorage()
*/
createDeviceProtectedStorageContext : function( ) {},
/**Return a new Context object for the current Context but whose storage
APIs are backed by credential-protected storage. This is the default
storage area for apps unless
{@link android.R.attr#defaultToDeviceProtectedStorage} was requested.
<p>
On devices with direct boot, data stored in this location is encrypted
with a key tied to user credentials, which can be accessed
<em>only after</em> the user has entered their credentials (such as a
lock pattern or PIN).
<p>
If the underlying device does not have the ability to store
device-protected and credential-protected data using different keys, then
both storage areas will become available at the same time. They remain as
two distinct storage locations on disk, and only the window of
availability changes.
<p>
Each call to this method returns a new instance of a Context object;
Context objects are not shared, however common state (ClassLoader, other
Resources for the same configuration) may be so the Context itself can be
fairly lightweight.
@see #isCredentialProtectedStorage()
@hide
*/
createCredentialProtectedStorageContext : function( ) {},
/**Gets the display adjustments holder for this context. This information
is provided on a per-application or activity basis and is used to simulate lower density
display metrics for legacy applications and restricted screen sizes.
@param {Number} displayId The display id for which to get compatibility info.
@return {Object {android.view.DisplayAdjustments}} The compatibility info holder, or null if not required by the application.
@hide
*/
getDisplayAdjustments : function( ) {},
/**
@return {Object {android.view.Display}} Returns the {@link Display} object this context is associated with.
@hide
*/
getDisplay : function( ) {},
/**Gets the display ID.
@return {Number} display ID associated with this {@link Context}.
@hide
*/
getDisplayId : function( ) {},
/**
@hide
*/
updateDisplay : function( ) {},
/**Indicates whether this Context is restricted.
@return {Boolean} {@code true} if this Context is restricted, {@code false} otherwise.
@see #CONTEXT_RESTRICTED
*/
isRestricted : function( ) {},
/**Indicates if the storage APIs of this Context are backed by
device-protected storage.
@see #createDeviceProtectedStorageContext()
*/
isDeviceProtectedStorage : function( ) {},
/**Indicates if the storage APIs of this Context are backed by
credential-protected storage.
@see #createCredentialProtectedStorageContext()
@hide
*/
isCredentialProtectedStorage : function( ) {},
/**Returns true if the context can load unsafe resources, e.g. fonts.
@hide
*/
canLoadUnsafeResources : function( ) {},
/**
@hide
*/
getActivityToken : function( ) {},
/**
@hide
*/
getServiceDispatcher : function( ) {},
/**
@hide
*/
getIApplicationThread : function( ) {},
/**
@hide
*/
getMainThreadHandler : function( ) {},
/**
@hide
*/
getAutofillClient : function( ) {},
/**
@hide
*/
setAutofillClient : function( ) {},
/**
@hide
*/
getContentCaptureClient : function( ) {},
/**
@hide
*/
isAutofillCompatibilityEnabled : function( ) {},
/**
@hide
*/
getAutofillOptions : function( ) {},
/**
@hide
*/
setAutofillOptions : function( ) {},
/**Gets the Content Capture options for this context, or {@code null} if it's not whitelisted.
@hide
*/
getContentCaptureOptions : function( ) {},
/**
@hide
*/
setContentCaptureOptions : function( ) {},
/**Throws an exception if the Context is using system resources,
which are non-runtime-overlay-themable and may show inconsistent UI.
@hide
*/
assertRuntimeOverlayThemable : function( ) {},
};