Context
extends Objectpublic static final String ACCESSIBILITY_SERVICE
Use with getSystemService(String) to retrieve a AccessibilityManager for giving the user feedback for UI events through the registered event listeners.
public static final String ACTIVITY_SERVICE
Use with getSystemService(String) to retrieve a ActivityManager for interacting with the global system state.
public static final String DISPLAY_SERVICE
Use with getSystemService(String) to retrieve a DisplayManager for interacting with display devices.
public static final String INPUT_METHOD_SERVICE
Use with getSystemService(String) to retrieve a InputMethodManager for accessing input methods.
public static final String INPUT_SERVICE
Use with getSystemService(String) to retrieve a InputManager for interacting with in
put devices.
public static final String LAYOUT_INFLATER_SERVICE
Use with getSystemService(String) to retrieve a LayoutInflater for inflating layout resources in this context.
public abstract boolean bindService (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 it is created and be told if it dies and restarts. The service will be considered required by the system only for as long as the calling context exists. For example, if this Context is an Activity that is stopped, the service will not be required to continue running until the Activity is resumed.
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 startService(Intent) with the arguments containing the command to be sent, with the service calling its 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 registerReceiver(BroadcastReceiver, IntentFilter), since the lifetime of this BroadcastReceiver is tied to another object (the one that registered it).
Parameters
| 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, BIND_AUTO_CREATE, BIND_DEBUG_UNBIND, BIND_NOT_FOREGROUND, BIND_ABOVE_CLIENT, BIND_ALLOW_OOM_MANAGEMENT, or BIND_WAIVE_PRIORITY. |
Returns
- 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.
public abstract Context getApplicationContext ()
Return the context of the single, global Application object of the current process. This generally should only be used if you need a Context whose lifecycle is separate from the current context, that is tied to the lifetime of the process rather than the current component.
Consider for example how this interacts with 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.
public abstract ApplicationInfo getApplicationInfo ()
Return the full application info for this context's package.
public abstract AssetManager getAssets ()
Return an AssetManager instance for your application's package.
public abstract File getCacheDir ()
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. Note: you should not rely on the system deleting these files for you; you should always have a reasonable maximum, such as 1 MB, for the amount of space you consume with cache files, and prune those files when exceeding that space.
Returns
- Returns the path of the directory holding application cache files.
public abstract ClassLoader getClassLoader ()
Return a class loader you can use to retrieve classes in this package.
public abstract ContentResolver getContentResolver ()
Return a ContentResolver instance for your application's package.
public abstract File getDatabasePath (String name)
Returns the absolute path on the filesystem where a database created with openOrCreateDatabase(String, int, SQLiteDatabase.CursorFactory) is stored.
Parameters
| name | The name of the database for which you would like to get its path. |
|---|
Returns
- Returns an absolute path to the given database.
public abstract File getDir (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.
Parameters
| 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 MODE_PRIVATE for the default operation, MODE_WORLD_READABLE and MODE_WORLD_WRITEABLE to control permissions. |
Returns
- Returns a File object for the requested directory. The directory will have been created if it does not already exist.
public abstract 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.
This is like getCacheDir() in that these files will be deleted when the application is uninstalled, however there are some important differences:
- The platform does not always monitor the space available in external storage, and thus may not automatically delete these files. Currently the only time files here will be deleted by the platform is when running on
JELLY_BEAN_MR1or later andEnvironment.isExternalStorageEmulated()returns true. Note that you should be managing the maximum space you will use for these anyway, just like withgetCacheDir(). - External files are not always available: they will disappear if the user mounts the external storage on a computer or removes it. See the APIs on
Environmentfor information in the storage state. - There is no security enforced with these files. All applications can read and write files placed here.
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 WRITE_EXTERNAL_STORAGE permission.
Returns
- Returns the path of the directory holding application cache files on external storage. Returns null if external storage is not currently mounted so it could not ensure the path exists; you will need to call this method again when it is available.
See Also
Here is an example of typical code to manipulate a file in an application's private storage:
void createExternalStoragePrivateFile() { // Create a path where we will place our private file on external // storage. File file = new File(getExternalFilesDir(null), "DemoFile.jpg"); try { // Very simple code to copy a picture from the application's // resource into the external file. Note that this code does // no error checking, and assumes the picture is small (does not // try to copy it in chunks). Note that if external storage is // not currently mounted this will silently fail. InputStream is = getResources().openRawResource(R.drawable.balloons); OutputStream os = new FileOutputStream(file); byte[] data = new byte[is.available()]; is.read(data); os.write(data); is.close(); os.close(); } catch (IOException e) { // Unable to create file, likely because external storage is // not currently mounted. Log.w("ExternalStorage", "Error writing " + file, e); } } void deleteExternalStoragePrivateFile() { // Get path for the file on external storage. If external // storage is not currently mounted this will fail. File file = new File(getExternalFilesDir(null), "DemoFile.jpg"); if (file != null) { file.delete(); } } boolean hasExternalStoragePrivateFile() { // Get path for the file on external storage. If external // storage is not currently mounted this will fail. File file = new File(getExternalFilesDir(null), "DemoFile.jpg"); if (file != null) { return file.exists(); } return false; }
public abstract File getFileStreamPath (String name)
Returns the absolute path on the filesystem where a file created with openFileOutput(String, int) is stored.
Parameters
| name | The name of the file for which you would like to get its path. |
|---|
Returns
- Returns an absolute path to the given file.
public abstract PackageManager getPackageManager ()
Return PackageManager instance to find global package information.
public abstract String getPackageName ()
Return the name of this application's package.
public abstract Resources getResources ()
Return a Resources instance for your application's package.
public abstract 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. 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.
Parameters
| 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 MODE_PRIVATE for the default operation, MODE_WORLD_READABLE and MODE_WORLD_WRITEABLE to control permissions. The bit MODE_MULTI_PROCESS can also be used if multiple processes are mutating the same SharedPreferences file. MODE_MULTI_PROCESS is always on in apps targetting Gingerbread (Android 2.3) and below, and off by default in later versions. |
Returns
- Returns the single SharedPreferences instance that can be used to retrieve and modify the preference values.
public abstract Object getSystemService (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:
-
The top-level window manager in which you can place custom windows. The returned object is a
WindowManager. -
A
LayoutInflaterfor inflating layout resources in this context. -
A
ActivityManagerfor interacting with the global activity state of the system. -
A
PowerManagerfor controlling power management. -
A
AlarmManagerfor receiving intents at the time of your choosing. -
A
NotificationManagerfor informing the user of background events. -
A
KeyguardManagerfor controlling keyguard. -
A
LocationManagerfor controlling location (e.g., GPS) updates. -
A
SearchManagerfor handling search. -
A
Vibratorfor interacting with the vibrator hardware. -
A
ConnectivityManagerfor handling management of network connections. -
A
WifiManagerfor management of Wi-Fi connectivity. -
An
InputMethodManagerfor management of input methods. -
An
UiModeManagerfor controlling UI modes. -
A
DownloadManagerfor requesting HTTP downloads
WINDOW_SERVICE ("window")
LAYOUT_INFLATER_SERVICE ("layout_inflater")
ACTIVITY_SERVICE ("activity")
POWER_SERVICE ("power")
ALARM_SERVICE ("alarm")
NOTIFICATION_SERVICE ("notification")
KEYGUARD_SERVICE ("keyguard")
LOCATION_SERVICE ("location")
SEARCH_SERVICE ("search")
VIBRATOR_SERVICE ("vibrator")
CONNECTIVITY_SERVICE ("connection")
WIFI_SERVICE ("wifi")
INPUT_METHOD_SERVICE ("input_method")
UI_MODE_SERVICE ("uimode")
DOWNLOAD_SERVICE ("download")
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.)
Parameters
| name | The name of the desired service. |
|---|
Returns
- The service or null if the name does not exist.
public final CharSequence getText (int resId)
Return a localized, styled CharSequence from the application's package's default string table.
Parameters
| resId | Resource id for the CharSequence text |
|---|
public abstract Resources.Theme getTheme ()
Return the Theme object associated with this Context.
public abstract FileInputStream openFileInput (String name)
Open a private file associated with this Context's application package for reading.
Parameters
| name | The name of the file to open; can not contain path separators. |
|---|
Returns
- FileInputStream Resulting input stream.
Throws
| FileNotFoundException |
|---|
public abstract FileOutputStream openFileOutput (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.
Parameters
| name | The name of the file to open; can not contain path separators. |
|---|---|
| mode | Operating mode. Use 0 or MODE_PRIVATE for the default operation, MODE_APPEND to append to an existing file, MODE_WORLD_READABLE and MODE_WORLD_WRITEABLE to control permissions. |
Returns
- FileOutputStream Resulting output stream.
public abstract SQLiteDatabase openOrCreateDatabase (String name, int mode, SQLiteDatabase.CursorFactory factory)
Open a new private SQLiteDatabase associated with this Context's application package. Create the database file if it doesn't exist.
Parameters
| name | The name (unique in the application package) of the database. |
|---|---|
| mode | Operating mode. Use 0 or MODE_PRIVATE for the default operation, MODE_WORLD_READABLE and MODE_WORLD_WRITEABLE to control permissions. Use 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. |
Returns
- The contents of a newly created database with the given name.
public abstract Intent registerReceiver (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 BroadcastReceiver for more information on Intent broadcasts.
As of ICE_CREAM_SANDWICH, receivers registered with this method will correctly respect the 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 registerReceiver(BroadcastReceiver, IntentFilter), since the lifetime of such a registered BroadcastReceiver is tied to the object that registered it.
Parameters
| receiver | The BroadcastReceiver to handle the broadcast. |
|---|---|
| filter | Selects the Intent broadcasts to be received. |
Returns
- The first sticky intent found that matches filter, or null if there are none.
public abstract void sendBroadcast (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 sendOrderedBroadcast(Intent, String).
See BroadcastReceiver for more information on Intent broadcasts.
Parameters
| intent | The Intent to broadcast; all receivers matching this Intent will receive the broadcast. |
|---|
public abstract void sendOrderedBroadcast (Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, String initialData, Bundle initialExtras)
Version of 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 onReceive(Context, 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 sendOrderedBroadcast(Intent, String).
Like sendBroadcast(Intent), this method is asynchronous; it will return before resultReceiver.onReceive() is called.
See BroadcastReceiver for more information on Intent broadcasts.
Parameters
| 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. |
public abstract void startActivities (Intent[] intents, Bundle options)
Launch multiple new activities. This is generally the same as calling startActivity(Intent) for the first Intent in the array, that activity during its creation calling 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.
Parameters
| 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. |
Throws
| ActivityNotFoundException |
public abstract void startActivity (Intent intent)
Same as startActivity(Intent, Bundle) with no options specified.
Parameters
| intent | The description of the activity to start. |
|---|
Throws
| ActivityNotFoundException |
public abstract void startActivity (Intent intent, Bundle options)
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 Activity Context, then the Intent must include the 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.
Parameters
| 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. |
Throws
| ActivityNotFoundException |
public abstract ComponentName startService (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 onStartCommand(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 bindService(Intent, ServiceConnection, int): it requires the service to remain running until stopService(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 stopService(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.
Parameters
| 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. |
|---|
Returns
- If the service is being started or is already running, the
ComponentNameof the actual service that was started is returned; else if the service does not exist null is returned.
public abstract boolean stopService (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 ServiceConnection objects bound to it with the 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.
Parameters
| 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 IntentFilter published by a service. |
|---|
Returns
- 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 |
public abstract void unbindService (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.
Parameters
| conn | The connection interface previously supplied to bindService(). This parameter must not be null. |
|---|
public abstract void unregisterReceiver (BroadcastReceiver receiver)
Unregister a previously registered BroadcastReceiver. All filters that have been registered for this BroadcastReceiver will be removed.
Parameters
| receiver | The BroadcastReceiver to unregister. |
|---|
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
