Context.java revision a5ef9acdf4dc31bfe4756b933806070355d6aa3f
1/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.content;
18
19import android.content.pm.ApplicationInfo;
20import android.content.pm.PackageManager;
21import android.content.res.AssetManager;
22import android.content.res.Resources;
23import android.content.res.TypedArray;
24import android.database.sqlite.SQLiteDatabase;
25import android.database.sqlite.SQLiteDatabase.CursorFactory;
26import android.graphics.Bitmap;
27import android.graphics.drawable.Drawable;
28import android.net.Uri;
29import android.os.Bundle;
30import android.os.Handler;
31import android.os.Looper;
32import android.util.AttributeSet;
33
34import java.io.File;
35import java.io.FileInputStream;
36import java.io.FileNotFoundException;
37import java.io.FileOutputStream;
38import java.io.IOException;
39import java.io.InputStream;
40
41/**
42 * Interface to global information about an application environment.  This is
43 * an abstract class whose implementation is provided by
44 * the Android system.  It
45 * allows access to application-specific resources and classes, as well as
46 * up-calls for application-level operations such as launching activities,
47 * broadcasting and receiving intents, etc.
48 */
49public abstract class Context {
50    /**
51     * File creation mode: the default mode, where the created file can only
52     * be accessed by the calling application (or all applications sharing the
53     * same user ID).
54     * @see #MODE_WORLD_READABLE
55     * @see #MODE_WORLD_WRITEABLE
56     */
57    public static final int MODE_PRIVATE = 0x0000;
58    /**
59     * File creation mode: allow all other applications to have read access
60     * to the created file.
61     * @see #MODE_PRIVATE
62     * @see #MODE_WORLD_WRITEABLE
63     */
64    public static final int MODE_WORLD_READABLE = 0x0001;
65    /**
66     * File creation mode: allow all other applications to have write access
67     * to the created file.
68     * @see #MODE_PRIVATE
69     * @see #MODE_WORLD_READABLE
70     */
71    public static final int MODE_WORLD_WRITEABLE = 0x0002;
72    /**
73     * File creation mode: for use with {@link #openFileOutput}, if the file
74     * already exists then write data to the end of the existing file
75     * instead of erasing it.
76     * @see #openFileOutput
77     */
78    public static final int MODE_APPEND = 0x8000;
79
80    /**
81     * Flag for {@link #bindService}: automatically create the service as long
82     * as the binding exists.  Note that while this will create the service,
83     * its {@link android.app.Service#onStart} method will still only be called due to an
84     * explicit call to {@link #startService}.  Even without that, though,
85     * this still provides you with access to the service object while the
86     * service is created.
87     *
88     * <p>Specifying this flag also tells the system to treat the service
89     * as being as important as your own process -- that is, when deciding
90     * which process should be killed to free memory, the service will only
91     * be considered a candidate as long as the processes of any such bindings
92     * is also a candidate to be killed.  This is to avoid situations where
93     * the service is being continually created and killed due to low memory.
94     */
95    public static final int BIND_AUTO_CREATE = 0x0001;
96
97    /**
98     * Flag for {@link #bindService}: include debugging help for mismatched
99     * calls to unbind.  When this flag is set, the callstack of the following
100     * {@link #unbindService} call is retained, to be printed if a later
101     * incorrect unbind call is made.  Note that doing this requires retaining
102     * information about the binding that was made for the lifetime of the app,
103     * resulting in a leak -- this should only be used for debugging.
104     */
105    public static final int BIND_DEBUG_UNBIND = 0x0002;
106
107    /** Return an AssetManager instance for your application's package. */
108    public abstract AssetManager getAssets();
109
110    /** Return a Resources instance for your application's package. */
111    public abstract Resources getResources();
112
113    /** Return PackageManager instance to find global package information. */
114    public abstract PackageManager getPackageManager();
115
116    /** Return a ContentResolver instance for your application's package. */
117    public abstract ContentResolver getContentResolver();
118
119    /**
120     * Return the Looper for the main thread of the current process.  This is
121     * the thread used to dispatch calls to application components (activities,
122     * services, etc).
123     */
124    public abstract Looper getMainLooper();
125
126    /**
127     * Return the context of the single, global Application object of the
128     * current process.
129     */
130    public abstract Context getApplicationContext();
131
132    /**
133     * Return a localized, styled CharSequence from the application's package's
134     * default string table.
135     *
136     * @param resId Resource id for the CharSequence text
137     */
138    public final CharSequence getText(int resId) {
139        return getResources().getText(resId);
140    }
141
142    /**
143     * Return a localized string from the application's package's
144     * default string table.
145     *
146     * @param resId Resource id for the string
147     */
148    public final String getString(int resId) {
149        return getResources().getString(resId);
150    }
151
152    /**
153     * Return a localized formatted string from the application's package's
154     * default string table, substituting the format arguments as defined in
155     * {@link java.util.Formatter} and {@link java.lang.String#format}.
156     *
157     * @param resId Resource id for the format string
158     * @param formatArgs The format arguments that will be used for substitution.
159     */
160
161    public final String getString(int resId, Object... formatArgs) {
162        return getResources().getString(resId, formatArgs);
163    }
164
165     /**
166     * Set the base theme for this context.  Note that this should be called
167     * before any views are instantiated in the Context (for example before
168     * calling {@link android.app.Activity#setContentView} or
169     * {@link android.view.LayoutInflater#inflate}).
170     *
171     * @param resid The style resource describing the theme.
172     */
173    public abstract void setTheme(int resid);
174
175    /**
176     * Return the Theme object associated with this Context.
177     */
178    public abstract Resources.Theme getTheme();
179
180    /**
181     * Retrieve styled attribute information in this Context's theme.  See
182     * {@link Resources.Theme#obtainStyledAttributes(int[])}
183     * for more information.
184     *
185     * @see Resources.Theme#obtainStyledAttributes(int[])
186     */
187    public final TypedArray obtainStyledAttributes(
188            int[] attrs) {
189        return getTheme().obtainStyledAttributes(attrs);
190    }
191
192    /**
193     * Retrieve styled attribute information in this Context's theme.  See
194     * {@link Resources.Theme#obtainStyledAttributes(int, int[])}
195     * for more information.
196     *
197     * @see Resources.Theme#obtainStyledAttributes(int, int[])
198     */
199    public final TypedArray obtainStyledAttributes(
200            int resid, int[] attrs) throws Resources.NotFoundException {
201        return getTheme().obtainStyledAttributes(resid, attrs);
202    }
203
204    /**
205     * Retrieve styled attribute information in this Context's theme.  See
206     * {@link Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)}
207     * for more information.
208     *
209     * @see Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)
210     */
211    public final TypedArray obtainStyledAttributes(
212            AttributeSet set, int[] attrs) {
213        return getTheme().obtainStyledAttributes(set, attrs, 0, 0);
214    }
215
216    /**
217     * Retrieve styled attribute information in this Context's theme.  See
218     * {@link Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)}
219     * for more information.
220     *
221     * @see Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)
222     */
223    public final TypedArray obtainStyledAttributes(
224            AttributeSet set, int[] attrs, int defStyleAttr, int defStyleRes) {
225        return getTheme().obtainStyledAttributes(
226            set, attrs, defStyleAttr, defStyleRes);
227    }
228
229    /**
230     * Return a class loader you can use to retrieve classes in this package.
231     */
232    public abstract ClassLoader getClassLoader();
233
234    /** Return the name of this application's package. */
235    public abstract String getPackageName();
236
237    /** Return the full application info for this context's package. */
238    public abstract ApplicationInfo getApplicationInfo();
239
240    /**
241     * {@hide}
242     * Return the full path to this context's resource files.  This is the ZIP files
243     * containing the application's resources.
244     *
245     * <p>Note: this is not generally useful for applications, since they should
246     * not be directly accessing the file system.
247     *
248     *
249     * @return String Path to the resources.
250     */
251    public abstract String getPackageResourcePath();
252
253    /**
254     * {@hide}
255     * Return the full path to this context's code and asset files.  This is the ZIP files
256     * containing the application's code and assets.
257     *
258     * <p>Note: this is not generally useful for applications, since they should
259     * not be directly accessing the file system.
260     *
261     * @return String Path to the code and assets.
262     */
263    public abstract String getPackageCodePath();
264
265    /**
266     * {@hide}
267     * Return the full path to the shared prefs file for the given prefs group name.
268     *
269     * <p>Note: this is not generally useful for applications, since they should
270     * not be directly accessing the file system.
271     */
272    public abstract File getSharedPrefsFile(String name);
273
274    /**
275     * Retrieve and hold the contents of the preferences file 'name', returning
276     * a SharedPreferences through which you can retrieve and modify its
277     * values.  Only one instance of the SharedPreferences object is returned
278     * to any callers for the same name, meaning they will see each other's
279     * edits as soon as they are made.
280     *
281     * @param name Desired preferences file. If a preferences file by this name
282     * does not exist, it will be created when you retrieve an
283     * editor (SharedPreferences.edit()) and then commit changes (Editor.commit()).
284     * @param mode Operating mode.  Use 0 or {@link #MODE_PRIVATE} for the
285     * default operation, {@link #MODE_WORLD_READABLE}
286     * and {@link #MODE_WORLD_WRITEABLE} to control permissions.
287     *
288     * @return Returns the single SharedPreferences instance that can be used
289     *         to retrieve and modify the preference values.
290     *
291     * @see #MODE_PRIVATE
292     * @see #MODE_WORLD_READABLE
293     * @see #MODE_WORLD_WRITEABLE
294     */
295    public abstract SharedPreferences getSharedPreferences(String name,
296            int mode);
297
298    /**
299     * Open a private file associated with this Context's application package
300     * for reading.
301     *
302     * @param name The name of the file to open; can not contain path
303     *             separators.
304     *
305     * @return FileInputStream Resulting input stream.
306     *
307     * @see #openFileOutput
308     * @see #fileList
309     * @see #deleteFile
310     * @see java.io.FileInputStream#FileInputStream(String)
311     */
312    public abstract FileInputStream openFileInput(String name)
313        throws FileNotFoundException;
314
315    /**
316     * Open a private file associated with this Context's application package
317     * for writing.  Creates the file if it doesn't already exist.
318     *
319     * @param name The name of the file to open; can not contain path
320     *             separators.
321     * @param mode Operating mode.  Use 0 or {@link #MODE_PRIVATE} for the
322     * default operation, {@link #MODE_APPEND} to append to an existing file,
323     * {@link #MODE_WORLD_READABLE} and {@link #MODE_WORLD_WRITEABLE} to control
324     * permissions.
325     *
326     * @return FileOutputStream Resulting output stream.
327     *
328     * @see #MODE_APPEND
329     * @see #MODE_PRIVATE
330     * @see #MODE_WORLD_READABLE
331     * @see #MODE_WORLD_WRITEABLE
332     * @see #openFileInput
333     * @see #fileList
334     * @see #deleteFile
335     * @see java.io.FileOutputStream#FileOutputStream(String)
336     */
337    public abstract FileOutputStream openFileOutput(String name, int mode)
338        throws FileNotFoundException;
339
340    /**
341     * Delete the given private file associated with this Context's
342     * application package.
343     *
344     * @param name The name of the file to delete; can not contain path
345     *             separators.
346     *
347     * @return True if the file was successfully deleted; else
348     *         false.
349     *
350     * @see #openFileInput
351     * @see #openFileOutput
352     * @see #fileList
353     * @see java.io.File#delete()
354     */
355    public abstract boolean deleteFile(String name);
356
357    /**
358     * Returns the absolute path on the filesystem where a file created with
359     * {@link #openFileOutput} is stored.
360     *
361     * @param name The name of the file for which you would like to get
362     *          its path.
363     *
364     * @return Returns an absolute path to the given file.
365     *
366     * @see #openFileOutput
367     * @see #getFilesDir
368     * @see #getDir
369     */
370    public abstract File getFileStreamPath(String name);
371
372    /**
373     * Returns the absolute path to the directory on the filesystem where
374     * files created with {@link #openFileOutput} are stored.
375     *
376     * @return Returns the path of the directory holding application files.
377     *
378     * @see #openFileOutput
379     * @see #getFileStreamPath
380     * @see #getDir
381     */
382    public abstract File getFilesDir();
383
384    /**
385     * Returns the absolute path to the application specific cache directory
386     * on the filesystem. These files will be ones that get deleted first when the
387     * device runs low on storage
388     * There is no guarantee when these files will be deleted.
389     *
390     * @return Returns the path of the directory holding application cache files.
391     *
392     * @see #openFileOutput
393     * @see #getFileStreamPath
394     * @see #getDir
395     */
396    public abstract File getCacheDir();
397
398    /**
399     * Returns an array of strings naming the private files associated with
400     * this Context's application package.
401     *
402     * @return Array of strings naming the private files.
403     *
404     * @see #openFileInput
405     * @see #openFileOutput
406     * @see #deleteFile
407     */
408    public abstract String[] fileList();
409
410    /**
411     * Retrieve, creating if needed, a new directory in which the application
412     * can place its own custom data files.  You can use the returned File
413     * object to create and access files in this directory.  Note that files
414     * created through a File object will only be accessible by your own
415     * application; you can only set the mode of the entire directory, not
416     * of individual files.
417     *
418     * @param name Name of the directory to retrieve.  This is a directory
419     * that is created as part of your application data.
420     * @param mode Operating mode.  Use 0 or {@link #MODE_PRIVATE} for the
421     * default operation, {@link #MODE_WORLD_READABLE} and
422     * {@link #MODE_WORLD_WRITEABLE} to control permissions.
423     *
424     * @return Returns a File object for the requested directory.  The directory
425     * will have been created if it does not already exist.
426     *
427     * @see #openFileOutput(String, int)
428     */
429    public abstract File getDir(String name, int mode);
430
431    /**
432     * Open a new private SQLiteDatabase associated with this Context's
433     * application package.  Create the database file if it doesn't exist.
434     *
435     * @param name The name (unique in the application package) of the database.
436     * @param mode Operating mode.  Use 0 or {@link #MODE_PRIVATE} for the
437     *     default operation, {@link #MODE_WORLD_READABLE}
438     *     and {@link #MODE_WORLD_WRITEABLE} to control permissions.
439     * @param factory An optional factory class that is called to instantiate a
440     *     cursor when query is called.
441     *
442     * @return The contents of a newly created database with the given name.
443     * @throws android.database.sqlite.SQLiteException if the database file could not be opened.
444     *
445     * @see #MODE_PRIVATE
446     * @see #MODE_WORLD_READABLE
447     * @see #MODE_WORLD_WRITEABLE
448     * @see #deleteDatabase
449     */
450    public abstract SQLiteDatabase openOrCreateDatabase(String name,
451            int mode, CursorFactory factory);
452
453    /**
454     * Delete an existing private SQLiteDatabase associated with this Context's
455     * application package.
456     *
457     * @param name The name (unique in the application package) of the
458     *             database.
459     *
460     * @return True if the database was successfully deleted; else false.
461     *
462     * @see #openOrCreateDatabase
463     */
464    public abstract boolean deleteDatabase(String name);
465
466    /**
467     * Returns the absolute path on the filesystem where a database created with
468     * {@link #openOrCreateDatabase} is stored.
469     *
470     * @param name The name of the database for which you would like to get
471     *          its path.
472     *
473     * @return Returns an absolute path to the given database.
474     *
475     * @see #openOrCreateDatabase
476     */
477    public abstract File getDatabasePath(String name);
478
479    /**
480     * Returns an array of strings naming the private databases associated with
481     * this Context's application package.
482     *
483     * @return Array of strings naming the private databases.
484     *
485     * @see #openOrCreateDatabase
486     * @see #deleteDatabase
487     */
488    public abstract String[] databaseList();
489
490    /**
491     * @deprecated Use {@link android.app.WallpaperManager#getDrawable
492     * WallpaperManager.get()} instead.
493     */
494    @Deprecated
495    public abstract Drawable getWallpaper();
496
497    /**
498     * @deprecated Use {@link android.app.WallpaperManager#peekDrawable
499     * WallpaperManager.peek()} instead.
500     */
501    @Deprecated
502    public abstract Drawable peekWallpaper();
503
504    /**
505     * @deprecated Use {@link android.app.WallpaperManager#getDesiredMinimumWidth()
506     * WallpaperManager.getDesiredMinimumWidth()} instead.
507     */
508    @Deprecated
509    public abstract int getWallpaperDesiredMinimumWidth();
510
511    /**
512     * @deprecated Use {@link android.app.WallpaperManager#getDesiredMinimumHeight()
513     * WallpaperManager.getDesiredMinimumHeight()} instead.
514     */
515    @Deprecated
516    public abstract int getWallpaperDesiredMinimumHeight();
517
518    /**
519     * @deprecated Use {@link android.app.WallpaperManager#setBitmap(Bitmap)
520     * WallpaperManager.set()} instead.
521     */
522    @Deprecated
523    public abstract void setWallpaper(Bitmap bitmap) throws IOException;
524
525    /**
526     * @deprecated Use {@link android.app.WallpaperManager#setStream(InputStream)
527     * WallpaperManager.set()} instead.
528     */
529    @Deprecated
530    public abstract void setWallpaper(InputStream data) throws IOException;
531
532    /**
533     * @deprecated Use {@link android.app.WallpaperManager#clear
534     * WallpaperManager.clear()} instead.
535     */
536    @Deprecated
537    public abstract void clearWallpaper() throws IOException;
538
539    /**
540     * Launch a new activity.  You will not receive any information about when
541     * the activity exits.
542     *
543     * <p>Note that if this method is being called from outside of an
544     * {@link android.app.Activity} Context, then the Intent must include
545     * the {@link Intent#FLAG_ACTIVITY_NEW_TASK} launch flag.  This is because,
546     * without being started from an existing Activity, there is no existing
547     * task in which to place the new activity and thus it needs to be placed
548     * in its own separate task.
549     *
550     * <p>This method throws {@link ActivityNotFoundException}
551     * if there was no Activity found to run the given Intent.
552     *
553     * @param intent The description of the activity to start.
554     *
555     * @throws ActivityNotFoundException
556     *
557     * @see PackageManager#resolveActivity
558     */
559    public abstract void startActivity(Intent intent);
560
561    /**
562     * Like {@link #startActivity(Intent)}, but taking a IntentSender
563     * to start.  If the IntentSender is for an activity, that activity will be started
564     * as if you had called the regular {@link #startActivity(Intent)}
565     * here; otherwise, its associated action will be executed (such as
566     * sending a broadcast) as if you had called
567     * {@link IntentSender#sendIntent IntentSender.sendIntent} on it.
568     *
569     * @param intent The IntentSender to launch.
570     * @param fillInIntent If non-null, this will be provided as the
571     * intent parameter to {@link IntentSender#sendIntent}.
572     * @param flagsMask Intent flags in the original IntentSender that you
573     * would like to change.
574     * @param flagsValues Desired values for any bits set in
575     * <var>flagsMask</var>
576     * @param extraFlags Always set to 0.
577     */
578    public abstract void startIntentSender(IntentSender intent,
579            Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags)
580            throws IntentSender.SendIntentException;
581
582    /**
583     * Broadcast the given intent to all interested BroadcastReceivers.  This
584     * call is asynchronous; it returns immediately, and you will continue
585     * executing while the receivers are run.  No results are propagated from
586     * receivers and receivers can not abort the broadcast. If you want
587     * to allow receivers to propagate results or abort the broadcast, you must
588     * send an ordered broadcast using
589     * {@link #sendOrderedBroadcast(Intent, String)}.
590     *
591     * <p>See {@link BroadcastReceiver} for more information on Intent broadcasts.
592     *
593     * @param intent The Intent to broadcast; all receivers matching this
594     *               Intent will receive the broadcast.
595     *
596     * @see android.content.BroadcastReceiver
597     * @see #registerReceiver
598     * @see #sendBroadcast(Intent, String)
599     * @see #sendOrderedBroadcast(Intent, String)
600     * @see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
601     */
602    public abstract void sendBroadcast(Intent intent);
603
604    /**
605     * Broadcast the given intent to all interested BroadcastReceivers, allowing
606     * an optional required permission to be enforced.  This
607     * call is asynchronous; it returns immediately, and you will continue
608     * executing while the receivers are run.  No results are propagated from
609     * receivers and receivers can not abort the broadcast. If you want
610     * to allow receivers to propagate results or abort the broadcast, you must
611     * send an ordered broadcast using
612     * {@link #sendOrderedBroadcast(Intent, String)}.
613     *
614     * <p>See {@link BroadcastReceiver} for more information on Intent broadcasts.
615     *
616     * @param intent The Intent to broadcast; all receivers matching this
617     *               Intent will receive the broadcast.
618     * @param receiverPermission (optional) String naming a permissions that
619     *               a receiver must hold in order to receive your broadcast.
620     *               If null, no permission is required.
621     *
622     * @see android.content.BroadcastReceiver
623     * @see #registerReceiver
624     * @see #sendBroadcast(Intent)
625     * @see #sendOrderedBroadcast(Intent, String)
626     * @see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
627     */
628    public abstract void sendBroadcast(Intent intent,
629            String receiverPermission);
630
631    /**
632     * Broadcast the given intent to all interested BroadcastReceivers, delivering
633     * them one at a time to allow more preferred receivers to consume the
634     * broadcast before it is delivered to less preferred receivers.  This
635     * call is asynchronous; it returns immediately, and you will continue
636     * executing while the receivers are run.
637     *
638     * <p>See {@link BroadcastReceiver} for more information on Intent broadcasts.
639     *
640     * @param intent The Intent to broadcast; all receivers matching this
641     *               Intent will receive the broadcast.
642     * @param receiverPermission (optional) String naming a permissions that
643     *               a receiver must hold in order to receive your broadcast.
644     *               If null, no permission is required.
645     *
646     * @see android.content.BroadcastReceiver
647     * @see #registerReceiver
648     * @see #sendBroadcast(Intent)
649     * @see #sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)
650     */
651    public abstract void sendOrderedBroadcast(Intent intent,
652            String receiverPermission);
653
654    /**
655     * Version of {@link #sendBroadcast(Intent)} that allows you to
656     * receive data back from the broadcast.  This is accomplished by
657     * supplying your own BroadcastReceiver when calling, which will be
658     * treated as a final receiver at the end of the broadcast -- its
659     * {@link BroadcastReceiver#onReceive} method will be called with
660     * the result values collected from the other receivers.  The broadcast will
661     * be serialized in the same way as calling
662     * {@link #sendOrderedBroadcast(Intent, String)}.
663     *
664     * <p>Like {@link #sendBroadcast(Intent)}, this method is
665     * asynchronous; it will return before
666     * resultReceiver.onReceive() is called.
667     *
668     * <p>See {@link BroadcastReceiver} for more information on Intent broadcasts.
669     *
670     * @param intent The Intent to broadcast; all receivers matching this
671     *               Intent will receive the broadcast.
672     * @param receiverPermission String naming a permissions that
673     *               a receiver must hold in order to receive your broadcast.
674     *               If null, no permission is required.
675     * @param resultReceiver Your own BroadcastReceiver to treat as the final
676     *                       receiver of the broadcast.
677     * @param scheduler A custom Handler with which to schedule the
678     *                  resultReceiver callback; if null it will be
679     *                  scheduled in the Context's main thread.
680     * @param initialCode An initial value for the result code.  Often
681     *                    Activity.RESULT_OK.
682     * @param initialData An initial value for the result data.  Often
683     *                    null.
684     * @param initialExtras An initial value for the result extras.  Often
685     *                      null.
686     *
687     * @see #sendBroadcast(Intent)
688     * @see #sendBroadcast(Intent, String)
689     * @see #sendOrderedBroadcast(Intent, String)
690     * @see #sendStickyBroadcast(Intent)
691     * @see #sendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, int, String, Bundle)
692     * @see android.content.BroadcastReceiver
693     * @see #registerReceiver
694     * @see android.app.Activity#RESULT_OK
695     */
696    public abstract void sendOrderedBroadcast(Intent intent,
697            String receiverPermission, BroadcastReceiver resultReceiver,
698            Handler scheduler, int initialCode, String initialData,
699            Bundle initialExtras);
700
701    /**
702     * Perform a {@link #sendBroadcast(Intent)} that is "sticky," meaning the
703     * Intent you are sending stays around after the broadcast is complete,
704     * so that others can quickly retrieve that data through the return
705     * value of {@link #registerReceiver(BroadcastReceiver, IntentFilter)}.  In
706     * all other ways, this behaves the same as
707     * {@link #sendBroadcast(Intent)}.
708     *
709     * <p>You must hold the {@link android.Manifest.permission#BROADCAST_STICKY}
710     * permission in order to use this API.  If you do not hold that
711     * permission, {@link SecurityException} will be thrown.
712     *
713     * @param intent The Intent to broadcast; all receivers matching this
714     * Intent will receive the broadcast, and the Intent will be held to
715     * be re-broadcast to future receivers.
716     *
717     * @see #sendBroadcast(Intent)
718     * @see #sendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, int, String, Bundle)
719     */
720    public abstract void sendStickyBroadcast(Intent intent);
721
722    /**
723     * Version of {@link #sendStickyBroadcast} that allows you to
724     * receive data back from the broadcast.  This is accomplished by
725     * supplying your own BroadcastReceiver when calling, which will be
726     * treated as a final receiver at the end of the broadcast -- its
727     * {@link BroadcastReceiver#onReceive} method will be called with
728     * the result values collected from the other receivers.  The broadcast will
729     * be serialized in the same way as calling
730     * {@link #sendOrderedBroadcast(Intent, String)}.
731     *
732     * <p>Like {@link #sendBroadcast(Intent)}, this method is
733     * asynchronous; it will return before
734     * resultReceiver.onReceive() is called.  Note that the sticky data
735     * stored is only the data you initially supply to the broadcast, not
736     * the result of any changes made by the receivers.
737     *
738     * <p>See {@link BroadcastReceiver} for more information on Intent broadcasts.
739     *
740     * @param intent The Intent to broadcast; all receivers matching this
741     *               Intent will receive the broadcast.
742     * @param resultReceiver Your own BroadcastReceiver to treat as the final
743     *                       receiver of the broadcast.
744     * @param scheduler A custom Handler with which to schedule the
745     *                  resultReceiver callback; if null it will be
746     *                  scheduled in the Context's main thread.
747     * @param initialCode An initial value for the result code.  Often
748     *                    Activity.RESULT_OK.
749     * @param initialData An initial value for the result data.  Often
750     *                    null.
751     * @param initialExtras An initial value for the result extras.  Often
752     *                      null.
753     *
754     * @see #sendBroadcast(Intent)
755     * @see #sendBroadcast(Intent, String)
756     * @see #sendOrderedBroadcast(Intent, String)
757     * @see #sendStickyBroadcast(Intent)
758     * @see android.content.BroadcastReceiver
759     * @see #registerReceiver
760     * @see android.app.Activity#RESULT_OK
761     */
762    public abstract void sendStickyOrderedBroadcast(Intent intent,
763            BroadcastReceiver resultReceiver,
764            Handler scheduler, int initialCode, String initialData,
765            Bundle initialExtras);
766
767
768    /**
769     * Remove the data previously sent with {@link #sendStickyBroadcast},
770     * so that it is as if the sticky broadcast had never happened.
771     *
772     * <p>You must hold the {@link android.Manifest.permission#BROADCAST_STICKY}
773     * permission in order to use this API.  If you do not hold that
774     * permission, {@link SecurityException} will be thrown.
775     *
776     * @param intent The Intent that was previously broadcast.
777     *
778     * @see #sendStickyBroadcast
779     */
780    public abstract void removeStickyBroadcast(Intent intent);
781
782    /**
783     * Register a BroadcastReceiver to be run in the main activity thread.  The
784     * <var>receiver</var> will be called with any broadcast Intent that
785     * matches <var>filter</var>, in the main application thread.
786     *
787     * <p>The system may broadcast Intents that are "sticky" -- these stay
788     * around after the broadcast as finished, to be sent to any later
789     * registrations. If your IntentFilter matches one of these sticky
790     * Intents, that Intent will be returned by this function
791     * <strong>and</strong> sent to your <var>receiver</var> as if it had just
792     * been broadcast.
793     *
794     * <p>There may be multiple sticky Intents that match <var>filter</var>,
795     * in which case each of these will be sent to <var>receiver</var>.  In
796     * this case, only one of these can be returned directly by the function;
797     * which of these that is returned is arbitrarily decided by the system.
798     *
799     * <p>If you know the Intent your are registering for is sticky, you can
800     * supply null for your <var>receiver</var>.  In this case, no receiver is
801     * registered -- the function simply returns the sticky Intent that
802     * matches <var>filter</var>.  In the case of multiple matches, the same
803     * rules as described above apply.
804     *
805     * <p>See {@link BroadcastReceiver} for more information on Intent broadcasts.
806     *
807     * <p class="note">Note: this method <em>cannot be called from a
808     * {@link BroadcastReceiver} component;</em> that is, from a BroadcastReceiver
809     * that is declared in an application's manifest.  It is okay, however, to call
810     * this method from another BroadcastReceiver that has itself been registered
811     * at run time with {@link #registerReceiver}, since the lifetime of such a
812     * registered BroadcastReceiver is tied to the object that registered it.</p>
813     *
814     * @param receiver The BroadcastReceiver to handle the broadcast.
815     * @param filter Selects the Intent broadcasts to be received.
816     *
817     * @return The first sticky intent found that matches <var>filter</var>,
818     *         or null if there are none.
819     *
820     * @see #registerReceiver(BroadcastReceiver, IntentFilter, String, Handler)
821     * @see #sendBroadcast
822     * @see #unregisterReceiver
823     */
824    public abstract Intent registerReceiver(BroadcastReceiver receiver,
825                                            IntentFilter filter);
826
827    /**
828     * Register to receive intent broadcasts, to run in the context of
829     * <var>scheduler</var>.  See
830     * {@link #registerReceiver(BroadcastReceiver, IntentFilter)} for more
831     * information.  This allows you to enforce permissions on who can
832     * broadcast intents to your receiver, or have the receiver run in
833     * a different thread than the main application thread.
834     *
835     * <p>See {@link BroadcastReceiver} for more information on Intent broadcasts.
836     *
837     * @param receiver The BroadcastReceiver to handle the broadcast.
838     * @param filter Selects the Intent broadcasts to be received.
839     * @param broadcastPermission String naming a permissions that a
840     *      broadcaster must hold in order to send an Intent to you.  If null,
841     *      no permission is required.
842     * @param scheduler Handler identifying the thread that will receive
843     *      the Intent.  If null, the main thread of the process will be used.
844     *
845     * @return The first sticky intent found that matches <var>filter</var>,
846     *         or null if there are none.
847     *
848     * @see #registerReceiver(BroadcastReceiver, IntentFilter)
849     * @see #sendBroadcast
850     * @see #unregisterReceiver
851     */
852    public abstract Intent registerReceiver(BroadcastReceiver receiver,
853                                            IntentFilter filter,
854                                            String broadcastPermission,
855                                            Handler scheduler);
856
857    /**
858     * Unregister a previously registered BroadcastReceiver.  <em>All</em>
859     * filters that have been registered for this BroadcastReceiver will be
860     * removed.
861     *
862     * @param receiver The BroadcastReceiver to unregister.
863     *
864     * @see #registerReceiver
865     */
866    public abstract void unregisterReceiver(BroadcastReceiver receiver);
867
868    /**
869     * Request that a given application service be started.  The Intent
870     * can either contain the complete class name of a specific service
871     * implementation to start, or an abstract definition through the
872     * action and other fields of the kind of service to start.  If this service
873     * is not already running, it will be instantiated and started (creating a
874     * process for it if needed); if it is running then it remains running.
875     *
876     * <p>Every call to this method will result in a corresponding call to
877     * the target service's {@link android.app.Service#onStart} method,
878     * with the <var>intent</var> given here.  This provides a convenient way
879     * to submit jobs to a service without having to bind and call on to its
880     * interface.
881     *
882     * <p>Using startService() overrides the default service lifetime that is
883     * managed by {@link #bindService}: it requires the service to remain
884     * running until {@link #stopService} is called, regardless of whether
885     * any clients are connected to it.  Note that calls to startService()
886     * are not nesting: no matter how many times you call startService(),
887     * a single call to {@link #stopService} will stop it.
888     *
889     * <p>The system attempts to keep running services around as much as
890     * possible.  The only time they should be stopped is if the current
891     * foreground application is using so many resources that the service needs
892     * to be killed.  If any errors happen in the service's process, it will
893     * automatically be restarted.
894     *
895     * <p>This function will throw {@link SecurityException} if you do not
896     * have permission to start the given service.
897     *
898     * @param service Identifies the service to be started.  The Intent may
899     *      specify either an explicit component name to start, or a logical
900     *      description (action, category, etc) to match an
901     *      {@link IntentFilter} published by a service.  Additional values
902     *      may be included in the Intent extras to supply arguments along with
903     *      this specific start call.
904     *
905     * @return If the service is being started or is already running, the
906     * {@link ComponentName} of the actual service that was started is
907     * returned; else if the service does not exist null is returned.
908     *
909     * @throws SecurityException
910     *
911     * @see #stopService
912     * @see #bindService
913     */
914    public abstract ComponentName startService(Intent service);
915
916    /**
917     * Request that a given application service be stopped.  If the service is
918     * not running, nothing happens.  Otherwise it is stopped.  Note that calls
919     * to startService() are not counted -- this stops the service no matter
920     * how many times it was started.
921     *
922     * <p>Note that if a stopped service still has {@link ServiceConnection}
923     * objects bound to it with the {@link #BIND_AUTO_CREATE} set, it will
924     * not be destroyed until all of these bindings are removed.  See
925     * the {@link android.app.Service} documentation for more details on a
926     * service's lifecycle.
927     *
928     * <p>This function will throw {@link SecurityException} if you do not
929     * have permission to stop the given service.
930     *
931     * @param service Description of the service to be stopped.  The Intent may
932     *      specify either an explicit component name to start, or a logical
933     *      description (action, category, etc) to match an
934     *      {@link IntentFilter} published by a service.
935     *
936     * @return If there is a service matching the given Intent that is already
937     * running, then it is stopped and true is returned; else false is returned.
938     *
939     * @throws SecurityException
940     *
941     * @see #startService
942     */
943    public abstract boolean stopService(Intent service);
944
945    /**
946     * Connect to an application service, creating it if needed.  This defines
947     * a dependency between your application and the service.  The given
948     * <var>conn</var> will receive the service object when its created and be
949     * told if it dies and restarts.  The service will be considered required
950     * by the system only for as long as the calling context exists.  For
951     * example, if this Context is an Activity that is stopped, the service will
952     * not be required to continue running until the Activity is resumed.
953     *
954     * <p>This function will throw {@link SecurityException} if you do not
955     * have permission to bind to the given service.
956     *
957     * <p class="note">Note: this method <em>can not be called from an
958     * {@link BroadcastReceiver} component</em>.  A pattern you can use to
959     * communicate from an BroadcastReceiver to a Service is to call
960     * {@link #startService} with the arguments containing the command to be
961     * sent, with the service calling its
962     * {@link android.app.Service#stopSelf(int)} method when done executing
963     * that command.  See the API demo App/Service/Service Start Arguments
964     * Controller for an illustration of this.  It is okay, however, to use
965     * this method from an BroadcastReceiver that has been registered with
966     * {@link #registerReceiver}, since the lifetime of this BroadcastReceiver
967     * is tied to another object (the one that registered it).</p>
968     *
969     * @param service Identifies the service to connect to.  The Intent may
970     *      specify either an explicit component name, or a logical
971     *      description (action, category, etc) to match an
972     *      {@link IntentFilter} published by a service.
973     * @param conn Receives information as the service is started and stopped.
974     * @param flags Operation options for the binding.  May be 0 or
975     *          {@link #BIND_AUTO_CREATE}.
976     * @return If you have successfully bound to the service, true is returned;
977     *         false is returned if the connection is not made so you will not
978     *         receive the service object.
979     *
980     * @throws SecurityException
981     *
982     * @see #unbindService
983     * @see #startService
984     * @see #BIND_AUTO_CREATE
985     */
986    public abstract boolean bindService(Intent service, ServiceConnection conn,
987            int flags);
988
989    /**
990     * Disconnect from an application service.  You will no longer receive
991     * calls as the service is restarted, and the service is now allowed to
992     * stop at any time.
993     *
994     * @param conn The connection interface previously supplied to
995     *             bindService().
996     *
997     * @see #bindService
998     */
999    public abstract void unbindService(ServiceConnection conn);
1000
1001    /**
1002     * Start executing an {@link android.app.Instrumentation} class.  The given
1003     * Instrumentation component will be run by killing its target application
1004     * (if currently running), starting the target process, instantiating the
1005     * instrumentation component, and then letting it drive the application.
1006     *
1007     * <p>This function is not synchronous -- it returns as soon as the
1008     * instrumentation has started and while it is running.
1009     *
1010     * <p>Instrumentation is normally only allowed to run against a package
1011     * that is either unsigned or signed with a signature that the
1012     * the instrumentation package is also signed with (ensuring the target
1013     * trusts the instrumentation).
1014     *
1015     * @param className Name of the Instrumentation component to be run.
1016     * @param profileFile Optional path to write profiling data as the
1017     * instrumentation runs, or null for no profiling.
1018     * @param arguments Additional optional arguments to pass to the
1019     * instrumentation, or null.
1020     *
1021     * @return Returns true if the instrumentation was successfully started,
1022     * else false if it could not be found.
1023     */
1024    public abstract boolean startInstrumentation(ComponentName className,
1025            String profileFile, Bundle arguments);
1026
1027    /**
1028     * Return the handle to a system-level service by name. The class of the
1029     * returned object varies by the requested name. Currently available names
1030     * are:
1031     *
1032     * <dl>
1033     *  <dt> {@link #WINDOW_SERVICE} ("window")
1034     *  <dd> The top-level window manager in which you can place custom
1035     *  windows.  The returned object is a {@link android.view.WindowManager}.
1036     *  <dt> {@link #LAYOUT_INFLATER_SERVICE} ("layout_inflater")
1037     *  <dd> A {@link android.view.LayoutInflater} for inflating layout resources
1038     *  in this context.
1039     *  <dt> {@link #ACTIVITY_SERVICE} ("activity")
1040     *  <dd> A {@link android.app.ActivityManager} for interacting with the
1041     *  global activity state of the system.
1042     *  <dt> {@link #POWER_SERVICE} ("power")
1043     *  <dd> A {@link android.os.PowerManager} for controlling power
1044     *  management.
1045     *  <dt> {@link #ALARM_SERVICE} ("alarm")
1046     *  <dd> A {@link android.app.AlarmManager} for receiving intents at the
1047     *  time of your choosing.
1048     *  <dt> {@link #NOTIFICATION_SERVICE} ("notification")
1049     *  <dd> A {@link android.app.NotificationManager} for informing the user
1050     *   of background events.
1051     *  <dt> {@link #KEYGUARD_SERVICE} ("keyguard")
1052     *  <dd> A {@link android.app.KeyguardManager} for controlling keyguard.
1053     *  <dt> {@link #LOCATION_SERVICE} ("location")
1054     *  <dd> A {@link android.location.LocationManager} for controlling location
1055     *   (e.g., GPS) updates.
1056     *  <dt> {@link #SEARCH_SERVICE} ("search")
1057     *  <dd> A {@link android.app.SearchManager} for handling search.
1058     *  <dt> {@link #VIBRATOR_SERVICE} ("vibrator")
1059     *  <dd> A {@link android.os.Vibrator} for interacting with the vibrator
1060     *  hardware.
1061     *  <dt> {@link #CONNECTIVITY_SERVICE} ("connection")
1062     *  <dd> A {@link android.net.ConnectivityManager ConnectivityManager} for
1063     *  handling management of network connections.
1064     *  <dt> {@link #WIFI_SERVICE} ("wifi")
1065     *  <dd> A {@link android.net.wifi.WifiManager WifiManager} for management of
1066     * Wi-Fi connectivity.
1067     * <dt> {@link #INPUT_METHOD_SERVICE} ("input_method")
1068     * <dd> An {@link android.view.inputmethod.InputMethodManager InputMethodManager}
1069     * for management of input methods.
1070     * </dl>
1071     *
1072     * <p>Note:  System services obtained via this API may be closely associated with
1073     * the Context in which they are obtained from.  In general, do not share the
1074     * service objects between various different contexts (Activities, Applications,
1075     * Services, Providers, etc.)
1076     *
1077     * @param name The name of the desired service.
1078     *
1079     * @return The service or null if the name does not exist.
1080     *
1081     * @see #WINDOW_SERVICE
1082     * @see android.view.WindowManager
1083     * @see #LAYOUT_INFLATER_SERVICE
1084     * @see android.view.LayoutInflater
1085     * @see #ACTIVITY_SERVICE
1086     * @see android.app.ActivityManager
1087     * @see #POWER_SERVICE
1088     * @see android.os.PowerManager
1089     * @see #ALARM_SERVICE
1090     * @see android.app.AlarmManager
1091     * @see #NOTIFICATION_SERVICE
1092     * @see android.app.NotificationManager
1093     * @see #KEYGUARD_SERVICE
1094     * @see android.app.KeyguardManager
1095     * @see #LOCATION_SERVICE
1096     * @see android.location.LocationManager
1097     * @see #SEARCH_SERVICE
1098     * @see android.app.SearchManager
1099     * @see #SENSOR_SERVICE
1100     * @see android.hardware.SensorManager
1101     * @see #VIBRATOR_SERVICE
1102     * @see android.os.Vibrator
1103     * @see #CONNECTIVITY_SERVICE
1104     * @see android.net.ConnectivityManager
1105     * @see #WIFI_SERVICE
1106     * @see android.net.wifi.WifiManager
1107     * @see #AUDIO_SERVICE
1108     * @see android.media.AudioManager
1109     * @see #TELEPHONY_SERVICE
1110     * @see android.telephony.TelephonyManager
1111     * @see #INPUT_METHOD_SERVICE
1112     * @see android.view.inputmethod.InputMethodManager
1113     */
1114    public abstract Object getSystemService(String name);
1115
1116    /**
1117     * Use with {@link #getSystemService} to retrieve a
1118     * {@link android.os.PowerManager} for controlling power management,
1119     * including "wake locks," which let you keep the device on while
1120     * you're running long tasks.
1121     */
1122    public static final String POWER_SERVICE = "power";
1123    /**
1124     * Use with {@link #getSystemService} to retrieve a
1125     * {@link android.view.WindowManager} for accessing the system's window
1126     * manager.
1127     *
1128     * @see #getSystemService
1129     * @see android.view.WindowManager
1130     */
1131    public static final String WINDOW_SERVICE = "window";
1132    /**
1133     * Use with {@link #getSystemService} to retrieve a
1134     * {@link android.view.LayoutInflater} for inflating layout resources in this
1135     * context.
1136     *
1137     * @see #getSystemService
1138     * @see android.view.LayoutInflater
1139     */
1140    public static final String LAYOUT_INFLATER_SERVICE = "layout_inflater";
1141    /**
1142     * Use with {@link #getSystemService} to retrieve a
1143     * {@link android.accounts.AccountManager} for receiving intents at a
1144     * time of your choosing.
1145     *
1146     * @see #getSystemService
1147     * @see android.accounts.AccountManager
1148     */
1149    public static final String ACCOUNT_SERVICE = "account";
1150    /**
1151     * Use with {@link #getSystemService} to retrieve a
1152     * {@link android.app.ActivityManager} for interacting with the global
1153     * system state.
1154     *
1155     * @see #getSystemService
1156     * @see android.app.ActivityManager
1157     */
1158    public static final String ACTIVITY_SERVICE = "activity";
1159    /**
1160     * Use with {@link #getSystemService} to retrieve a
1161     * {@link android.app.AlarmManager} for receiving intents at a
1162     * time of your choosing.
1163     *
1164     * @see #getSystemService
1165     * @see android.app.AlarmManager
1166     */
1167    public static final String ALARM_SERVICE = "alarm";
1168    /**
1169     * Use with {@link #getSystemService} to retrieve a
1170     * {@link android.app.NotificationManager} for informing the user of
1171     * background events.
1172     *
1173     * @see #getSystemService
1174     * @see android.app.NotificationManager
1175     */
1176    public static final String NOTIFICATION_SERVICE = "notification";
1177    /**
1178     * Use with {@link #getSystemService} to retrieve a
1179     * {@link android.view.accessibility.AccessibilityManager} for giving the user
1180     * feedback for UI events through the registered event listeners.
1181     *
1182     * @see #getSystemService
1183     * @see android.view.accessibility.AccessibilityManager
1184     */
1185    public static final String ACCESSIBILITY_SERVICE = "accessibility";
1186    /**
1187     * Use with {@link #getSystemService} to retrieve a
1188     * {@link android.app.NotificationManager} for controlling keyguard.
1189     *
1190     * @see #getSystemService
1191     * @see android.app.KeyguardManager
1192     */
1193    public static final String KEYGUARD_SERVICE = "keyguard";
1194    /**
1195     * Use with {@link #getSystemService} to retrieve a {@link
1196     * android.location.LocationManager} for controlling location
1197     * updates.
1198     *
1199     * @see #getSystemService
1200     * @see android.location.LocationManager
1201     */
1202    public static final String LOCATION_SERVICE = "location";
1203    /**
1204     * Use with {@link #getSystemService} to retrieve a {@link
1205     * android.app.SearchManager} for handling searches.
1206     *
1207     * @see #getSystemService
1208     * @see android.app.SearchManager
1209     */
1210    public static final String SEARCH_SERVICE = "search";
1211    /**
1212     * Use with {@link #getSystemService} to retrieve a {@link
1213     * android.hardware.SensorManager} for accessing sensors.
1214     *
1215     * @see #getSystemService
1216     * @see android.hardware.SensorManager
1217     */
1218    public static final String SENSOR_SERVICE = "sensor";
1219    /**
1220     * Use with {@link #getSystemService} to retrieve a
1221     * com.android.server.WallpaperService for accessing wallpapers.
1222     *
1223     * @see #getSystemService
1224     */
1225    public static final String WALLPAPER_SERVICE = "wallpaper";
1226    /**
1227     * Use with {@link #getSystemService} to retrieve a {@link
1228     * android.os.Vibrator} for interacting with the vibration hardware.
1229     *
1230     * @see #getSystemService
1231     * @see android.os.Vibrator
1232     */
1233    public static final String VIBRATOR_SERVICE = "vibrator";
1234    /**
1235     * Use with {@link #getSystemService} to retrieve a {@link
1236     * android.app.StatusBarManager} for interacting with the status bar.
1237     *
1238     * @see #getSystemService
1239     * @see android.app.StatusBarManager
1240     * @hide
1241     */
1242    public static final String STATUS_BAR_SERVICE = "statusbar";
1243
1244    /**
1245     * Use with {@link #getSystemService} to retrieve a {@link
1246     * android.net.ConnectivityManager} for handling management of
1247     * network connections.
1248     *
1249     * @see #getSystemService
1250     * @see android.net.ConnectivityManager
1251     */
1252    public static final String CONNECTIVITY_SERVICE = "connectivity";
1253
1254    /**
1255     * Use with {@link #getSystemService} to retrieve a {@link
1256     * android.net.wifi.WifiManager} for handling management of
1257     * Wi-Fi access.
1258     *
1259     * @see #getSystemService
1260     * @see android.net.wifi.WifiManager
1261     */
1262    public static final String WIFI_SERVICE = "wifi";
1263
1264    /**
1265     * Use with {@link #getSystemService} to retrieve a
1266     * {@link android.media.AudioManager} for handling management of volume,
1267     * ringer modes and audio routing.
1268     *
1269     * @see #getSystemService
1270     * @see android.media.AudioManager
1271     */
1272    public static final String AUDIO_SERVICE = "audio";
1273
1274    /**
1275     * Use with {@link #getSystemService} to retrieve a
1276     * {@link android.telephony.TelephonyManager} for handling management the
1277     * telephony features of the device.
1278     *
1279     * @see #getSystemService
1280     * @see android.telephony.TelephonyManager
1281     */
1282    public static final String TELEPHONY_SERVICE = "phone";
1283
1284    /**
1285     * Use with {@link #getSystemService} to retrieve a
1286     * {@link android.text.ClipboardManager} for accessing and modifying
1287     * the contents of the global clipboard.
1288     *
1289     * @see #getSystemService
1290     * @see android.text.ClipboardManager
1291     */
1292    public static final String CLIPBOARD_SERVICE = "clipboard";
1293
1294    /**
1295     * Use with {@link #getSystemService} to retrieve a
1296     * {@link android.view.inputmethod.InputMethodManager} for accessing input
1297     * methods.
1298     *
1299     * @see #getSystemService
1300     */
1301    public static final String INPUT_METHOD_SERVICE = "input_method";
1302
1303    /**
1304     * Use with {@link #getSystemService} to retrieve a
1305     * {@blink android.appwidget.AppWidgetManager} for accessing AppWidgets.
1306     *
1307     * @hide
1308     * @see #getSystemService
1309     */
1310    public static final String APPWIDGET_SERVICE = "appwidget";
1311
1312    /**
1313     * Use with {@link #getSystemService} to retrieve an
1314     * {@blink android.backup.IBackupManager IBackupManager} for communicating
1315     * with the backup mechanism.
1316     * @hide
1317     *
1318     * @see #getSystemService
1319     */
1320    public static final String BACKUP_SERVICE = "backup";
1321
1322    /**
1323     * Determine whether the given permission is allowed for a particular
1324     * process and user ID running in the system.
1325     *
1326     * @param permission The name of the permission being checked.
1327     * @param pid The process ID being checked against.  Must be > 0.
1328     * @param uid The user ID being checked against.  A uid of 0 is the root
1329     * user, which will pass every permission check.
1330     *
1331     * @return Returns {@link PackageManager#PERMISSION_GRANTED} if the given
1332     * pid/uid is allowed that permission, or
1333     * {@link PackageManager#PERMISSION_DENIED} if it is not.
1334     *
1335     * @see PackageManager#checkPermission(String, String)
1336     * @see #checkCallingPermission
1337     */
1338    public abstract int checkPermission(String permission, int pid, int uid);
1339
1340    /**
1341     * Determine whether the calling process of an IPC you are handling has been
1342     * granted a particular permission.  This is basically the same as calling
1343     * {@link #checkPermission(String, int, int)} with the pid and uid returned
1344     * by {@link android.os.Binder#getCallingPid} and
1345     * {@link android.os.Binder#getCallingUid}.  One important difference
1346     * is that if you are not currently processing an IPC, this function
1347     * will always fail.  This is done to protect against accidentally
1348     * leaking permissions; you can use {@link #checkCallingOrSelfPermission}
1349     * to avoid this protection.
1350     *
1351     * @param permission The name of the permission being checked.
1352     *
1353     * @return Returns {@link PackageManager#PERMISSION_GRANTED} if the calling
1354     * pid/uid is allowed that permission, or
1355     * {@link PackageManager#PERMISSION_DENIED} if it is not.
1356     *
1357     * @see PackageManager#checkPermission(String, String)
1358     * @see #checkPermission
1359     * @see #checkCallingOrSelfPermission
1360     */
1361    public abstract int checkCallingPermission(String permission);
1362
1363    /**
1364     * Determine whether the calling process of an IPC <em>or you</em> have been
1365     * granted a particular permission.  This is the same as
1366     * {@link #checkCallingPermission}, except it grants your own permissions
1367     * if you are not currently processing an IPC.  Use with care!
1368     *
1369     * @param permission The name of the permission being checked.
1370     *
1371     * @return Returns {@link PackageManager#PERMISSION_GRANTED} if the calling
1372     * pid/uid is allowed that permission, or
1373     * {@link PackageManager#PERMISSION_DENIED} if it is not.
1374     *
1375     * @see PackageManager#checkPermission(String, String)
1376     * @see #checkPermission
1377     * @see #checkCallingPermission
1378     */
1379    public abstract int checkCallingOrSelfPermission(String permission);
1380
1381    /**
1382     * If the given permission is not allowed for a particular process
1383     * and user ID running in the system, throw a {@link SecurityException}.
1384     *
1385     * @param permission The name of the permission being checked.
1386     * @param pid The process ID being checked against.  Must be &gt; 0.
1387     * @param uid The user ID being checked against.  A uid of 0 is the root
1388     * user, which will pass every permission check.
1389     * @param message A message to include in the exception if it is thrown.
1390     *
1391     * @see #checkPermission(String, int, int)
1392     */
1393    public abstract void enforcePermission(
1394            String permission, int pid, int uid, String message);
1395
1396    /**
1397     * If the calling process of an IPC you are handling has not been
1398     * granted a particular permission, throw a {@link
1399     * SecurityException}.  This is basically the same as calling
1400     * {@link #enforcePermission(String, int, int, String)} with the
1401     * pid and uid returned by {@link android.os.Binder#getCallingPid}
1402     * and {@link android.os.Binder#getCallingUid}.  One important
1403     * difference is that if you are not currently processing an IPC,
1404     * this function will always throw the SecurityException.  This is
1405     * done to protect against accidentally leaking permissions; you
1406     * can use {@link #enforceCallingOrSelfPermission} to avoid this
1407     * protection.
1408     *
1409     * @param permission The name of the permission being checked.
1410     * @param message A message to include in the exception if it is thrown.
1411     *
1412     * @see #checkCallingPermission(String)
1413     */
1414    public abstract void enforceCallingPermission(
1415            String permission, String message);
1416
1417    /**
1418     * If neither you nor the calling process of an IPC you are
1419     * handling has been granted a particular permission, throw a
1420     * {@link SecurityException}.  This is the same as {@link
1421     * #enforceCallingPermission}, except it grants your own
1422     * permissions if you are not currently processing an IPC.  Use
1423     * with care!
1424     *
1425     * @param permission The name of the permission being checked.
1426     * @param message A message to include in the exception if it is thrown.
1427     *
1428     * @see #checkCallingOrSelfPermission(String)
1429     */
1430    public abstract void enforceCallingOrSelfPermission(
1431            String permission, String message);
1432
1433    /**
1434     * Grant permission to access a specific Uri to another package, regardless
1435     * of whether that package has general permission to access the Uri's
1436     * content provider.  This can be used to grant specific, temporary
1437     * permissions, typically in response to user interaction (such as the
1438     * user opening an attachment that you would like someone else to
1439     * display).
1440     *
1441     * <p>Normally you should use {@link Intent#FLAG_GRANT_READ_URI_PERMISSION
1442     * Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1443     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION
1444     * Intent.FLAG_GRANT_WRITE_URI_PERMISSION} with the Intent being used to
1445     * start an activity instead of this function directly.  If you use this
1446     * function directly, you should be sure to call
1447     * {@link #revokeUriPermission} when the target should no longer be allowed
1448     * to access it.
1449     *
1450     * <p>To succeed, the content provider owning the Uri must have set the
1451     * {@link android.R.styleable#AndroidManifestProvider_grantUriPermissions
1452     * grantUriPermissions} attribute in its manifest or included the
1453     * {@link android.R.styleable#AndroidManifestGrantUriPermission
1454     * &lt;grant-uri-permissions&gt;} tag.
1455     *
1456     * @param toPackage The package you would like to allow to access the Uri.
1457     * @param uri The Uri you would like to grant access to.
1458     * @param modeFlags The desired access modes.  Any combination of
1459     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION
1460     * Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1461     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION
1462     * Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1463     *
1464     * @see #revokeUriPermission
1465     */
1466    public abstract void grantUriPermission(String toPackage, Uri uri,
1467            int modeFlags);
1468
1469    /**
1470     * Remove all permissions to access a particular content provider Uri
1471     * that were previously added with {@link #grantUriPermission}.  The given
1472     * Uri will match all previously granted Uris that are the same or a
1473     * sub-path of the given Uri.  That is, revoking "content://foo/one" will
1474     * revoke both "content://foo/target" and "content://foo/target/sub", but not
1475     * "content://foo".
1476     *
1477     * @param uri The Uri you would like to revoke access to.
1478     * @param modeFlags The desired access modes.  Any combination of
1479     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION
1480     * Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1481     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION
1482     * Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1483     *
1484     * @see #grantUriPermission
1485     */
1486    public abstract void revokeUriPermission(Uri uri, int modeFlags);
1487
1488    /**
1489     * Determine whether a particular process and user ID has been granted
1490     * permission to access a specific URI.  This only checks for permissions
1491     * that have been explicitly granted -- if the given process/uid has
1492     * more general access to the URI's content provider then this check will
1493     * always fail.
1494     *
1495     * @param uri The uri that is being checked.
1496     * @param pid The process ID being checked against.  Must be &gt; 0.
1497     * @param uid The user ID being checked against.  A uid of 0 is the root
1498     * user, which will pass every permission check.
1499     * @param modeFlags The type of access to grant.  May be one or both of
1500     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1501     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1502     *
1503     * @return Returns {@link PackageManager#PERMISSION_GRANTED} if the given
1504     * pid/uid is allowed to access that uri, or
1505     * {@link PackageManager#PERMISSION_DENIED} if it is not.
1506     *
1507     * @see #checkCallingUriPermission
1508     */
1509    public abstract int checkUriPermission(Uri uri, int pid, int uid, int modeFlags);
1510
1511    /**
1512     * Determine whether the calling process and user ID has been
1513     * granted permission to access a specific URI.  This is basically
1514     * the same as calling {@link #checkUriPermission(Uri, int, int,
1515     * int)} with the pid and uid returned by {@link
1516     * android.os.Binder#getCallingPid} and {@link
1517     * android.os.Binder#getCallingUid}.  One important difference is
1518     * that if you are not currently processing an IPC, this function
1519     * will always fail.
1520     *
1521     * @param uri The uri that is being checked.
1522     * @param modeFlags The type of access to grant.  May be one or both of
1523     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1524     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1525     *
1526     * @return Returns {@link PackageManager#PERMISSION_GRANTED} if the caller
1527     * is allowed to access that uri, or
1528     * {@link PackageManager#PERMISSION_DENIED} if it is not.
1529     *
1530     * @see #checkUriPermission(Uri, int, int, int)
1531     */
1532    public abstract int checkCallingUriPermission(Uri uri, int modeFlags);
1533
1534    /**
1535     * Determine whether the calling process of an IPC <em>or you</em> has been granted
1536     * permission to access a specific URI.  This is the same as
1537     * {@link #checkCallingUriPermission}, except it grants your own permissions
1538     * if you are not currently processing an IPC.  Use with care!
1539     *
1540     * @param uri The uri that is being checked.
1541     * @param modeFlags The type of access to grant.  May be one or both of
1542     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1543     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1544     *
1545     * @return Returns {@link PackageManager#PERMISSION_GRANTED} if the caller
1546     * is allowed to access that uri, or
1547     * {@link PackageManager#PERMISSION_DENIED} if it is not.
1548     *
1549     * @see #checkCallingUriPermission
1550     */
1551    public abstract int checkCallingOrSelfUriPermission(Uri uri, int modeFlags);
1552
1553    /**
1554     * Check both a Uri and normal permission.  This allows you to perform
1555     * both {@link #checkPermission} and {@link #checkUriPermission} in one
1556     * call.
1557     *
1558     * @param uri The Uri whose permission is to be checked, or null to not
1559     * do this check.
1560     * @param readPermission The permission that provides overall read access,
1561     * or null to not do this check.
1562     * @param writePermission The permission that provides overall write
1563     * acess, or null to not do this check.
1564     * @param pid The process ID being checked against.  Must be &gt; 0.
1565     * @param uid The user ID being checked against.  A uid of 0 is the root
1566     * user, which will pass every permission check.
1567     * @param modeFlags The type of access to grant.  May be one or both of
1568     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1569     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1570     *
1571     * @return Returns {@link PackageManager#PERMISSION_GRANTED} if the caller
1572     * is allowed to access that uri or holds one of the given permissions, or
1573     * {@link PackageManager#PERMISSION_DENIED} if it is not.
1574     */
1575    public abstract int checkUriPermission(Uri uri, String readPermission,
1576            String writePermission, int pid, int uid, int modeFlags);
1577
1578    /**
1579     * If a particular process and user ID has not been granted
1580     * permission to access a specific URI, throw {@link
1581     * SecurityException}.  This only checks for permissions that have
1582     * been explicitly granted -- if the given process/uid has more
1583     * general access to the URI's content provider then this check
1584     * will always fail.
1585     *
1586     * @param uri The uri that is being checked.
1587     * @param pid The process ID being checked against.  Must be &gt; 0.
1588     * @param uid The user ID being checked against.  A uid of 0 is the root
1589     * user, which will pass every permission check.
1590     * @param modeFlags The type of access to grant.  May be one or both of
1591     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1592     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1593     * @param message A message to include in the exception if it is thrown.
1594     *
1595     * @see #checkUriPermission(Uri, int, int, int)
1596     */
1597    public abstract void enforceUriPermission(
1598            Uri uri, int pid, int uid, int modeFlags, String message);
1599
1600    /**
1601     * If the calling process and user ID has not been granted
1602     * permission to access a specific URI, throw {@link
1603     * SecurityException}.  This is basically the same as calling
1604     * {@link #enforceUriPermission(Uri, int, int, int, String)} with
1605     * the pid and uid returned by {@link
1606     * android.os.Binder#getCallingPid} and {@link
1607     * android.os.Binder#getCallingUid}.  One important difference is
1608     * that if you are not currently processing an IPC, this function
1609     * will always throw a SecurityException.
1610     *
1611     * @param uri The uri that is being checked.
1612     * @param modeFlags The type of access to grant.  May be one or both of
1613     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1614     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1615     * @param message A message to include in the exception if it is thrown.
1616     *
1617     * @see #checkCallingUriPermission(Uri, int)
1618     */
1619    public abstract void enforceCallingUriPermission(
1620            Uri uri, int modeFlags, String message);
1621
1622    /**
1623     * If the calling process of an IPC <em>or you</em> has not been
1624     * granted permission to access a specific URI, throw {@link
1625     * SecurityException}.  This is the same as {@link
1626     * #enforceCallingUriPermission}, except it grants your own
1627     * permissions if you are not currently processing an IPC.  Use
1628     * with care!
1629     *
1630     * @param uri The uri that is being checked.
1631     * @param modeFlags The type of access to grant.  May be one or both of
1632     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1633     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1634     * @param message A message to include in the exception if it is thrown.
1635     *
1636     * @see #checkCallingOrSelfUriPermission(Uri, int)
1637     */
1638    public abstract void enforceCallingOrSelfUriPermission(
1639            Uri uri, int modeFlags, String message);
1640
1641    /**
1642     * Enforce both a Uri and normal permission.  This allows you to perform
1643     * both {@link #enforcePermission} and {@link #enforceUriPermission} in one
1644     * call.
1645     *
1646     * @param uri The Uri whose permission is to be checked, or null to not
1647     * do this check.
1648     * @param readPermission The permission that provides overall read access,
1649     * or null to not do this check.
1650     * @param writePermission The permission that provides overall write
1651     * acess, or null to not do this check.
1652     * @param pid The process ID being checked against.  Must be &gt; 0.
1653     * @param uid The user ID being checked against.  A uid of 0 is the root
1654     * user, which will pass every permission check.
1655     * @param modeFlags The type of access to grant.  May be one or both of
1656     * {@link Intent#FLAG_GRANT_READ_URI_PERMISSION Intent.FLAG_GRANT_READ_URI_PERMISSION} or
1657     * {@link Intent#FLAG_GRANT_WRITE_URI_PERMISSION Intent.FLAG_GRANT_WRITE_URI_PERMISSION}.
1658     * @param message A message to include in the exception if it is thrown.
1659     *
1660     * @see #checkUriPermission(Uri, String, String, int, int, int)
1661     */
1662    public abstract void enforceUriPermission(
1663            Uri uri, String readPermission, String writePermission,
1664            int pid, int uid, int modeFlags, String message);
1665
1666    /**
1667     * Flag for use with {@link #createPackageContext}: include the application
1668     * code with the context.  This means loading code into the caller's
1669     * process, so that {@link #getClassLoader()} can be used to instantiate
1670     * the application's classes.  Setting this flags imposes security
1671     * restrictions on what application context you can access; if the
1672     * requested application can not be safely loaded into your process,
1673     * java.lang.SecurityException will be thrown.  If this flag is not set,
1674     * there will be no restrictions on the packages that can be loaded,
1675     * but {@link #getClassLoader} will always return the default system
1676     * class loader.
1677     */
1678    public static final int CONTEXT_INCLUDE_CODE = 0x00000001;
1679
1680    /**
1681     * Flag for use with {@link #createPackageContext}: ignore any security
1682     * restrictions on the Context being requested, allowing it to always
1683     * be loaded.  For use with {@link #CONTEXT_INCLUDE_CODE} to allow code
1684     * to be loaded into a process even when it isn't safe to do so.  Use
1685     * with extreme care!
1686     */
1687    public static final int CONTEXT_IGNORE_SECURITY = 0x00000002;
1688
1689    /**
1690     * Flag for use with {@link #createPackageContext}: a restricted context may
1691     * disable specific features. For instance, a View associated with a restricted
1692     * context would ignore particular XML attributes.
1693     */
1694    public static final int CONTEXT_RESTRICTED = 0x00000004;
1695
1696    /**
1697     * Return a new Context object for the given application name.  This
1698     * Context is the same as what the named application gets when it is
1699     * launched, containing the same resources and class loader.  Each call to
1700     * this method returns a new instance of a Context object; Context objects
1701     * are not shared, however they share common state (Resources, ClassLoader,
1702     * etc) so the Context instance itself is fairly lightweight.
1703     *
1704     * <p>Throws {@link PackageManager.NameNotFoundException} if there is no
1705     * application with the given package name.
1706     *
1707     * <p>Throws {@link java.lang.SecurityException} if the Context requested
1708     * can not be loaded into the caller's process for security reasons (see
1709     * {@link #CONTEXT_INCLUDE_CODE} for more information}.
1710     *
1711     * @param packageName Name of the application's package.
1712     * @param flags Option flags, one of {@link #CONTEXT_INCLUDE_CODE}
1713     *              or {@link #CONTEXT_IGNORE_SECURITY}.
1714     *
1715     * @return A Context for the application.
1716     *
1717     * @throws java.lang.SecurityException
1718     * @throws PackageManager.NameNotFoundException if there is no application with
1719     * the given package name
1720     */
1721    public abstract Context createPackageContext(String packageName,
1722            int flags) throws PackageManager.NameNotFoundException;
1723
1724    /**
1725     * Indicates whether this Context is restricted.
1726     *
1727     * @return True if this Context is restricted, false otherwise.
1728     *
1729     * @see #CONTEXT_RESTRICTED
1730     */
1731    public boolean isRestricted() {
1732        return false;
1733    }
1734}
1735