FileDocCategorySizeDatePackage
Context.javaAPI DocAndroid 1.5 API71251Wed May 06 22:41:54 BST 2009android.content

Context

public abstract class Context extends 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.

Fields Summary
public static final int
MODE_PRIVATE
File creation mode: the default mode, where the created file can only be accessed by the calling application (or all applications sharing the same user ID).
public static final int
MODE_WORLD_READABLE
File creation mode: allow all other applications to have read access to the created file.
public static final int
MODE_WORLD_WRITEABLE
File creation mode: allow all other applications to have write access to the created file.
public static final int
MODE_APPEND
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.
public static final int
BIND_AUTO_CREATE
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#onStart} 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.

Specifying this flag also tells the system to treat the service as being as important as your own process -- that is, when deciding which process should be killed to free memory, the service will only be considered a candidate as long as the processes of any such bindings is also a candidate to be killed. This is to avoid situations where the service is being continually created and killed due to low memory.

public static final int
BIND_DEBUG_UNBIND
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.
public static final String
POWER_SERVICE
Use with {@link #getSystemService} 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.
public static final String
WINDOW_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.view.WindowManager} for accessing the system's window manager.
public static final String
LAYOUT_INFLATER_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.view.LayoutInflater} for inflating layout resources in this context.
public static final String
ACTIVITY_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.app.ActivityManager} for interacting with the global system state.
public static final String
ALARM_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.app.AlarmManager} for receiving intents at a time of your choosing.
public static final String
NOTIFICATION_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.app.NotificationManager} for informing the user of background events.
public static final String
KEYGUARD_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.app.NotificationManager} for controlling keyguard.
public static final String
LOCATION_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.location.LocationManager} for controlling location updates.
public static final String
SEARCH_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.app.SearchManager} for handling searches.
public static final String
SENSOR_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.hardware.SensorManager} for accessing sensors.
public static final String
BLUETOOTH_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.bluetooth.BluetoothDevice} for interacting with Bluetooth.
public static final String
WALLPAPER_SERVICE
Use with {@link #getSystemService} to retrieve a com.android.server.WallpaperService for accessing wallpapers.
public static final String
VIBRATOR_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.os.Vibrator} for interacting with the vibration hardware.
public static final String
STATUS_BAR_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.app.StatusBarManager} for interacting with the status bar.
public static final String
CONNECTIVITY_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.net.ConnectivityManager} for handling management of network connections.
public static final String
WIFI_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.net.wifi.WifiManager} for handling management of Wi-Fi access.
public static final String
AUDIO_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.media.AudioManager} for handling management of volume, ringer modes and audio routing.
public static final String
TELEPHONY_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.telephony.TelephonyManager} for handling management the telephony features of the device.
public static final String
CLIPBOARD_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.text.ClipboardManager} for accessing and modifying the contents of the global clipboard.
public static final String
INPUT_METHOD_SERVICE
Use with {@link #getSystemService} to retrieve a {@link android.view.inputmethod.InputMethodManager} for accessing input methods.
public static final String
APPWIDGET_SERVICE
Use with {@link #getSystemService} to retrieve a {@blink android.appwidget.AppWidgetManager} for accessing AppWidgets.
public static final int
CONTEXT_INCLUDE_CODE
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.
public static final int
CONTEXT_IGNORE_SECURITY
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!
Constructors Summary
Methods Summary
public abstract booleanbindService(Intent service, ServiceConnection conn, int flags)
Connect to an application service, creating it if needed. This defines a dependency between your application and the service. The given conn will receive the service object when its 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.

This function will throw {@link SecurityException} if you do not have permission to bind to the given service.

Note: this method can not be called from an {@link BroadcastReceiver} component. A pattern you can use to communicate from an 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 an BroadcastReceiver that has been registered with {@link #registerReceiver}, since the lifetime of this BroadcastReceiver is tied to another object (the one that registered it).

param
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 {@link IntentFilter} published by a service.
param
conn Receives information as the service is started and stopped.
param
flags Operation options for the binding. May be 0 or {@link #BIND_AUTO_CREATE}.
return
If you have successfully bound to the service, true is returned; false is returned if the connection is not made so you will not receive the service object.
throws
SecurityException
see
#unbindService
see
#startService
see
#BIND_AUTO_CREATE

public abstract intcheckCallingOrSelfPermission(java.lang.String permission)
Determine whether the calling process of an IPC or you 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
permission The name of the permission being checked.
return
Returns {@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
public abstract intcheckCallingOrSelfUriPermission(android.net.Uri uri, int modeFlags)
Determine whether the calling process of an IPC or you 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
uri The uri that is being checked.
param
modeFlags The type of access to grant. May be one or both of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
return
Returns {@link PackageManager#PERMISSION_GRANTED} if the caller
is allowed to access that uri, or
{@link PackageManager#PERMISSION_DENIED} if it is not.
see
#checkCallingUriPermission
public abstract intcheckCallingPermission(java.lang.String permission)
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
permission The name of the permission being checked.
return
Returns {@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
public abstract intcheckCallingUriPermission(android.net.Uri uri, int modeFlags)
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
uri The uri that is being checked.
param
modeFlags The type of access to grant. May be one or both of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
return
Returns {@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)
public abstract intcheckPermission(java.lang.String permission, int pid, int uid)
Determine whether the given permission is allowed for a particular
process and user ID running in the system.
param
permission The name of the permission being checked.
param
pid The process ID being checked against. Must be > 0.
param
uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
return
Returns {@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
public abstract intcheckUriPermission(android.net.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. 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
uri The uri that is being checked.
param
pid The process ID being checked against. Must be > 0.
param
uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
param
modeFlags The type of access to grant. May be one or both of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
return
Returns {@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
public abstract intcheckUriPermission(android.net.Uri uri, java.lang.String readPermission, java.lang.String writePermission, int pid, int uid, int modeFlags)
Check both a Uri and normal permission. This allows you to perform
both {@link #checkPermission} and {@link #checkUriPermission} in one
call.
param
uri The Uri whose permission is to be checked, or null to not
do this check.
param
readPermission The permission that provides overall read access,
or null to not do this check.
param
writePermission The permission that provides overall write
acess, or null to not do this check.
param
pid The process ID being checked against. Must be > 0.
param
uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
param
modeFlags The type of access to grant. May be one or both of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
return
Returns {@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.
public abstract voidclearWallpaper()
Remove any currently set wallpaper, reverting to the system's default
wallpaper. On success, the intent {@link Intent#ACTION_WALLPAPER_CHANGED}
is broadcast.
throws
IOException If an error occurs reverting to the default
wallpaper.
public abstract android.content.ContextcreatePackageContext(java.lang.String packageName, int flags)
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.


Throws {@link PackageManager.NameNotFoundException} if there is no
application with the given package name.


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
packageName Name of the application's package.
param
flags Option flags, one of {@link #CONTEXT_INCLUDE_CODE}
or {@link #CONTEXT_IGNORE_SECURITY}.
return
A Context for the application.
throws
java.lang.SecurityException
throws
PackageManager.NameNotFoundException if there is no application with
the given package name
public abstract java.lang.String[]databaseList()
Returns an array of strings naming the private databases associated with
this Context's application package.
return
Array of strings naming the private databases.
see
#openOrCreateDatabase
see
#deleteDatabase
public abstract booleandeleteDatabase(java.lang.String name)
Delete an existing private SQLiteDatabase associated with this Context's
application package.
param
name The name (unique in the application package) of the
database.
return
True if the database was successfully deleted; else false.
see
#openOrCreateDatabase
public abstract booleandeleteFile(java.lang.String name)
Delete the given private file associated with this Context's
application package.
param
name The name of the file to delete; can not contain path
separators.
return
True if the file was successfully deleted; else
false.
see
#openFileInput
see
#openFileOutput
see
#fileList
see
java.io.File#delete()
public abstract voidenforceCallingOrSelfPermission(java.lang.String permission, java.lang.String message)
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
permission The name of the permission being checked.
param
message A message to include in the exception if it is thrown.
see
#checkCallingOrSelfPermission(String)
public abstract voidenforceCallingOrSelfUriPermission(android.net.Uri uri, int modeFlags, java.lang.String message)
If the calling process of an IPC or you 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
uri The uri that is being checked.
param
modeFlags The type of access to grant. May be one or both of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
param
message A message to include in the exception if it is thrown.
see
#checkCallingOrSelfUriPermission(Uri, int)
public abstract voidenforceCallingPermission(java.lang.String permission, java.lang.String message)
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
permission The name of the permission being checked.
param
message A message to include in the exception if it is thrown.
see
#checkCallingPermission(String)
public abstract voidenforceCallingUriPermission(android.net.Uri uri, int modeFlags, java.lang.String message)
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
uri The uri that is being checked.
param
modeFlags The type of access to grant. May be one or both of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
param
message A message to include in the exception if it is thrown.
see
#checkCallingUriPermission(Uri, int)
public abstract voidenforcePermission(java.lang.String permission, int pid, int uid, java.lang.String message)
If the given permission is not allowed for a particular process
and user ID running in the system, throw a {@link SecurityException}.
param
permission The name of the permission being checked.
param
pid The process ID being checked against. Must be > 0.
param
uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
param
message A message to include in the exception if it is thrown.
see
#checkPermission(String, int, int)
public abstract voidenforceUriPermission(android.net.Uri uri, int pid, int uid, int modeFlags, java.lang.String message)
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
uri The uri that is being checked.
param
pid The process ID being checked against. Must be > 0.
param
uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
param
modeFlags The type of access to grant. May be one or both of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
param
message A message to include in the exception if it is thrown.
see
#checkUriPermission(Uri, int, int, int)
public abstract voidenforceUriPermission(android.net.Uri uri, java.lang.String readPermission, java.lang.String writePermission, int pid, int uid, int modeFlags, java.lang.String message)
Enforce both a Uri and normal permission. This allows you to perform
both {@link #enforcePermission} and {@link #enforceUriPermission} in one
call.
param
uri The Uri whose permission is to be checked, or null to not
do this check.
param
readPermission The permission that provides overall read access,
or null to not do this check.
param
writePermission The permission that provides overall write
acess, or null to not do this check.
param
pid The process ID being checked against. Must be > 0.
param
uid The user ID being checked against. A uid of 0 is the root
user, which will pass every permission check.
param
modeFlags The type of access to grant. May be one or both of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
param
message A message to include in the exception if it is thrown.
see
#checkUriPermission(Uri, String, String, int, int, int)
public abstract java.lang.String[]fileList()
Returns an array of strings naming the private files associated with
this Context's application package.
return
Array of strings naming the private files.
see
#openFileInput
see
#openFileOutput
see
#deleteFile
public abstract android.content.ContextgetApplicationContext()
Return the context of the single, global Application object of the
current process.
public abstract android.content.res.AssetManagergetAssets()
Return an AssetManager instance for your application's package.
public abstract java.io.FilegetCacheDir()
Returns the absolute path to the application specific cache directory
on the filesystem. These files will be ones that get deleted first when the
device runs low on storage
There is no guarantee when these files will be deleted.
return
Returns the path of the directory holding application cache files.
see
#openFileOutput
see
#getFileStreamPath
see
#getDir
public abstract java.lang.ClassLoadergetClassLoader()
Return a class loader you can use to retrieve classes in this package.
public abstract ContentResolvergetContentResolver()
Return a ContentResolver instance for your application's package.
public abstract java.io.FilegetDatabasePath(java.lang.String name)
Returns the absolute path on the filesystem where a database created with
{@link #openOrCreateDatabase} is stored.
param
name The name of the database for which you would like to get
its path.
return
Returns an absolute path to the given database.
see
#openOrCreateDatabase
public abstract java.io.FilegetDir(java.lang.String name, int mode)
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.
param
name Name of the directory to retrieve. This is a directory
that is created as part of your application data.
param
mode Operating mode. Use 0 or {@link #MODE_PRIVATE} for the
default operation, {@link #MODE_WORLD_READABLE} and
{@link #MODE_WORLD_WRITEABLE} to control permissions.
return
Returns a File object for the requested directory. The directory
will have been created if it does not already exist.
see
#openFileOutput(String, int)
public abstract java.io.FilegetFileStreamPath(java.lang.String name)
Returns the absolute path on the filesystem where a file created with
{@link #openFileOutput} is stored.
param
name The name of the file for which you would like to get
its path.
return
Returns an absolute path to the given file.
see
#openFileOutput
see
#getFilesDir
see
#getDir
public abstract java.io.FilegetFilesDir()
Returns the absolute path to the directory on the filesystem where
files created with {@link #openFileOutput} are stored.
return
Returns the path of the directory holding application files.
see
#openFileOutput
see
#getFileStreamPath
see
#getDir
public abstract android.os.LoopergetMainLooper()
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).
public abstract java.lang.StringgetPackageCodePath()
{@hide}
Return the full path to this context's code and asset files. This is the ZIP files
containing the application's code and assets.


Note: this is not generally useful for applications, since they should
not be directly accessing the file system.
return
String Path to the code and assets.
public abstract android.content.pm.PackageManagergetPackageManager()
Return PackageManager instance to find global package information.
public abstract java.lang.StringgetPackageName()
Return the name of this application's package.
public abstract java.lang.StringgetPackageResourcePath()
{@hide}
Return the full path to this context's resource files. This is the ZIP files
containing the application's resources.


Note: this is not generally useful for applications, since they should
not be directly accessing the file system.
return
String Path to the resources.
public abstract android.content.res.ResourcesgetResources()
Return a Resources instance for your application's package.
public abstract SharedPreferencesgetSharedPreferences(java.lang.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. 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
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
mode Operating mode. Use 0 or {@link #MODE_PRIVATE} for the
default operation, {@link #MODE_WORLD_READABLE}
and {@link #MODE_WORLD_WRITEABLE} to control permissions.
return
Returns the single SharedPreferences instance that can be used
to retrieve and modify the preference values.
see
#MODE_PRIVATE
see
#MODE_WORLD_READABLE
see
#MODE_WORLD_WRITEABLE
public final java.lang.StringgetString(int resId)
Return a localized string from the application's package's
default string table.
param
resId Resource id for the string
        return getResources().getString(resId);
    
public final java.lang.StringgetString(int resId, java.lang.Object formatArgs)
Return 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
resId Resource id for the format string
param
formatArgs The format arguments that will be used for substitution.
        return getResources().getString(resId, formatArgs);
    
public abstract java.lang.ObjectgetSystemService(java.lang.String name)
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:




 {@link #WINDOW_SERVICE} ("window")

 The top-level window manager in which you can place custom
windows. The returned object is a {@link android.view.WindowManager}.

 {@link #LAYOUT_INFLATER_SERVICE} ("layout_inflater")

 A {@link android.view.LayoutInflater} for inflating layout resources
in this context.

 {@link #ACTIVITY_SERVICE} ("activity")

 A {@link android.app.ActivityManager} for interacting with the
global activity state of the system.

 {@link #POWER_SERVICE} ("power")

 A {@link android.os.PowerManager} for controlling power
management.

 {@link #ALARM_SERVICE} ("alarm")

 A {@link android.app.AlarmManager} for receiving intents at the
time of your choosing.

 {@link #NOTIFICATION_SERVICE} ("notification")

 A {@link android.app.NotificationManager} for informing the user
of background events.

 {@link #KEYGUARD_SERVICE} ("keyguard")

 A {@link android.app.KeyguardManager} for controlling keyguard.

 {@link #LOCATION_SERVICE} ("location")

 A {@link android.location.LocationManager} for controlling location
(e.g., GPS) updates.

 {@link #SEARCH_SERVICE} ("search")

 A {@link android.app.SearchManager} for handling search.

 {@link #VIBRATOR_SERVICE} ("vibrator")

 A {@link android.os.Vibrator} for interacting with the vibrator
hardware.

 {@link #CONNECTIVITY_SERVICE} ("connection")

 A {@link android.net.ConnectivityManager ConnectivityManager} for
handling management of network connections.

 {@link #WIFI_SERVICE} ("wifi")

 A {@link android.net.wifi.WifiManager WifiManager} for management of
Wi-Fi connectivity.

 {@link #INPUT_METHOD_SERVICE} ("input_method")

 An {@link android.view.inputmethod.InputMethodManager InputMethodManager}
for management of input methods.




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.)
param
name The name of the desired service.
return
The service or 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
#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
#TELEPHONY_SERVICE
see
android.telephony.TelephonyManager
see
#INPUT_METHOD_SERVICE
see
android.view.inputmethod.InputMethodManager
public final java.lang.CharSequencegetText(int resId)
Return a localized, styled CharSequence from the application's package's
default string table.
param
resId Resource id for the CharSequence text

             
       

             
       

             
       

             
       

                                   
       
    
                      
       

                             
         
        return getResources().getText(resId);
    
public abstract Resources.ThemegetTheme()
Return the Theme object associated with this Context.
public abstract android.graphics.drawable.DrawablegetWallpaper()
Like {@link #peekWallpaper}, but always returns a valid Drawable. If
no wallpaper is set, the system default wallpaper is returned.
return
Returns a Drawable object that will draw the wallpaper.
public abstract intgetWallpaperDesiredMinimumHeight()
Returns the desired minimum height for the wallpaper. Callers of
{@link #setWallpaper(android.graphics.Bitmap)} or
{@link #setWallpaper(java.io.InputStream)} should check this value
beforehand to make sure the supplied wallpaper respects the desired
minimum height.

If the returned value is <= 0, the caller should use the height of
the default display instead.
return
The desired minimum height for the wallpaper. This value should
be honored by applications that set the wallpaper but it is not
mandatory.
public abstract intgetWallpaperDesiredMinimumWidth()
Returns the desired minimum width for the wallpaper. Callers of
{@link #setWallpaper(android.graphics.Bitmap)} or
{@link #setWallpaper(java.io.InputStream)} should check this value
beforehand to make sure the supplied wallpaper respects the desired
minimum width.

If the returned value is <= 0, the caller should use the width of
the default display instead.
return
The desired minimum width for the wallpaper. This value should
be honored by applications that set the wallpaper but it is not
mandatory.
public abstract voidgrantUriPermission(java.lang.String toPackage, android.net.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. 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).


Normally you should use {@link Intent#FLAG_GRANT_READ_URI_PERMISSION
Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION
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.


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
toPackage The package you would like to allow to access the Uri.
param
uri The Uri you would like to grant access to.
param
modeFlags The desired access modes. Any combination of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION
Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION
Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
see
#revokeUriPermission
public final android.content.res.TypedArrayobtainStyledAttributes(int[] attrs)
Retrieve styled attribute information in this Context's theme. See
{@link Resources.Theme#obtainStyledAttributes(int[])}
for more information.
see
Resources.Theme#obtainStyledAttributes(int[])
        return getTheme().obtainStyledAttributes(attrs);
    
public final android.content.res.TypedArrayobtainStyledAttributes(int resid, int[] attrs)
Retrieve styled attribute information in this Context's theme. See
{@link Resources.Theme#obtainStyledAttributes(int, int[])}
for more information.
see
Resources.Theme#obtainStyledAttributes(int, int[])
        return getTheme().obtainStyledAttributes(resid, attrs);
    
public final android.content.res.TypedArrayobtainStyledAttributes(android.util.AttributeSet set, int[] attrs)
Retrieve styled attribute information in this Context's theme. See
{@link Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)}
for more information.
see
Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)
        return getTheme().obtainStyledAttributes(set, attrs, 0, 0);
    
public final android.content.res.TypedArrayobtainStyledAttributes(android.util.AttributeSet set, int[] attrs, int defStyleAttr, int defStyleRes)
Retrieve styled attribute information in this Context's theme. See
{@link Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)}
for more information.
see
Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)
        return getTheme().obtainStyledAttributes(
            set, attrs, defStyleAttr, defStyleRes);
    
public abstract java.io.FileInputStreamopenFileInput(java.lang.String name)
Open a private file associated with this Context's application package
for reading.
param
name The name of the file to open; can not contain path
separators.
return
FileInputStream Resulting input stream.
see
#openFileOutput
see
#fileList
see
#deleteFile
see
java.io.FileInputStream#FileInputStream(String)
public abstract java.io.FileOutputStreamopenFileOutput(java.lang.String name, int mode)
Open a private file associated with this Context's application package
for writing. Creates the file if it doesn't already exist.
param
name The name of the file to open; can not contain path
separators.
param
mode Operating mode. Use 0 or {@link #MODE_PRIVATE} for the
default operation, {@link #MODE_APPEND} to append to an existing file,
{@link #MODE_WORLD_READABLE} and {@link #MODE_WORLD_WRITEABLE} to control
permissions.
return
FileOutputStream Resulting output stream.
see
#MODE_APPEND
see
#MODE_PRIVATE
see
#MODE_WORLD_READABLE
see
#MODE_WORLD_WRITEABLE
see
#openFileInput
see
#fileList
see
#deleteFile
see
java.io.FileOutputStream#FileOutputStream(String)
public abstract android.database.sqlite.SQLiteDatabaseopenOrCreateDatabase(java.lang.String name, int mode, android.database.sqlite.SQLiteDatabase.CursorFactory factory)
Open a new private SQLiteDatabase associated with this Context's
application package. Create the database file if it doesn't exist.
param
name The name (unique in the application package) of the database.
param
mode Operating mode. Use 0 or {@link #MODE_PRIVATE} for the
default operation, {@link #MODE_WORLD_READABLE}
and {@link #MODE_WORLD_WRITEABLE} to control permissions.
param
factory An optional factory class that is called to instantiate a
cursor when query is called.
return
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_WORLD_READABLE
see
#MODE_WORLD_WRITEABLE
see
#deleteDatabase
public abstract android.graphics.drawable.DrawablepeekWallpaper()
Retrieve the current system wallpaper. This is returned as an
abstract Drawable that you can install in a View to display whatever
wallpaper the user has currently set. If there is no wallpaper set,
a null pointer is returned.
return
Returns a Drawable object that will draw the wallpaper or a
null pointer if these is none.
public abstract IntentregisterReceiver(BroadcastReceiver receiver, IntentFilter filter)
Register a BroadcastReceiver to be run in the main activity thread. The
receiver will be called with any broadcast Intent that
matches filter, in the main application thread.


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 {@link BroadcastReceiver} for more information on Intent broadcasts.


Note: this method cannot be called from a
{@link 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 {@link #registerReceiver}, since the lifetime of such a
registered BroadcastReceiver is tied to the object that registered it.
param
receiver The BroadcastReceiver to handle the broadcast.
param
filter Selects the Intent broadcasts to be received.
return
The first sticky intent found that matches filter,
or null if there are none.
see
#registerReceiver(BroadcastReceiver, IntentFilter, String, Handler)
see
#sendBroadcast
see
#unregisterReceiver
public abstract IntentregisterReceiver(BroadcastReceiver receiver, IntentFilter filter, java.lang.String broadcastPermission, android.os.Handler scheduler)
Register to receive intent broadcasts, to run in the context of
scheduler. See
{@link #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 {@link BroadcastReceiver} for more information on Intent broadcasts.
param
receiver The BroadcastReceiver to handle the broadcast.
param
filter Selects the Intent broadcasts to be received.
param
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
scheduler Handler identifying the thread that will receive
the Intent. If null, the main thread of the process will be used.
return
The first sticky intent found that matches filter,
or null if there are none.
see
#registerReceiver(BroadcastReceiver, IntentFilter)
see
#sendBroadcast
see
#unregisterReceiver
public abstract voidremoveStickyBroadcast(Intent intent)
Remove the data previously sent with {@link #sendStickyBroadcast},
so that it is as if the sticky broadcast had never happened.


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
intent The Intent that was previously broadcast.
see
#sendStickyBroadcast
public abstract voidrevokeUriPermission(android.net.Uri uri, int modeFlags)
Remove all permissions to access a particular content provider Uri
that were previously added with {@link #grantUriPermission}. 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".
param
uri The Uri you would like to revoke access to.
param
modeFlags The desired access modes. Any combination of
{@link Intent#FLAG_GRANT_READ_URI_PERMISSION
Intent.FLAG_GRANT_READ_URI_PERMISSION} or
{@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION
Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
see
#grantUriPermission
public abstract voidsendBroadcast(Intent intent)
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)}.


See {@link BroadcastReceiver} for more information on Intent broadcasts.
param
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)
public abstract voidsendBroadcast(Intent intent, java.lang.String receiverPermission)
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)}.


See {@link BroadcastReceiver} for more information on Intent broadcasts.
param
intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
param
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)
see
#sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
public abstract voidsendOrderedBroadcast(Intent intent, java.lang.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. This
call is asynchronous; it returns immediately, and you will continue
executing while the receivers are run.


See {@link BroadcastReceiver} for more information on Intent broadcasts.
param
intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
param
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)
public abstract voidsendOrderedBroadcast(Intent intent, java.lang.String receiverPermission, BroadcastReceiver resultReceiver, android.os.Handler scheduler, int initialCode, java.lang.String initialData, android.os.Bundle initialExtras)
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 BroadcastReceiver#onReceive} method will be called with
the result values collected from the other receivers. If you use
an resultReceiver with this method, then the broadcast will
be serialized in the same way as calling
{@link #sendOrderedBroadcast(Intent, String)}.


Like {@link #sendBroadcast(Intent)}, this method is
asynchronous; it will return before
resultReceiver.onReceive() is called.


See {@link BroadcastReceiver} for more information on Intent broadcasts.
param
intent The Intent to broadcast; all receivers matching this
Intent will receive the broadcast.
param
receiverPermission String naming a permissions that
a receiver must hold in order to receive your broadcast.
If null, no permission is required.
param
resultReceiver Your own BroadcastReceiver to treat as the final
receiver of the broadcast.
param
scheduler A custom Handler with which to schedule the
resultReceiver callback; if null it will be
scheduled in the Context's main thread.
param
initialCode An initial value for the result code. Often
Activity.RESULT_OK.
param
initialData An initial value for the result data. 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
public abstract voidsendStickyBroadcast(Intent intent)
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, IntentFilter)}. In
all other ways, this behaves the same as
{@link #sendBroadcast(Intent)}.


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
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)
public abstract voidsetTheme(int resid)
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
resid The style resource describing the theme.
public abstract voidsetWallpaper(android.graphics.Bitmap bitmap)
Change the current system wallpaper to a bitmap. The given bitmap is
converted to a PNG and stored as the wallpaper. On success, the intent
{@link Intent#ACTION_WALLPAPER_CHANGED} is broadcast.
param
bitmap The bitmap to save.
throws
IOException If an error occurs reverting to the default
wallpaper.
public abstract voidsetWallpaper(java.io.InputStream data)
Change the current system wallpaper to a specific byte stream. The
give InputStream is copied into persistent storage and will now be
used as the wallpaper. Currently it must be either a JPEG or PNG
image. On success, the intent {@link Intent#ACTION_WALLPAPER_CHANGED}
is broadcast.
param
data A stream containing the raw data to install as a wallpaper.
throws
IOException If an error occurs reverting to the default
wallpaper.
public abstract voidstartActivity(Intent intent)
Launch a new activity. You will not receive any information about when
the activity exits.


Note that if this method is being called from outside of an
{@link android.app.Activity} Context, then the Intent must include
the {@link 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 {@link ActivityNotFoundException}
if there was no Activity found to run the given Intent.
param
intent The description of the activity to start.
throws
ActivityNotFoundException
see
PackageManager#resolveActivity
public abstract booleanstartInstrumentation(ComponentName className, java.lang.String profileFile, android.os.Bundle arguments)
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.


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).
param
className Name of the Instrumentation component to be run.
param
profileFile Optional path to write profiling data as the
instrumentation runs, or null for no profiling.
param
arguments Additional optional arguments to pass to the
instrumentation, or null.
return
Returns true if the instrumentation was successfully started,
else false if it could not be found.
public abstract ComponentNamestartService(Intent service)
Request that a given application service be started. The Intent
can either contain the complete class name of a specific service
implementation to start, or an abstract definition through the
action and other fields of the kind of service to start. 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.


Every call to this method will result in a corresponding call to
the target service's {@link android.app.Service#onStart} 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 {@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()
are not nesting: no matter how many times you call startService(),
a single call to {@link #stopService} 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 {@link SecurityException} if you do not
have permission to start the given service.
param
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
{@link IntentFilter} published by a service. Additional values
may be included in the Intent extras to supply arguments along with
this specific start call.
return
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
see
#stopService
see
#bindService
public abstract booleanstopService(Intent service)
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.


Note that if a stopped service still has {@link 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.


This function will throw {@link SecurityException} if you do not
have permission to stop the given service.
param
service 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
{@link IntentFilter} published by a service.
return
If there is a service matching the given Intent that is already
running, then it is stopped and true is returned; else false is returned.
throws
SecurityException
see
#startService
public abstract voidunbindService(ServiceConnection conn)
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
conn The connection interface previously supplied to
bindService().
see
#bindService
public abstract voidunregisterReceiver(BroadcastReceiver receiver)
Unregister a previously registered BroadcastReceiver. All
filters that have been registered for this BroadcastReceiver will be
removed.
param
receiver The BroadcastReceiver to unregister.
see
#registerReceiver