public class ContextWrapper extends Context
ACCESSIBILITY_SERVICE, ACCOUNT_SERVICE, ACTIVITY_SERVICE, ALARM_SERVICE, APPWIDGET_SERVICE, AUDIO_SERVICE, BACKUP_SERVICE, BIND_ABOVE_CLIENT, BIND_ADJUST_WITH_ACTIVITY, BIND_ALLOW_OOM_MANAGEMENT, BIND_AUTO_CREATE, BIND_DEBUG_UNBIND, BIND_IMPORTANT, BIND_NOT_FOREGROUND, BIND_NOT_VISIBLE, BIND_VISIBLE, BIND_WAIVE_PRIORITY, BLUETOOTH_SERVICE, CLIPBOARD_SERVICE, CONNECTIVITY_SERVICE, CONTEXT_IGNORE_SECURITY, CONTEXT_INCLUDE_CODE, CONTEXT_RESTRICTED, COUNTRY_DETECTOR, DEVICE_POLICY_SERVICE, DISPLAY_SERVICE, DOWNLOAD_SERVICE, DROPBOX_SERVICE, INPUT_METHOD_SERVICE, INPUT_SERVICE, KEYGUARD_SERVICE, LAYOUT_INFLATER_SERVICE, LOCATION_SERVICE, MEDIA_ROUTER_SERVICE, MODE_APPEND, MODE_ENABLE_WRITE_AHEAD_LOGGING, MODE_MULTI_PROCESS, MODE_PRIVATE, MODE_WORLD_READABLE, MODE_WORLD_WRITEABLE, NETWORK_POLICY_SERVICE, NETWORK_STATS_SERVICE, NETWORKMANAGEMENT_SERVICE, NFC_SERVICE, NOTIFICATION_SERVICE, NSD_SERVICE, POWER_SERVICE, SCHEDULING_POLICY_SERVICE, SEARCH_SERVICE, SENSOR_SERVICE, SERIAL_SERVICE, SIP_SERVICE, STATUS_BAR_SERVICE, STORAGE_SERVICE, TELEPHONY_SERVICE, TEXT_SERVICES_MANAGER_SERVICE, THROTTLE_SERVICE, UI_MODE_SERVICE, UPDATE_LOCK_SERVICE, USB_SERVICE, USER_SERVICE, VIBRATOR_SERVICE, WALLPAPER_SERVICE, WIFI_P2P_SERVICE, WIFI_SERVICE, WINDOW_SERVICE
Constructor and Description |
---|
ContextWrapper(Context base) |
Modifier and Type | Method and Description |
---|---|
protected void |
attachBaseContext(Context base)
Set the base context for this ContextWrapper.
|
boolean |
bindService(Intent service,
ServiceConnection conn,
int flags)
Connect to an application service, creating it if needed.
|
boolean |
bindService(Intent service,
ServiceConnection conn,
int flags,
int userHandle)
Same as
Context.bindService(Intent, ServiceConnection, int) , but with an explicit userHandle
argument for use by system server and other multi-user aware code. |
int |
checkCallingOrSelfPermission(String permission)
Determine whether the calling process of an IPC or you have been
granted a particular permission.
|
int |
checkCallingOrSelfUriPermission(Uri uri,
int modeFlags)
Determine whether the calling process of an IPC or you has been granted
permission to access a specific URI.
|
int |
checkCallingPermission(String permission)
Determine whether the calling process of an IPC you are handling has been
granted a particular permission.
|
int |
checkCallingUriPermission(Uri uri,
int modeFlags)
Determine whether the calling process and user ID has been
granted permission to access a specific URI.
|
int |
checkPermission(String permission,
int pid,
int uid)
Determine whether the given permission is allowed for a particular
process and user ID running in the system.
|
int |
checkUriPermission(Uri uri,
int pid,
int uid,
int modeFlags)
Determine whether a particular process and user ID has been granted
permission to access a specific URI.
|
int |
checkUriPermission(Uri uri,
String readPermission,
String writePermission,
int pid,
int uid,
int modeFlags)
Check both a Uri and normal permission.
|
void |
clearWallpaper() |
Context |
createConfigurationContext(Configuration overrideConfiguration)
Return a new Context object for the current Context but whose resources
are adjusted to match the given Configuration.
|
Context |
createDisplayContext(Display display)
Return a new Context object for the current Context but whose resources
are adjusted to match the metrics of the given Display.
|
Context |
createPackageContext(String packageName,
int flags)
Return a new Context object for the given application name.
|
Context |
createPackageContextAsUser(String packageName,
int flags,
UserHandle user)
Similar to
Context.createPackageContext(String, int) , but with a
different UserHandle . |
String[] |
databaseList()
Returns an array of strings naming the private databases associated with
this Context's application package.
|
boolean |
deleteDatabase(String name)
Delete an existing private SQLiteDatabase associated with this Context's
application package.
|
boolean |
deleteFile(String name)
Delete the given private file associated with this Context's
application package.
|
void |
enforceCallingOrSelfPermission(String permission,
String message)
If neither you nor the calling process of an IPC you are
handling has been granted a particular permission, throw a
SecurityException . |
void |
enforceCallingOrSelfUriPermission(Uri uri,
int modeFlags,
String message)
If the calling process of an IPC or you has not been
granted permission to access a specific URI, throw
SecurityException . |
void |
enforceCallingPermission(String permission,
String message)
If the calling process of an IPC you are handling has not been
granted a particular permission, throw a
SecurityException . |
void |
enforceCallingUriPermission(Uri uri,
int modeFlags,
String message)
If the calling process and user ID has not been granted
permission to access a specific URI, throw
SecurityException . |
void |
enforcePermission(String permission,
int pid,
int uid,
String message)
If the given permission is not allowed for a particular process
and user ID running in the system, throw a
SecurityException . |
void |
enforceUriPermission(Uri uri,
int pid,
int uid,
int modeFlags,
String message)
If a particular process and user ID has not been granted
permission to access a specific URI, throw
SecurityException . |
void |
enforceUriPermission(Uri uri,
String readPermission,
String writePermission,
int pid,
int uid,
int modeFlags,
String message)
Enforce both a Uri and normal permission.
|
String[] |
fileList()
Returns an array of strings naming the private files associated with
this Context's application package.
|
Context |
getApplicationContext()
Return the context of the single, global Application object of the
current process.
|
ApplicationInfo |
getApplicationInfo()
Return the full application info for this context's package.
|
AssetManager |
getAssets()
Return an AssetManager instance for your application's package.
|
Context |
getBaseContext() |
File |
getCacheDir()
Returns the absolute path to the application specific cache directory
on the filesystem.
|
ClassLoader |
getClassLoader()
Return a class loader you can use to retrieve classes in this package.
|
CompatibilityInfoHolder |
getCompatibilityInfo(int displayId)
Gets the compatibility info holder for this context.
|
ContentResolver |
getContentResolver()
Return a ContentResolver instance for your application's package.
|
File |
getDatabasePath(String name)
Returns the absolute path on the filesystem where a database created with
Context.openOrCreateDatabase(java.lang.String, int, android.database.sqlite.SQLiteDatabase.CursorFactory) is stored. |
File |
getDir(String name,
int mode)
Retrieve, creating if needed, a new directory in which the application
can place its own custom data files.
|
File |
getExternalCacheDir()
Returns the absolute path to the directory on the external filesystem
(that is somewhere on
Environment.getExternalStorageDirectory() where the application can
place cache files it owns. |
File |
getExternalFilesDir(String type)
Returns the absolute path to the directory on the external filesystem
(that is somewhere on
Environment.getExternalStorageDirectory() ) where the application can
place persistent files it owns. |
File |
getFilesDir()
Returns the absolute path to the directory on the filesystem where
files created with
Context.openFileOutput(java.lang.String, int) are stored. |
File |
getFileStreamPath(String name)
Returns the absolute path on the filesystem where a file created with
Context.openFileOutput(java.lang.String, int) is stored. |
Looper |
getMainLooper()
Return the Looper for the main thread of the current process.
|
File |
getObbDir()
Return the directory where this application's OBB files (if there
are any) can be found.
|
String |
getPackageCodePath()
Return the full path to this context's primary Android package.
|
PackageManager |
getPackageManager()
Return PackageManager instance to find global package information.
|
String |
getPackageName()
Return the name of this application's package.
|
String |
getPackageResourcePath()
Return the full path to this context's primary Android package.
|
Resources |
getResources()
Return a Resources instance for your application's package.
|
SharedPreferences |
getSharedPreferences(String name,
int mode)
Retrieve and hold the contents of the preferences file 'name', returning
a SharedPreferences through which you can retrieve and modify its
values.
|
File |
getSharedPrefsFile(String name)
Return the full path to the shared prefs file for the given prefs group name.
|
Object |
getSystemService(String name)
Return the handle to a system-level service by name.
|
Resources.Theme |
getTheme()
Return the Theme object associated with this Context.
|
int |
getThemeResId() |
Drawable |
getWallpaper() |
int |
getWallpaperDesiredMinimumHeight() |
int |
getWallpaperDesiredMinimumWidth() |
void |
grantUriPermission(String toPackage,
Uri uri,
int modeFlags)
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.
|
boolean |
isRestricted()
Indicates whether this Context is restricted.
|
FileInputStream |
openFileInput(String name)
Open a private file associated with this Context's application package
for reading.
|
FileOutputStream |
openFileOutput(String name,
int mode)
Open a private file associated with this Context's application package
for writing.
|
SQLiteDatabase |
openOrCreateDatabase(String name,
int mode,
SQLiteDatabase.CursorFactory factory)
Open a new private SQLiteDatabase associated with this Context's
application package.
|
SQLiteDatabase |
openOrCreateDatabase(String name,
int mode,
SQLiteDatabase.CursorFactory factory,
DatabaseErrorHandler errorHandler)
Open a new private SQLiteDatabase associated with this Context's
application package.
|
Drawable |
peekWallpaper() |
Intent |
registerReceiver(BroadcastReceiver receiver,
IntentFilter filter)
Register a BroadcastReceiver to be run in the main activity thread.
|
Intent |
registerReceiver(BroadcastReceiver receiver,
IntentFilter filter,
String broadcastPermission,
Handler scheduler)
Register to receive intent broadcasts, to run in the context of
scheduler.
|
Intent |
registerReceiverAsUser(BroadcastReceiver receiver,
UserHandle user,
IntentFilter filter,
String broadcastPermission,
Handler scheduler) |
void |
removeStickyBroadcast(Intent intent)
Remove the data previously sent with
Context.sendStickyBroadcast(android.content.Intent) ,
so that it is as if the sticky broadcast had never happened. |
void |
removeStickyBroadcastAsUser(Intent intent,
UserHandle user)
Version of
Context.removeStickyBroadcast(Intent) that allows you to specify the
user the broadcast will be sent to. |
void |
revokeUriPermission(Uri uri,
int modeFlags)
Remove all permissions to access a particular content provider Uri
that were previously added with
Context.grantUriPermission(java.lang.String, android.net.Uri, int) . |
void |
sendBroadcast(Intent intent)
Broadcast the given intent to all interested BroadcastReceivers.
|
void |
sendBroadcast(Intent intent,
String receiverPermission)
Broadcast the given intent to all interested BroadcastReceivers, allowing
an optional required permission to be enforced.
|
void |
sendBroadcastAsUser(Intent intent,
UserHandle user)
Version of
Context.sendBroadcast(Intent) that allows you to specify the
user the broadcast will be sent to. |
void |
sendBroadcastAsUser(Intent intent,
UserHandle user,
String receiverPermission)
Version of
Context.sendBroadcast(Intent, String) that allows you to specify the
user the broadcast will be sent to. |
void |
sendOrderedBroadcast(Intent intent,
String receiverPermission)
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.
|
void |
sendOrderedBroadcast(Intent intent,
String receiverPermission,
BroadcastReceiver resultReceiver,
Handler scheduler,
int initialCode,
String initialData,
Bundle initialExtras)
Version of
Context.sendBroadcast(Intent) that allows you to
receive data back from the broadcast. |
void |
sendOrderedBroadcastAsUser(Intent intent,
UserHandle user,
String receiverPermission,
BroadcastReceiver resultReceiver,
Handler scheduler,
int initialCode,
String initialData,
Bundle initialExtras)
Version of
Context.sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
that allows you to specify the
user the broadcast will be sent to. |
void |
sendStickyBroadcast(Intent intent)
Perform a
Context.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 Context.registerReceiver(BroadcastReceiver, IntentFilter) . |
void |
sendStickyBroadcastAsUser(Intent intent,
UserHandle user)
Version of
Context.sendStickyBroadcast(Intent) that allows you to specify the
user the broadcast will be sent to. |
void |
sendStickyOrderedBroadcast(Intent intent,
BroadcastReceiver resultReceiver,
Handler scheduler,
int initialCode,
String initialData,
Bundle initialExtras)
Version of
Context.sendStickyBroadcast(android.content.Intent) that allows you to
receive data back from the broadcast. |
void |
sendStickyOrderedBroadcastAsUser(Intent intent,
UserHandle user,
BroadcastReceiver resultReceiver,
Handler scheduler,
int initialCode,
String initialData,
Bundle initialExtras)
Version of
Context.sendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, int, String, Bundle)
that allows you to specify the
user the broadcast will be sent to. |
void |
setTheme(int resid)
Set the base theme for this context.
|
void |
setWallpaper(Bitmap bitmap) |
void |
setWallpaper(InputStream data) |
void |
startActivities(Intent[] intents)
Same as
Context.startActivities(Intent[], Bundle) with no options
specified. |
void |
startActivities(Intent[] intents,
Bundle options)
Launch multiple new activities.
|
void |
startActivitiesAsUser(Intent[] intents,
Bundle options,
UserHandle userHandle) |
void |
startActivity(Intent intent)
Same as
Context.startActivity(Intent, Bundle) with no options
specified. |
void |
startActivity(Intent intent,
Bundle options)
Launch a new activity.
|
void |
startActivityAsUser(Intent intent,
Bundle options,
UserHandle user)
Version of
Context.startActivity(Intent, Bundle) that allows you to specify the
user the activity will be started for. |
void |
startActivityAsUser(Intent intent,
UserHandle user)
Version of
Context.startActivity(Intent) that allows you to specify the
user the activity will be started for. |
boolean |
startInstrumentation(ComponentName className,
String profileFile,
Bundle arguments)
Start executing an
Instrumentation class. |
void |
startIntentSender(IntentSender intent,
Intent fillInIntent,
int flagsMask,
int flagsValues,
int extraFlags)
Same as
Context.startIntentSender(IntentSender, Intent, int, int, int, Bundle)
with no options specified. |
void |
startIntentSender(IntentSender intent,
Intent fillInIntent,
int flagsMask,
int flagsValues,
int extraFlags,
Bundle options)
Like
Context.startActivity(Intent, Bundle) , but taking a IntentSender
to start. |
ComponentName |
startService(Intent service)
Request that a given application service be started.
|
ComponentName |
startServiceAsUser(Intent service,
UserHandle user) |
boolean |
stopService(Intent name)
Request that a given application service be stopped.
|
boolean |
stopServiceAsUser(Intent name,
UserHandle user) |
void |
unbindService(ServiceConnection conn)
Disconnect from an application service.
|
void |
unregisterReceiver(BroadcastReceiver receiver)
Unregister a previously registered BroadcastReceiver.
|
getString, getString, getText, obtainStyledAttributes, obtainStyledAttributes, obtainStyledAttributes, obtainStyledAttributes, registerComponentCallbacks, unregisterComponentCallbacks
public ContextWrapper(Context base)
protected void attachBaseContext(Context base)
base
- The new base context for this wrapper.public Context getBaseContext()
public AssetManager getAssets()
Context
public Resources getResources()
Context
getResources
in class Context
public PackageManager getPackageManager()
Context
getPackageManager
in class Context
public ContentResolver getContentResolver()
Context
getContentResolver
in class Context
public Looper getMainLooper()
Context
getMainLooper
in class Context
public Context getApplicationContext()
Context
Consider for example how this interacts with
Context.registerReceiver(BroadcastReceiver, IntentFilter)
:
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.
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.
getApplicationContext
in class Context
public void setTheme(int resid)
Context
Activity.setContentView(int)
or
LayoutInflater.inflate(int, android.view.ViewGroup)
).public int getThemeResId()
getThemeResId
in class Context
public Resources.Theme getTheme()
Context
public ClassLoader getClassLoader()
Context
getClassLoader
in class Context
public String getPackageName()
Context
getPackageName
in class Context
public ApplicationInfo getApplicationInfo()
Context
getApplicationInfo
in class Context
public String getPackageResourcePath()
Context
Note: this is not generally useful for applications, since they should not be directly accessing the file system.
getPackageResourcePath
in class Context
public String getPackageCodePath()
Context
Note: this is not generally useful for applications, since they should not be directly accessing the file system.
getPackageCodePath
in class Context
public File getSharedPrefsFile(String name)
Context
Note: this is not generally useful for applications, since they should not be directly accessing the file system.
getSharedPrefsFile
in class Context
public SharedPreferences getSharedPreferences(String name, int mode)
Context
getSharedPreferences
in class Context
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()).mode
- Operating mode. Use 0 or Context.MODE_PRIVATE
for the
default operation, Context.MODE_WORLD_READABLE
and Context.MODE_WORLD_WRITEABLE
to control permissions. The bit
Context.MODE_MULTI_PROCESS
can also be used if multiple processes
are mutating the same SharedPreferences file. Context.MODE_MULTI_PROCESS
is always on in apps targetting Gingerbread (Android 2.3) and below, and
off by default in later versions.Context.MODE_PRIVATE
,
Context.MODE_WORLD_READABLE
,
Context.MODE_WORLD_WRITEABLE
,
Context.MODE_MULTI_PROCESS
public FileInputStream openFileInput(String name) throws FileNotFoundException
Context
openFileInput
in class Context
name
- The name of the file to open; can not contain path
separators.FileNotFoundException
Context.openFileOutput(java.lang.String, int)
,
Context.fileList()
,
Context.deleteFile(java.lang.String)
,
FileInputStream.FileInputStream(String)
public FileOutputStream openFileOutput(String name, int mode) throws FileNotFoundException
Context
openFileOutput
in class Context
name
- The name of the file to open; can not contain path
separators.mode
- Operating mode. Use 0 or Context.MODE_PRIVATE
for the
default operation, Context.MODE_APPEND
to append to an existing file,
Context.MODE_WORLD_READABLE
and Context.MODE_WORLD_WRITEABLE
to control
permissions.FileNotFoundException
Context.MODE_APPEND
,
Context.MODE_PRIVATE
,
Context.MODE_WORLD_READABLE
,
Context.MODE_WORLD_WRITEABLE
,
Context.openFileInput(java.lang.String)
,
Context.fileList()
,
Context.deleteFile(java.lang.String)
,
FileOutputStream.FileOutputStream(String)
public boolean deleteFile(String name)
Context
deleteFile
in class Context
name
- The name of the file to delete; can not contain path
separators.Context.openFileInput(java.lang.String)
,
Context.openFileOutput(java.lang.String, int)
,
Context.fileList()
,
File.delete()
public File getFileStreamPath(String name)
Context
Context.openFileOutput(java.lang.String, int)
is stored.getFileStreamPath
in class Context
name
- The name of the file for which you would like to get
its path.Context.openFileOutput(java.lang.String, int)
,
Context.getFilesDir()
,
Context.getDir(java.lang.String, int)
public String[] fileList()
Context
fileList
in class Context
Context.openFileInput(java.lang.String)
,
Context.openFileOutput(java.lang.String, int)
,
Context.deleteFile(java.lang.String)
public File getFilesDir()
Context
Context.openFileOutput(java.lang.String, int)
are stored.getFilesDir
in class Context
Context.openFileOutput(java.lang.String, int)
,
Context.getFileStreamPath(java.lang.String)
,
Context.getDir(java.lang.String, int)
public File getExternalFilesDir(String type)
Context
Environment.getExternalStorageDirectory()
) where the application can
place persistent files it owns. These files are private to the
applications, and not typically visible to the user as media.
This is like Context.getFilesDir()
in that these
files will be deleted when the application is uninstalled, however there
are some important differences:
Environment
for information in the storage state.
On devices with multiple users (as described by UserManager
),
each user has their own isolated external storage. Applications only
have access to the external storage for the user they're running as.
Here is an example of typical code to manipulate a file in an application's private storage:
If you supply a non-null type 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
MediaScannerConnection.scanFile
.
Note that this is not the same as
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
Environment.getExternalStoragePublicDirectory()
, the directory
returned here will be automatically created for you.
Here is an example of typical code to manipulate a picture in an application's private storage and add it to the media database:
Writing to this path requires the
android.Manifest.permission#WRITE_EXTERNAL_STORAGE
permission.
getExternalFilesDir
in class Context
type
- The type of files directory to return. May be null for
the root of the files directory or one of
the following Environment constants for a subdirectory:
Environment.DIRECTORY_MUSIC
,
Environment.DIRECTORY_PODCASTS
,
Environment.DIRECTORY_RINGTONES
,
Environment.DIRECTORY_ALARMS
,
Environment.DIRECTORY_NOTIFICATIONS
,
Environment.DIRECTORY_PICTURES
, or
Environment.DIRECTORY_MOVIES
.Context.getFilesDir()
,
Environment.getExternalStoragePublicDirectory(java.lang.String)
public File getObbDir()
Context
On devices with multiple users (as described by 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.
public File getCacheDir()
Context
getCacheDir
in class Context
Context.openFileOutput(java.lang.String, int)
,
Context.getFileStreamPath(java.lang.String)
,
Context.getDir(java.lang.String, int)
public File getExternalCacheDir()
Context
Environment.getExternalStorageDirectory()
where the application can
place cache files it owns.
This is like Context.getCacheDir()
in that these
files will be deleted when the application is uninstalled, however there
are some important differences:
Build.VERSION_CODES.JELLY_BEAN_MR1
or later and
Environment.isExternalStorageEmulated()
returns true. Note that you should
be managing the maximum space you will use for these anyway, just like
with Context.getCacheDir()
.
Environment
for information in the storage state.
On devices with multiple users (as described by UserManager
),
each user has their own isolated external storage. Applications only
have access to the external storage for the user they're running as.
Writing to this path requires the
android.Manifest.permission#WRITE_EXTERNAL_STORAGE
permission.
getExternalCacheDir
in class Context
Context.getCacheDir()
public File getDir(String name, int mode)
Context
getDir
in class Context
name
- Name of the directory to retrieve. This is a directory
that is created as part of your application data.mode
- Operating mode. Use 0 or Context.MODE_PRIVATE
for the
default operation, Context.MODE_WORLD_READABLE
and
Context.MODE_WORLD_WRITEABLE
to control permissions.Context.openFileOutput(String, int)
public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory)
Context
openOrCreateDatabase
in class Context
name
- The name (unique in the application package) of the database.mode
- Operating mode. Use 0 or Context.MODE_PRIVATE
for the
default operation, Context.MODE_WORLD_READABLE
and Context.MODE_WORLD_WRITEABLE
to control permissions.
Use Context.MODE_ENABLE_WRITE_AHEAD_LOGGING
to enable write-ahead logging by default.factory
- An optional factory class that is called to instantiate a
cursor when query is called.Context.MODE_PRIVATE
,
Context.MODE_WORLD_READABLE
,
Context.MODE_WORLD_WRITEABLE
,
Context.MODE_ENABLE_WRITE_AHEAD_LOGGING
,
Context.deleteDatabase(java.lang.String)
public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler)
Context
Accepts input param: a concrete instance of DatabaseErrorHandler
to be
used to handle corruption when sqlite reports database corruption.
openOrCreateDatabase
in class Context
name
- The name (unique in the application package) of the database.mode
- Operating mode. Use 0 or Context.MODE_PRIVATE
for the
default operation, Context.MODE_WORLD_READABLE
and Context.MODE_WORLD_WRITEABLE
to control permissions.
Use Context.MODE_ENABLE_WRITE_AHEAD_LOGGING
to enable write-ahead logging by default.factory
- An optional factory class that is called to instantiate a
cursor when query is called.errorHandler
- the DatabaseErrorHandler
to be used when sqlite reports database
corruption. if null, DefaultDatabaseErrorHandler
is assumed.Context.MODE_PRIVATE
,
Context.MODE_WORLD_READABLE
,
Context.MODE_WORLD_WRITEABLE
,
Context.MODE_ENABLE_WRITE_AHEAD_LOGGING
,
Context.deleteDatabase(java.lang.String)
public boolean deleteDatabase(String name)
Context
deleteDatabase
in class Context
name
- The name (unique in the application package) of the
database.Context.openOrCreateDatabase(java.lang.String, int, android.database.sqlite.SQLiteDatabase.CursorFactory)
public File getDatabasePath(String name)
Context
Context.openOrCreateDatabase(java.lang.String, int, android.database.sqlite.SQLiteDatabase.CursorFactory)
is stored.getDatabasePath
in class Context
name
- The name of the database for which you would like to get
its path.Context.openOrCreateDatabase(java.lang.String, int, android.database.sqlite.SQLiteDatabase.CursorFactory)
public String[] databaseList()
Context
databaseList
in class Context
Context.openOrCreateDatabase(java.lang.String, int, android.database.sqlite.SQLiteDatabase.CursorFactory)
,
Context.deleteDatabase(java.lang.String)
public Drawable getWallpaper()
getWallpaper
in class Context
public Drawable peekWallpaper()
peekWallpaper
in class Context
public int getWallpaperDesiredMinimumWidth()
getWallpaperDesiredMinimumWidth
in class Context
public int getWallpaperDesiredMinimumHeight()
getWallpaperDesiredMinimumHeight
in class Context
public void setWallpaper(Bitmap bitmap) throws IOException
setWallpaper
in class Context
IOException
public void setWallpaper(InputStream data) throws IOException
setWallpaper
in class Context
IOException
public void clearWallpaper() throws IOException
clearWallpaper
in class Context
IOException
public void startActivity(Intent intent)
Context
Context.startActivity(Intent, Bundle)
with no options
specified.startActivity
in class Context
intent
- The description of the activity to start.#startActivity(Intent, Bundle)}
,
PackageManager.resolveActivity(android.content.Intent, int)
public void startActivityAsUser(Intent intent, UserHandle user)
Context
Context.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. Using it requires holding
the INTERACT_ACROSS_USERS_FULL permission.startActivityAsUser
in class Context
intent
- The description of the activity to start.user
- The UserHandle of the user to start this activity for.public void startActivity(Intent intent, Bundle options)
Context
Note that if this method is being called from outside of an
Activity
Context, then the Intent must include
the 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.
This method throws ActivityNotFoundException
if there was no Activity found to run the given Intent.
startActivity
in class Context
intent
- The description of the activity to start.options
- Additional options for how the Activity should be started.
May be null if there are no options. See ActivityOptions
for how to build the Bundle supplied here; there are no supported definitions
for building it manually.Context.startActivity(Intent)
,
PackageManager.resolveActivity(android.content.Intent, int)
public void startActivityAsUser(Intent intent, Bundle options, UserHandle user)
Context
Context.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. Using it requires holding
the INTERACT_ACROSS_USERS_FULL permission.startActivityAsUser
in class Context
intent
- The description of the activity to start.options
- Additional options for how the Activity should be started.
May be null if there are no options. See ActivityOptions
for how to build the Bundle supplied here; there are no supported definitions
for building it manually.public void startActivities(Intent[] intents)
Context
Context.startActivities(Intent[], Bundle)
with no options
specified.startActivities
in class Context
intents
- An array of Intents to be started.#startActivities(Intent[], Bundle)}
,
PackageManager.resolveActivity(android.content.Intent, int)
public void startActivities(Intent[] intents, Bundle options)
Context
Context.startActivity(Intent)
for the first Intent in the array,
that activity during its creation calling Context.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).
This method throws ActivityNotFoundException
if there was no Activity found for any 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.
startActivities
in class Context
intents
- An array of Intents to be started.options
- Additional options for how the Activity should be started.
See Context.startActivity(Intent, Bundle)
for more details.#startActivities(Intent[])}
,
PackageManager.resolveActivity(android.content.Intent, int)
public void startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle)
startActivitiesAsUser
in class Context
intents
- An array of Intents to be started.options
- Additional options for how the Activity should be started.userHandle
- The user for whom to launch the activities
See Context.startActivity(Intent, Bundle)
for more details.#startActivities(Intent[])}
,
PackageManager.resolveActivity(android.content.Intent, int)
public void startIntentSender(IntentSender intent, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) throws IntentSender.SendIntentException
Context
Context.startIntentSender(IntentSender, Intent, int, int, int, Bundle)
with no options specified.startIntentSender
in class Context
intent
- The IntentSender to launch.fillInIntent
- If non-null, this will be provided as the
intent parameter to IntentSender.sendIntent(android.content.Context, int, android.content.Intent, android.content.IntentSender.OnFinished, android.os.Handler)
.flagsMask
- Intent flags in the original IntentSender that you
would like to change.flagsValues
- Desired values for any bits set in
flagsMaskextraFlags
- Always set to 0.IntentSender.SendIntentException
Context.startActivity(Intent)
,
Context.startIntentSender(IntentSender, Intent, int, int, int, Bundle)
public void startIntentSender(IntentSender intent, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) throws IntentSender.SendIntentException
Context
Context.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 Context.startActivity(Intent)
here; otherwise, its associated action will be executed (such as
sending a broadcast) as if you had called
IntentSender.sendIntent
on it.startIntentSender
in class Context
intent
- The IntentSender to launch.fillInIntent
- If non-null, this will be provided as the
intent parameter to IntentSender.sendIntent(android.content.Context, int, android.content.Intent, android.content.IntentSender.OnFinished, android.os.Handler)
.flagsMask
- Intent flags in the original IntentSender that you
would like to change.flagsValues
- Desired values for any bits set in
flagsMaskextraFlags
- Always set to 0.options
- Additional options for how the Activity should be started.
See 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.IntentSender.SendIntentException
Context.startActivity(Intent, Bundle)
,
Context.startIntentSender(IntentSender, Intent, int, int, int)
public void sendBroadcast(Intent intent)
Context
Context.sendOrderedBroadcast(Intent, String)
.
See BroadcastReceiver
for more information on Intent broadcasts.
sendBroadcast
in class Context
intent
- The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.BroadcastReceiver
,
Context.registerReceiver(android.content.BroadcastReceiver, android.content.IntentFilter)
,
Context.sendBroadcast(Intent, String)
,
Context.sendOrderedBroadcast(Intent, String)
,
Context.sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
public void sendBroadcast(Intent intent, String receiverPermission)
Context
Context.sendOrderedBroadcast(Intent, String)
.
See BroadcastReceiver
for more information on Intent broadcasts.
sendBroadcast
in class Context
intent
- The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.receiverPermission
- (optional) String naming a permission that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.BroadcastReceiver
,
Context.registerReceiver(android.content.BroadcastReceiver, android.content.IntentFilter)
,
Context.sendBroadcast(Intent)
,
Context.sendOrderedBroadcast(Intent, String)
,
Context.sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
public void sendOrderedBroadcast(Intent intent, String receiverPermission)
Context
See BroadcastReceiver
for more information on Intent broadcasts.
sendOrderedBroadcast
in class Context
intent
- The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.receiverPermission
- (optional) String naming a permissions that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.BroadcastReceiver
,
Context.registerReceiver(android.content.BroadcastReceiver, android.content.IntentFilter)
,
Context.sendBroadcast(Intent)
,
Context.sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
public void sendOrderedBroadcast(Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, String initialData, Bundle initialExtras)
Context
Context.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
BroadcastReceiver.onReceive(android.content.Context, android.content.Intent)
method will be called with
the result values collected from the other receivers. The broadcast will
be serialized in the same way as calling
Context.sendOrderedBroadcast(Intent, String)
.
Like Context.sendBroadcast(Intent)
, this method is
asynchronous; it will return before
resultReceiver.onReceive() is called.
See BroadcastReceiver
for more information on Intent broadcasts.
sendOrderedBroadcast
in class Context
intent
- The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.receiverPermission
- String naming a permissions that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.resultReceiver
- Your own BroadcastReceiver to treat as the final
receiver of the broadcast.scheduler
- A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.initialCode
- An initial value for the result code. Often
Activity.RESULT_OK.initialData
- An initial value for the result data. Often
null.initialExtras
- An initial value for the result extras. Often
null.Context.sendBroadcast(Intent)
,
Context.sendBroadcast(Intent, String)
,
Context.sendOrderedBroadcast(Intent, String)
,
Context.sendStickyBroadcast(Intent)
,
Context.sendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, int, String, Bundle)
,
BroadcastReceiver
,
Context.registerReceiver(android.content.BroadcastReceiver, android.content.IntentFilter)
,
Activity.RESULT_OK
public void sendBroadcastAsUser(Intent intent, UserHandle user)
Context
Context.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. Using it requires holding
the INTERACT_ACROSS_USERS permission.sendBroadcastAsUser
in class Context
intent
- The intent to broadcastuser
- UserHandle to send the intent to.Context.sendBroadcast(Intent)
public void sendBroadcastAsUser(Intent intent, UserHandle user, String receiverPermission)
Context
Context.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. Using it requires holding
the INTERACT_ACROSS_USERS permission.sendBroadcastAsUser
in class Context
intent
- The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.user
- UserHandle to send the intent to.receiverPermission
- (optional) String naming a permission that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.Context.sendBroadcast(Intent, String)
public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, String initialData, Bundle initialExtras)
Context
Context.sendOrderedBroadcast(Intent, String, 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. Using it requires holding
the INTERACT_ACROSS_USERS permission.
See BroadcastReceiver
for more information on Intent broadcasts.
sendOrderedBroadcastAsUser
in class Context
intent
- The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.user
- UserHandle to send the intent to.receiverPermission
- String naming a permissions that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.resultReceiver
- Your own BroadcastReceiver to treat as the final
receiver of the broadcast.scheduler
- A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.initialCode
- An initial value for the result code. Often
Activity.RESULT_OK.initialData
- An initial value for the result data. Often
null.initialExtras
- An initial value for the result extras. Often
null.Context.sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
public void sendStickyBroadcast(Intent intent)
Context
Context.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 Context.registerReceiver(BroadcastReceiver, IntentFilter)
. In
all other ways, this behaves the same as
Context.sendBroadcast(Intent)
.
You must hold the android.Manifest.permission#BROADCAST_STICKY
permission in order to use this API. If you do not hold that
permission, SecurityException
will be thrown.
sendStickyBroadcast
in class Context
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.Context.sendBroadcast(Intent)
,
Context.sendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, int, String, Bundle)
public void sendStickyOrderedBroadcast(Intent intent, BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, String initialData, Bundle initialExtras)
Context
Context.sendStickyBroadcast(android.content.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
BroadcastReceiver.onReceive(android.content.Context, android.content.Intent)
method will be called with
the result values collected from the other receivers. The broadcast will
be serialized in the same way as calling
Context.sendOrderedBroadcast(Intent, String)
.
Like Context.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.
See BroadcastReceiver
for more information on Intent broadcasts.
sendStickyOrderedBroadcast
in class Context
intent
- The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.resultReceiver
- Your own BroadcastReceiver to treat as the final
receiver of the broadcast.scheduler
- A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.initialCode
- An initial value for the result code. Often
Activity.RESULT_OK.initialData
- An initial value for the result data. Often
null.initialExtras
- An initial value for the result extras. Often
null.Context.sendBroadcast(Intent)
,
Context.sendBroadcast(Intent, String)
,
Context.sendOrderedBroadcast(Intent, String)
,
Context.sendStickyBroadcast(Intent)
,
BroadcastReceiver
,
Context.registerReceiver(android.content.BroadcastReceiver, android.content.IntentFilter)
,
Activity.RESULT_OK
public void removeStickyBroadcast(Intent intent)
Context
Context.sendStickyBroadcast(android.content.Intent)
,
so that it is as if the sticky broadcast had never happened.
You must hold the android.Manifest.permission#BROADCAST_STICKY
permission in order to use this API. If you do not hold that
permission, SecurityException
will be thrown.
removeStickyBroadcast
in class Context
intent
- The Intent that was previously broadcast.Context.sendStickyBroadcast(android.content.Intent)
public void sendStickyBroadcastAsUser(Intent intent, UserHandle user)
Context
Context.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. Using it requires holding
the INTERACT_ACROSS_USERS permission.sendStickyBroadcastAsUser
in class Context
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.user
- UserHandle to send the intent to.Context.sendBroadcast(Intent)
public void sendStickyOrderedBroadcastAsUser(Intent intent, UserHandle user, BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, String initialData, Bundle initialExtras)
Context
Context.sendStickyOrderedBroadcast(Intent, 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. Using it requires holding
the INTERACT_ACROSS_USERS permission.
See BroadcastReceiver
for more information on Intent broadcasts.
sendStickyOrderedBroadcastAsUser
in class Context
intent
- The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.user
- UserHandle to send the intent to.resultReceiver
- Your own BroadcastReceiver to treat as the final
receiver of the broadcast.scheduler
- A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.initialCode
- An initial value for the result code. Often
Activity.RESULT_OK.initialData
- An initial value for the result data. Often
null.initialExtras
- An initial value for the result extras. Often
null.Context.sendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, int, String, Bundle)
public void removeStickyBroadcastAsUser(Intent intent, UserHandle user)
Context
Context.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. Using it requires holding
the INTERACT_ACROSS_USERS permission.
You must hold the android.Manifest.permission#BROADCAST_STICKY
permission in order to use this API. If you do not hold that
permission, SecurityException
will be thrown.
removeStickyBroadcastAsUser
in class Context
intent
- The Intent that was previously broadcast.user
- UserHandle to remove the sticky broadcast from.Context.sendStickyBroadcastAsUser(android.content.Intent, android.os.UserHandle)
public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter)
Context
The system may broadcast Intents that are "sticky" -- these stay around after the broadcast as 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 and sent to your receiver as if it had just been broadcast.
There may be multiple sticky Intents that match filter, in which case each of these will be sent to receiver. 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.
If you know the Intent your are registering for is sticky, you can supply null for your receiver. In this case, no receiver is registered -- the function simply returns the sticky Intent that matches filter. In the case of multiple matches, the same rules as described above apply.
See BroadcastReceiver
for more information on Intent broadcasts.
As of Build.VERSION_CODES.ICE_CREAM_SANDWICH
, receivers
registered with this method will correctly respect the
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.
Note: this method cannot be called from a
BroadcastReceiver
component; 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 Context.registerReceiver(android.content.BroadcastReceiver, android.content.IntentFilter)
, since the lifetime of such a
registered BroadcastReceiver is tied to the object that registered it.
registerReceiver
in class Context
receiver
- The BroadcastReceiver to handle the broadcast.filter
- Selects the Intent broadcasts to be received.Context.registerReceiver(BroadcastReceiver, IntentFilter, String, Handler)
,
Context.sendBroadcast(android.content.Intent)
,
Context.unregisterReceiver(android.content.BroadcastReceiver)
public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, String broadcastPermission, Handler scheduler)
Context
Context.registerReceiver(BroadcastReceiver, 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.
See BroadcastReceiver
for more information on Intent broadcasts.
As of Build.VERSION_CODES.ICE_CREAM_SANDWICH
, receivers
registered with this method will correctly respect the
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.
registerReceiver
in class Context
receiver
- The BroadcastReceiver to handle the broadcast.filter
- Selects the Intent broadcasts to be received.broadcastPermission
- String naming a permissions that a
broadcaster must hold in order to send an Intent to you. If null,
no permission is required.scheduler
- Handler identifying the thread that will receive
the Intent. If null, the main thread of the process will be used.Context.registerReceiver(BroadcastReceiver, IntentFilter)
,
Context.sendBroadcast(android.content.Intent)
,
Context.unregisterReceiver(android.content.BroadcastReceiver)
public Intent registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user, IntentFilter filter, String broadcastPermission, Handler scheduler)
registerReceiverAsUser
in class Context
receiver
- The BroadcastReceiver to handle the broadcast.user
- UserHandle to send the intent to.filter
- Selects the Intent broadcasts to be received.broadcastPermission
- String naming a permissions that a
broadcaster must hold in order to send an Intent to you. If null,
no permission is required.scheduler
- Handler identifying the thread that will receive
the Intent. If null, the main thread of the process will be used.#registerReceiver(BroadcastReceiver, IntentFilter, String, Handler
,
Context.sendBroadcast(android.content.Intent)
,
Context.unregisterReceiver(android.content.BroadcastReceiver)
public void unregisterReceiver(BroadcastReceiver receiver)
Context
unregisterReceiver
in class Context
receiver
- The BroadcastReceiver to unregister.Context.registerReceiver(android.content.BroadcastReceiver, android.content.IntentFilter)
public ComponentName startService(Intent service)
Context
Every call to this method will result in a corresponding call to
the target service's Service.onStartCommand(android.content.Intent, int, int)
method,
with the intent given here. This provides a convenient way
to submit jobs to a service without having to bind and call on to its
interface.
Using startService() overrides the default service lifetime that is
managed by Context.bindService(android.content.Intent, android.content.ServiceConnection, int)
: it requires the service to remain
running until Context.stopService(android.content.Intent)
is called, regardless of whether
any clients are connected to it. Note that calls to startService()
are not nesting: no matter how many times you call startService(),
a single call to Context.stopService(android.content.Intent)
will stop it.
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.
This function will throw SecurityException
if you do not
have permission to start the given service.
startService
in class Context
service
- Identifies the service to be started. The Intent may
specify either an explicit component name to start, or a logical
description (action, category, etc) to match an
IntentFilter
published by a service. Additional values
may be included in the Intent extras to supply arguments along with
this specific start call.ComponentName
of the actual service that was started is
returned; else if the service does not exist null is returned.Context.stopService(android.content.Intent)
,
Context.bindService(android.content.Intent, android.content.ServiceConnection, int)
public boolean stopService(Intent name)
Context
Note that if a stopped service still has ServiceConnection
objects bound to it with the Context.BIND_AUTO_CREATE
set, it will
not be destroyed until all of these bindings are removed. See
the Service
documentation for more details on a
service's lifecycle.
This function will throw SecurityException
if you do not
have permission to stop the given service.
stopService
in class Context
name
- Description of the service to be stopped. The Intent may
specify either an explicit component name to start, or a logical
description (action, category, etc) to match an
IntentFilter
published by a service.Context.startService(android.content.Intent)
public ComponentName startServiceAsUser(Intent service, UserHandle user)
startServiceAsUser
in class Context
public boolean stopServiceAsUser(Intent name, UserHandle user)
stopServiceAsUser
in class Context
public boolean bindService(Intent service, ServiceConnection conn, int flags)
Context
This function will throw SecurityException
if you do not
have permission to bind to the given service.
Note: this method can not be called from a
BroadcastReceiver
component. A pattern you can use to
communicate from a BroadcastReceiver to a Service is to call
Context.startService(android.content.Intent)
with the arguments containing the command to be
sent, with the service calling its
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
Context.registerReceiver(android.content.BroadcastReceiver, android.content.IntentFilter)
, since the lifetime of this BroadcastReceiver
is tied to another object (the one that registered it).
bindService
in class Context
service
- Identifies the service to connect to. The Intent may
specify either an explicit component name, or a logical
description (action, category, etc) to match an
IntentFilter
published by a service.conn
- Receives information as the service is started and stopped.
This must be a valid ServiceConnection object; it must not be null.flags
- Operation options for the binding. May be 0,
Context.BIND_AUTO_CREATE
, Context.BIND_DEBUG_UNBIND
,
Context.BIND_NOT_FOREGROUND
, Context.BIND_ABOVE_CLIENT
,
Context.BIND_ALLOW_OOM_MANAGEMENT
, or
Context.BIND_WAIVE_PRIORITY
.Context.unbindService(android.content.ServiceConnection)
,
Context.startService(android.content.Intent)
,
Context.BIND_AUTO_CREATE
,
Context.BIND_DEBUG_UNBIND
,
Context.BIND_NOT_FOREGROUND
public boolean bindService(Intent service, ServiceConnection conn, int flags, int userHandle)
Context
Context.bindService(Intent, ServiceConnection, int)
, but with an explicit userHandle
argument for use by system server and other multi-user aware code.bindService
in class Context
public void unbindService(ServiceConnection conn)
Context
unbindService
in class Context
conn
- The connection interface previously supplied to
bindService(). This parameter must not be null.Context.bindService(android.content.Intent, android.content.ServiceConnection, int)
public boolean startInstrumentation(ComponentName className, String profileFile, Bundle arguments)
Context
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.
This function is not synchronous -- it returns as soon as the instrumentation has started and while it is running.
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).
startInstrumentation
in class Context
className
- Name of the Instrumentation component to be run.profileFile
- Optional path to write profiling data as the
instrumentation runs, or null for no profiling.arguments
- Additional optional arguments to pass to the
instrumentation, or null.public Object getSystemService(String name)
Context
Context.WINDOW_SERVICE
("window")
WindowManager
.
Context.LAYOUT_INFLATER_SERVICE
("layout_inflater")
LayoutInflater
for inflating layout resources
in this context.
Context.ACTIVITY_SERVICE
("activity")
ActivityManager
for interacting with the
global activity state of the system.
Context.POWER_SERVICE
("power")
PowerManager
for controlling power
management.
Context.ALARM_SERVICE
("alarm")
AlarmManager
for receiving intents at the
time of your choosing.
Context.NOTIFICATION_SERVICE
("notification")
NotificationManager
for informing the user
of background events.
Context.KEYGUARD_SERVICE
("keyguard")
KeyguardManager
for controlling keyguard.
Context.LOCATION_SERVICE
("location")
LocationManager
for controlling location
(e.g., GPS) updates.
Context.SEARCH_SERVICE
("search")
SearchManager
for handling search.
Context.VIBRATOR_SERVICE
("vibrator")
Vibrator
for interacting with the vibrator
hardware.
Context.CONNECTIVITY_SERVICE
("connection")
ConnectivityManager
for
handling management of network connections.
Context.WIFI_SERVICE
("wifi")
WifiManager
for management of
Wi-Fi connectivity.
Context.INPUT_METHOD_SERVICE
("input_method")
InputMethodManager
for management of input methods.
Context.UI_MODE_SERVICE
("uimode")
UiModeManager
for controlling UI modes.
Context.DOWNLOAD_SERVICE
("download")
DownloadManager
for requesting HTTP downloads
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.)
getSystemService
in class Context
name
- The name of the desired service.Context.WINDOW_SERVICE
,
WindowManager
,
Context.LAYOUT_INFLATER_SERVICE
,
LayoutInflater
,
Context.ACTIVITY_SERVICE
,
ActivityManager
,
Context.POWER_SERVICE
,
PowerManager
,
Context.ALARM_SERVICE
,
AlarmManager
,
Context.NOTIFICATION_SERVICE
,
NotificationManager
,
Context.KEYGUARD_SERVICE
,
KeyguardManager
,
Context.LOCATION_SERVICE
,
LocationManager
,
Context.SEARCH_SERVICE
,
SearchManager
,
Context.SENSOR_SERVICE
,
SensorManager
,
Context.STORAGE_SERVICE
,
StorageManager
,
Context.VIBRATOR_SERVICE
,
Vibrator
,
Context.CONNECTIVITY_SERVICE
,
ConnectivityManager
,
Context.WIFI_SERVICE
,
WifiManager
,
Context.AUDIO_SERVICE
,
AudioManager
,
Context.MEDIA_ROUTER_SERVICE
,
MediaRouter
,
Context.TELEPHONY_SERVICE
,
TelephonyManager
,
Context.INPUT_METHOD_SERVICE
,
InputMethodManager
,
Context.UI_MODE_SERVICE
,
UiModeManager
,
Context.DOWNLOAD_SERVICE
,
DownloadManager
public int checkPermission(String permission, int pid, int uid)
Context
checkPermission
in class Context
permission
- The name of the permission being checked.pid
- The process ID being checked against. Must be > 0.uid
- The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.PackageManager.PERMISSION_GRANTED
if the given
pid/uid is allowed that permission, or
PackageManager.PERMISSION_DENIED
if it is not.PackageManager.checkPermission(String, String)
,
Context.checkCallingPermission(java.lang.String)
public int checkCallingPermission(String permission)
Context
Context.checkPermission(String, int, int)
with the pid and uid returned
by Binder.getCallingPid()
and
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 Context.checkCallingOrSelfPermission(java.lang.String)
to avoid this protection.checkCallingPermission
in class Context
permission
- The name of the permission being checked.PackageManager.PERMISSION_GRANTED
if the calling
pid/uid is allowed that permission, or
PackageManager.PERMISSION_DENIED
if it is not.PackageManager.checkPermission(String, String)
,
Context.checkPermission(java.lang.String, int, int)
,
Context.checkCallingOrSelfPermission(java.lang.String)
public int checkCallingOrSelfPermission(String permission)
Context
Context.checkCallingPermission(java.lang.String)
, except it grants your own permissions
if you are not currently processing an IPC. Use with care!checkCallingOrSelfPermission
in class Context
permission
- The name of the permission being checked.PackageManager.PERMISSION_GRANTED
if the calling
pid/uid is allowed that permission, or
PackageManager.PERMISSION_DENIED
if it is not.PackageManager.checkPermission(String, String)
,
Context.checkPermission(java.lang.String, int, int)
,
Context.checkCallingPermission(java.lang.String)
public void enforcePermission(String permission, int pid, int uid, String message)
Context
SecurityException
.enforcePermission
in class Context
permission
- The name of the permission being checked.pid
- The process ID being checked against. Must be > 0.uid
- The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.message
- A message to include in the exception if it is thrown.Context.checkPermission(String, int, int)
public void enforceCallingPermission(String permission, String message)
Context
SecurityException
. This is basically the same as calling
Context.enforcePermission(String, int, int, String)
with the
pid and uid returned by Binder.getCallingPid()
and 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 Context.enforceCallingOrSelfPermission(java.lang.String, java.lang.String)
to avoid this
protection.enforceCallingPermission
in class Context
permission
- The name of the permission being checked.message
- A message to include in the exception if it is thrown.Context.checkCallingPermission(String)
public void enforceCallingOrSelfPermission(String permission, String message)
Context
SecurityException
. This is the same as Context.enforceCallingPermission(java.lang.String, java.lang.String)
, except it grants your own
permissions if you are not currently processing an IPC. Use
with care!enforceCallingOrSelfPermission
in class Context
permission
- The name of the permission being checked.message
- A message to include in the exception if it is thrown.Context.checkCallingOrSelfPermission(String)
public void grantUriPermission(String toPackage, Uri uri, int modeFlags)
Context
Normally you should use Intent.FLAG_GRANT_READ_URI_PERMISSION
or
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
Context.revokeUriPermission(android.net.Uri, int)
when the target should no longer be allowed
to access it.
To succeed, the content provider owning the Uri must have set the
grantUriPermissions
attribute in its manifest or included the
<grant-uri-permissions>
tag.
grantUriPermission
in class Context
toPackage
- The package you would like to allow to access the Uri.uri
- The Uri you would like to grant access to.modeFlags
- The desired access modes. Any combination of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.Context.revokeUriPermission(android.net.Uri, int)
public void revokeUriPermission(Uri uri, int modeFlags)
Context
Context.grantUriPermission(java.lang.String, android.net.Uri, int)
. 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/one" will
revoke both "content://foo/target" and "content://foo/target/sub", but not
"content://foo".revokeUriPermission
in class Context
uri
- The Uri you would like to revoke access to.modeFlags
- The desired access modes. Any combination of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.Context.grantUriPermission(java.lang.String, android.net.Uri, int)
public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags)
Context
checkUriPermission
in class Context
uri
- The uri that is being checked.pid
- The process ID being checked against. Must be > 0.uid
- The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.modeFlags
- The type of access to grant. May be one or both of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.PackageManager.PERMISSION_GRANTED
if the given
pid/uid is allowed to access that uri, or
PackageManager.PERMISSION_DENIED
if it is not.Context.checkCallingUriPermission(android.net.Uri, int)
public int checkCallingUriPermission(Uri uri, int modeFlags)
Context
Context.checkUriPermission(Uri, int, int,
int)
with the pid and uid returned by Binder.getCallingPid()
and Binder.getCallingUid()
. One important difference is
that if you are not currently processing an IPC, this function
will always fail.checkCallingUriPermission
in class Context
uri
- The uri that is being checked.modeFlags
- The type of access to grant. May be one or both of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.PackageManager.PERMISSION_GRANTED
if the caller
is allowed to access that uri, or
PackageManager.PERMISSION_DENIED
if it is not.Context.checkUriPermission(Uri, int, int, int)
public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags)
Context
Context.checkCallingUriPermission(android.net.Uri, int)
, except it grants your own permissions
if you are not currently processing an IPC. Use with care!checkCallingOrSelfUriPermission
in class Context
uri
- The uri that is being checked.modeFlags
- The type of access to grant. May be one or both of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.PackageManager.PERMISSION_GRANTED
if the caller
is allowed to access that uri, or
PackageManager.PERMISSION_DENIED
if it is not.Context.checkCallingUriPermission(android.net.Uri, int)
public int checkUriPermission(Uri uri, String readPermission, String writePermission, int pid, int uid, int modeFlags)
Context
Context.checkPermission(java.lang.String, int, int)
and Context.checkUriPermission(android.net.Uri, int, int, int)
in one
call.checkUriPermission
in class Context
uri
- The Uri whose permission is to be checked, or null to not
do this check.readPermission
- The permission that provides overall read access,
or null to not do this check.writePermission
- The permission that provides overall write
acess, or null to not do this check.pid
- The process ID being checked against. Must be > 0.uid
- The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.modeFlags
- The type of access to grant. May be one or both of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.PackageManager.PERMISSION_GRANTED
if the caller
is allowed to access that uri or holds one of the given permissions, or
PackageManager.PERMISSION_DENIED
if it is not.public void enforceUriPermission(Uri uri, int pid, int uid, int modeFlags, String message)
Context
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.enforceUriPermission
in class Context
uri
- The uri that is being checked.pid
- The process ID being checked against. Must be > 0.uid
- The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.modeFlags
- The type of access to grant. May be one or both of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.message
- A message to include in the exception if it is thrown.Context.checkUriPermission(Uri, int, int, int)
public void enforceCallingUriPermission(Uri uri, int modeFlags, String message)
Context
SecurityException
. This is basically the same as calling
Context.enforceUriPermission(Uri, int, int, int, String)
with
the pid and uid returned by Binder.getCallingPid()
and Binder.getCallingUid()
. One important difference is
that if you are not currently processing an IPC, this function
will always throw a SecurityException.enforceCallingUriPermission
in class Context
uri
- The uri that is being checked.modeFlags
- The type of access to grant. May be one or both of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.message
- A message to include in the exception if it is thrown.Context.checkCallingUriPermission(Uri, int)
public void enforceCallingOrSelfUriPermission(Uri uri, int modeFlags, String message)
Context
SecurityException
. This is the same as Context.enforceCallingUriPermission(android.net.Uri, int, java.lang.String)
, except it grants your own
permissions if you are not currently processing an IPC. Use
with care!enforceCallingOrSelfUriPermission
in class Context
uri
- The uri that is being checked.modeFlags
- The type of access to grant. May be one or both of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.message
- A message to include in the exception if it is thrown.Context.checkCallingOrSelfUriPermission(Uri, int)
public void enforceUriPermission(Uri uri, String readPermission, String writePermission, int pid, int uid, int modeFlags, String message)
Context
Context.enforcePermission(java.lang.String, int, int, java.lang.String)
and Context.enforceUriPermission(android.net.Uri, int, int, int, java.lang.String)
in one
call.enforceUriPermission
in class Context
uri
- The Uri whose permission is to be checked, or null to not
do this check.readPermission
- The permission that provides overall read access,
or null to not do this check.writePermission
- The permission that provides overall write
acess, or null to not do this check.pid
- The process ID being checked against. Must be > 0.uid
- The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.modeFlags
- The type of access to grant. May be one or both of
Intent.FLAG_GRANT_READ_URI_PERMISSION
or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
.message
- A message to include in the exception if it is thrown.Context.checkUriPermission(Uri, String, String, int, int, int)
public Context createPackageContext(String packageName, int flags) throws PackageManager.NameNotFoundException
Context
Throws PackageManager.NameNotFoundException
if there is no
application with the given package name.
Throws SecurityException
if the Context requested
can not be loaded into the caller's process for security reasons (see
Context.CONTEXT_INCLUDE_CODE
for more information}.
createPackageContext
in class Context
packageName
- Name of the application's package.flags
- Option flags, one of Context.CONTEXT_INCLUDE_CODE
or Context.CONTEXT_IGNORE_SECURITY
.PackageManager.NameNotFoundException
- if there is no application with
the given package namepublic Context createPackageContextAsUser(String packageName, int flags, UserHandle user) throws PackageManager.NameNotFoundException
Context
Context.createPackageContext(String, int)
, but with a
different UserHandle
. For example, Context.getContentResolver()
will open any Uri
as the given user.createPackageContextAsUser
in class Context
PackageManager.NameNotFoundException
public Context createConfigurationContext(Configuration overrideConfiguration)
Context
createConfigurationContext
in class Context
overrideConfiguration
- A 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.public Context createDisplayContext(Display display)
Context
WindowManager
(see Context.getSystemService(String)
) that is configured to show windows
on the given display. The WindowManager's WindowManager.getDefaultDisplay()
method can be used to retrieve the Display from the returned Context.createDisplayContext
in class Context
display
- A Display
object specifying the display
for whose metrics the Context's resources should be tailored and upon which
new windows should be shown.public boolean isRestricted()
Context
isRestricted
in class Context
Context.CONTEXT_RESTRICTED
public CompatibilityInfoHolder getCompatibilityInfo(int displayId)
Context
getCompatibilityInfo
in class Context
displayId
- The display id for which to get compatibility info.