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.annotation.AnyRes;
20import android.annotation.IntDef;
21import android.annotation.SdkConstant;
22import android.annotation.SdkConstant.SdkConstantType;
23import android.annotation.SystemApi;
24import android.content.pm.ActivityInfo;
25import android.content.pm.ApplicationInfo;
26import android.content.pm.ComponentInfo;
27import android.content.pm.PackageManager;
28import android.content.pm.ResolveInfo;
29import android.content.res.Resources;
30import android.content.res.TypedArray;
31import android.graphics.Rect;
32import android.net.Uri;
33import android.os.Build;
34import android.os.Bundle;
35import android.os.IBinder;
36import android.os.Parcel;
37import android.os.Parcelable;
38import android.os.Process;
39import android.os.ResultReceiver;
40import android.os.ShellCommand;
41import android.os.StrictMode;
42import android.os.UserHandle;
43import android.provider.DocumentsContract;
44import android.provider.DocumentsProvider;
45import android.provider.MediaStore;
46import android.provider.OpenableColumns;
47import android.util.ArraySet;
48import android.util.AttributeSet;
49import android.util.Log;
50import com.android.internal.util.XmlUtils;
51import org.xmlpull.v1.XmlPullParser;
52import org.xmlpull.v1.XmlPullParserException;
53import org.xmlpull.v1.XmlSerializer;
54
55import java.io.IOException;
56import java.io.PrintWriter;
57import java.io.Serializable;
58import java.lang.annotation.Retention;
59import java.lang.annotation.RetentionPolicy;
60import java.net.URISyntaxException;
61import java.util.ArrayList;
62import java.util.HashSet;
63import java.util.List;
64import java.util.Locale;
65import java.util.Objects;
66import java.util.Set;
67
68import static android.content.ContentProvider.maybeAddUserId;
69
70/**
71 * An intent is an abstract description of an operation to be performed.  It
72 * can be used with {@link Context#startActivity(Intent) startActivity} to
73 * launch an {@link android.app.Activity},
74 * {@link android.content.Context#sendBroadcast(Intent) broadcastIntent} to
75 * send it to any interested {@link BroadcastReceiver BroadcastReceiver} components,
76 * and {@link android.content.Context#startService} or
77 * {@link android.content.Context#bindService} to communicate with a
78 * background {@link android.app.Service}.
79 *
80 * <p>An Intent provides a facility for performing late runtime binding between the code in
81 * different applications. Its most significant use is in the launching of activities, where it
82 * can be thought of as the glue between activities. It is basically a passive data structure
83 * holding an abstract description of an action to be performed.</p>
84 *
85 * <div class="special reference">
86 * <h3>Developer Guides</h3>
87 * <p>For information about how to create and resolve intents, read the
88 * <a href="{@docRoot}guide/topics/intents/intents-filters.html">Intents and Intent Filters</a>
89 * developer guide.</p>
90 * </div>
91 *
92 * <a name="IntentStructure"></a>
93 * <h3>Intent Structure</h3>
94 * <p>The primary pieces of information in an intent are:</p>
95 *
96 * <ul>
97 *   <li> <p><b>action</b> -- The general action to be performed, such as
98 *     {@link #ACTION_VIEW}, {@link #ACTION_EDIT}, {@link #ACTION_MAIN},
99 *     etc.</p>
100 *   </li>
101 *   <li> <p><b>data</b> -- The data to operate on, such as a person record
102 *     in the contacts database, expressed as a {@link android.net.Uri}.</p>
103 *   </li>
104 * </ul>
105 *
106 *
107 * <p>Some examples of action/data pairs are:</p>
108 *
109 * <ul>
110 *   <li> <p><b>{@link #ACTION_VIEW} <i>content://contacts/people/1</i></b> -- Display
111 *     information about the person whose identifier is "1".</p>
112 *   </li>
113 *   <li> <p><b>{@link #ACTION_DIAL} <i>content://contacts/people/1</i></b> -- Display
114 *     the phone dialer with the person filled in.</p>
115 *   </li>
116 *   <li> <p><b>{@link #ACTION_VIEW} <i>tel:123</i></b> -- Display
117 *     the phone dialer with the given number filled in.  Note how the
118 *     VIEW action does what is considered the most reasonable thing for
119 *     a particular URI.</p>
120 *   </li>
121 *   <li> <p><b>{@link #ACTION_DIAL} <i>tel:123</i></b> -- Display
122 *     the phone dialer with the given number filled in.</p>
123 *   </li>
124 *   <li> <p><b>{@link #ACTION_EDIT} <i>content://contacts/people/1</i></b> -- Edit
125 *     information about the person whose identifier is "1".</p>
126 *   </li>
127 *   <li> <p><b>{@link #ACTION_VIEW} <i>content://contacts/people/</i></b> -- Display
128 *     a list of people, which the user can browse through.  This example is a
129 *     typical top-level entry into the Contacts application, showing you the
130 *     list of people. Selecting a particular person to view would result in a
131 *     new intent { <b>{@link #ACTION_VIEW} <i>content://contacts/people/N</i></b> }
132 *     being used to start an activity to display that person.</p>
133 *   </li>
134 * </ul>
135 *
136 * <p>In addition to these primary attributes, there are a number of secondary
137 * attributes that you can also include with an intent:</p>
138 *
139 * <ul>
140 *     <li> <p><b>category</b> -- Gives additional information about the action
141 *         to execute.  For example, {@link #CATEGORY_LAUNCHER} means it should
142 *         appear in the Launcher as a top-level application, while
143 *         {@link #CATEGORY_ALTERNATIVE} means it should be included in a list
144 *         of alternative actions the user can perform on a piece of data.</p>
145 *     <li> <p><b>type</b> -- Specifies an explicit type (a MIME type) of the
146 *         intent data.  Normally the type is inferred from the data itself.
147 *         By setting this attribute, you disable that evaluation and force
148 *         an explicit type.</p>
149 *     <li> <p><b>component</b> -- Specifies an explicit name of a component
150 *         class to use for the intent.  Normally this is determined by looking
151 *         at the other information in the intent (the action, data/type, and
152 *         categories) and matching that with a component that can handle it.
153 *         If this attribute is set then none of the evaluation is performed,
154 *         and this component is used exactly as is.  By specifying this attribute,
155 *         all of the other Intent attributes become optional.</p>
156 *     <li> <p><b>extras</b> -- This is a {@link Bundle} of any additional information.
157 *         This can be used to provide extended information to the component.
158 *         For example, if we have a action to send an e-mail message, we could
159 *         also include extra pieces of data here to supply a subject, body,
160 *         etc.</p>
161 * </ul>
162 *
163 * <p>Here are some examples of other operations you can specify as intents
164 * using these additional parameters:</p>
165 *
166 * <ul>
167 *   <li> <p><b>{@link #ACTION_MAIN} with category {@link #CATEGORY_HOME}</b> --
168 *     Launch the home screen.</p>
169 *   </li>
170 *   <li> <p><b>{@link #ACTION_GET_CONTENT} with MIME type
171 *     <i>{@link android.provider.Contacts.Phones#CONTENT_URI
172 *     vnd.android.cursor.item/phone}</i></b>
173 *     -- Display the list of people's phone numbers, allowing the user to
174 *     browse through them and pick one and return it to the parent activity.</p>
175 *   </li>
176 *   <li> <p><b>{@link #ACTION_GET_CONTENT} with MIME type
177 *     <i>*{@literal /}*</i> and category {@link #CATEGORY_OPENABLE}</b>
178 *     -- Display all pickers for data that can be opened with
179 *     {@link ContentResolver#openInputStream(Uri) ContentResolver.openInputStream()},
180 *     allowing the user to pick one of them and then some data inside of it
181 *     and returning the resulting URI to the caller.  This can be used,
182 *     for example, in an e-mail application to allow the user to pick some
183 *     data to include as an attachment.</p>
184 *   </li>
185 * </ul>
186 *
187 * <p>There are a variety of standard Intent action and category constants
188 * defined in the Intent class, but applications can also define their own.
189 * These strings use Java-style scoping, to ensure they are unique -- for
190 * example, the standard {@link #ACTION_VIEW} is called
191 * "android.intent.action.VIEW".</p>
192 *
193 * <p>Put together, the set of actions, data types, categories, and extra data
194 * defines a language for the system allowing for the expression of phrases
195 * such as "call john smith's cell".  As applications are added to the system,
196 * they can extend this language by adding new actions, types, and categories, or
197 * they can modify the behavior of existing phrases by supplying their own
198 * activities that handle them.</p>
199 *
200 * <a name="IntentResolution"></a>
201 * <h3>Intent Resolution</h3>
202 *
203 * <p>There are two primary forms of intents you will use.
204 *
205 * <ul>
206 *     <li> <p><b>Explicit Intents</b> have specified a component (via
207 *     {@link #setComponent} or {@link #setClass}), which provides the exact
208 *     class to be run.  Often these will not include any other information,
209 *     simply being a way for an application to launch various internal
210 *     activities it has as the user interacts with the application.
211 *
212 *     <li> <p><b>Implicit Intents</b> have not specified a component;
213 *     instead, they must include enough information for the system to
214 *     determine which of the available components is best to run for that
215 *     intent.
216 * </ul>
217 *
218 * <p>When using implicit intents, given such an arbitrary intent we need to
219 * know what to do with it. This is handled by the process of <em>Intent
220 * resolution</em>, which maps an Intent to an {@link android.app.Activity},
221 * {@link BroadcastReceiver}, or {@link android.app.Service} (or sometimes two or
222 * more activities/receivers) that can handle it.</p>
223 *
224 * <p>The intent resolution mechanism basically revolves around matching an
225 * Intent against all of the &lt;intent-filter&gt; descriptions in the
226 * installed application packages.  (Plus, in the case of broadcasts, any {@link BroadcastReceiver}
227 * objects explicitly registered with {@link Context#registerReceiver}.)  More
228 * details on this can be found in the documentation on the {@link
229 * IntentFilter} class.</p>
230 *
231 * <p>There are three pieces of information in the Intent that are used for
232 * resolution: the action, type, and category.  Using this information, a query
233 * is done on the {@link PackageManager} for a component that can handle the
234 * intent. The appropriate component is determined based on the intent
235 * information supplied in the <code>AndroidManifest.xml</code> file as
236 * follows:</p>
237 *
238 * <ul>
239 *     <li> <p>The <b>action</b>, if given, must be listed by the component as
240 *         one it handles.</p>
241 *     <li> <p>The <b>type</b> is retrieved from the Intent's data, if not
242 *         already supplied in the Intent.  Like the action, if a type is
243 *         included in the intent (either explicitly or implicitly in its
244 *         data), then this must be listed by the component as one it handles.</p>
245 *     <li> For data that is not a <code>content:</code> URI and where no explicit
246 *         type is included in the Intent, instead the <b>scheme</b> of the
247 *         intent data (such as <code>http:</code> or <code>mailto:</code>) is
248 *         considered. Again like the action, if we are matching a scheme it
249 *         must be listed by the component as one it can handle.
250 *     <li> <p>The <b>categories</b>, if supplied, must <em>all</em> be listed
251 *         by the activity as categories it handles.  That is, if you include
252 *         the categories {@link #CATEGORY_LAUNCHER} and
253 *         {@link #CATEGORY_ALTERNATIVE}, then you will only resolve to components
254 *         with an intent that lists <em>both</em> of those categories.
255 *         Activities will very often need to support the
256 *         {@link #CATEGORY_DEFAULT} so that they can be found by
257 *         {@link Context#startActivity Context.startActivity()}.</p>
258 * </ul>
259 *
260 * <p>For example, consider the Note Pad sample application that
261 * allows user to browse through a list of notes data and view details about
262 * individual items.  Text in italics indicate places were you would replace a
263 * name with one specific to your own package.</p>
264 *
265 * <pre> &lt;manifest xmlns:android="http://schemas.android.com/apk/res/android"
266 *       package="<i>com.android.notepad</i>"&gt;
267 *     &lt;application android:icon="@drawable/app_notes"
268 *             android:label="@string/app_name"&gt;
269 *
270 *         &lt;provider class=".NotePadProvider"
271 *                 android:authorities="<i>com.google.provider.NotePad</i>" /&gt;
272 *
273 *         &lt;activity class=".NotesList" android:label="@string/title_notes_list"&gt;
274 *             &lt;intent-filter&gt;
275 *                 &lt;action android:name="android.intent.action.MAIN" /&gt;
276 *                 &lt;category android:name="android.intent.category.LAUNCHER" /&gt;
277 *             &lt;/intent-filter&gt;
278 *             &lt;intent-filter&gt;
279 *                 &lt;action android:name="android.intent.action.VIEW" /&gt;
280 *                 &lt;action android:name="android.intent.action.EDIT" /&gt;
281 *                 &lt;action android:name="android.intent.action.PICK" /&gt;
282 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
283 *                 &lt;data android:mimeType="vnd.android.cursor.dir/<i>vnd.google.note</i>" /&gt;
284 *             &lt;/intent-filter&gt;
285 *             &lt;intent-filter&gt;
286 *                 &lt;action android:name="android.intent.action.GET_CONTENT" /&gt;
287 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
288 *                 &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
289 *             &lt;/intent-filter&gt;
290 *         &lt;/activity&gt;
291 *
292 *         &lt;activity class=".NoteEditor" android:label="@string/title_note"&gt;
293 *             &lt;intent-filter android:label="@string/resolve_edit"&gt;
294 *                 &lt;action android:name="android.intent.action.VIEW" /&gt;
295 *                 &lt;action android:name="android.intent.action.EDIT" /&gt;
296 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
297 *                 &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
298 *             &lt;/intent-filter&gt;
299 *
300 *             &lt;intent-filter&gt;
301 *                 &lt;action android:name="android.intent.action.INSERT" /&gt;
302 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
303 *                 &lt;data android:mimeType="vnd.android.cursor.dir/<i>vnd.google.note</i>" /&gt;
304 *             &lt;/intent-filter&gt;
305 *
306 *         &lt;/activity&gt;
307 *
308 *         &lt;activity class=".TitleEditor" android:label="@string/title_edit_title"
309 *                 android:theme="@android:style/Theme.Dialog"&gt;
310 *             &lt;intent-filter android:label="@string/resolve_title"&gt;
311 *                 &lt;action android:name="<i>com.android.notepad.action.EDIT_TITLE</i>" /&gt;
312 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
313 *                 &lt;category android:name="android.intent.category.ALTERNATIVE" /&gt;
314 *                 &lt;category android:name="android.intent.category.SELECTED_ALTERNATIVE" /&gt;
315 *                 &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
316 *             &lt;/intent-filter&gt;
317 *         &lt;/activity&gt;
318 *
319 *     &lt;/application&gt;
320 * &lt;/manifest&gt;</pre>
321 *
322 * <p>The first activity,
323 * <code>com.android.notepad.NotesList</code>, serves as our main
324 * entry into the app.  It can do three things as described by its three intent
325 * templates:
326 * <ol>
327 * <li><pre>
328 * &lt;intent-filter&gt;
329 *     &lt;action android:name="{@link #ACTION_MAIN android.intent.action.MAIN}" /&gt;
330 *     &lt;category android:name="{@link #CATEGORY_LAUNCHER android.intent.category.LAUNCHER}" /&gt;
331 * &lt;/intent-filter&gt;</pre>
332 * <p>This provides a top-level entry into the NotePad application: the standard
333 * MAIN action is a main entry point (not requiring any other information in
334 * the Intent), and the LAUNCHER category says that this entry point should be
335 * listed in the application launcher.</p>
336 * <li><pre>
337 * &lt;intent-filter&gt;
338 *     &lt;action android:name="{@link #ACTION_VIEW android.intent.action.VIEW}" /&gt;
339 *     &lt;action android:name="{@link #ACTION_EDIT android.intent.action.EDIT}" /&gt;
340 *     &lt;action android:name="{@link #ACTION_PICK android.intent.action.PICK}" /&gt;
341 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
342 *     &lt;data android:mimeType="vnd.android.cursor.dir/<i>vnd.google.note</i>" /&gt;
343 * &lt;/intent-filter&gt;</pre>
344 * <p>This declares the things that the activity can do on a directory of
345 * notes.  The type being supported is given with the &lt;type&gt; tag, where
346 * <code>vnd.android.cursor.dir/vnd.google.note</code> is a URI from which
347 * a Cursor of zero or more items (<code>vnd.android.cursor.dir</code>) can
348 * be retrieved which holds our note pad data (<code>vnd.google.note</code>).
349 * The activity allows the user to view or edit the directory of data (via
350 * the VIEW and EDIT actions), or to pick a particular note and return it
351 * to the caller (via the PICK action).  Note also the DEFAULT category
352 * supplied here: this is <em>required</em> for the
353 * {@link Context#startActivity Context.startActivity} method to resolve your
354 * activity when its component name is not explicitly specified.</p>
355 * <li><pre>
356 * &lt;intent-filter&gt;
357 *     &lt;action android:name="{@link #ACTION_GET_CONTENT android.intent.action.GET_CONTENT}" /&gt;
358 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
359 *     &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
360 * &lt;/intent-filter&gt;</pre>
361 * <p>This filter describes the ability to return to the caller a note selected by
362 * the user without needing to know where it came from.  The data type
363 * <code>vnd.android.cursor.item/vnd.google.note</code> is a URI from which
364 * a Cursor of exactly one (<code>vnd.android.cursor.item</code>) item can
365 * be retrieved which contains our note pad data (<code>vnd.google.note</code>).
366 * The GET_CONTENT action is similar to the PICK action, where the activity
367 * will return to its caller a piece of data selected by the user.  Here,
368 * however, the caller specifies the type of data they desire instead of
369 * the type of data the user will be picking from.</p>
370 * </ol>
371 *
372 * <p>Given these capabilities, the following intents will resolve to the
373 * NotesList activity:</p>
374 *
375 * <ul>
376 *     <li> <p><b>{ action=android.app.action.MAIN }</b> matches all of the
377 *         activities that can be used as top-level entry points into an
378 *         application.</p>
379 *     <li> <p><b>{ action=android.app.action.MAIN,
380 *         category=android.app.category.LAUNCHER }</b> is the actual intent
381 *         used by the Launcher to populate its top-level list.</p>
382 *     <li> <p><b>{ action=android.intent.action.VIEW
383 *          data=content://com.google.provider.NotePad/notes }</b>
384 *         displays a list of all the notes under
385 *         "content://com.google.provider.NotePad/notes", which
386 *         the user can browse through and see the details on.</p>
387 *     <li> <p><b>{ action=android.app.action.PICK
388 *          data=content://com.google.provider.NotePad/notes }</b>
389 *         provides a list of the notes under
390 *         "content://com.google.provider.NotePad/notes", from which
391 *         the user can pick a note whose data URL is returned back to the caller.</p>
392 *     <li> <p><b>{ action=android.app.action.GET_CONTENT
393 *          type=vnd.android.cursor.item/vnd.google.note }</b>
394 *         is similar to the pick action, but allows the caller to specify the
395 *         kind of data they want back so that the system can find the appropriate
396 *         activity to pick something of that data type.</p>
397 * </ul>
398 *
399 * <p>The second activity,
400 * <code>com.android.notepad.NoteEditor</code>, shows the user a single
401 * note entry and allows them to edit it.  It can do two things as described
402 * by its two intent templates:
403 * <ol>
404 * <li><pre>
405 * &lt;intent-filter android:label="@string/resolve_edit"&gt;
406 *     &lt;action android:name="{@link #ACTION_VIEW android.intent.action.VIEW}" /&gt;
407 *     &lt;action android:name="{@link #ACTION_EDIT android.intent.action.EDIT}" /&gt;
408 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
409 *     &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
410 * &lt;/intent-filter&gt;</pre>
411 * <p>The first, primary, purpose of this activity is to let the user interact
412 * with a single note, as decribed by the MIME type
413 * <code>vnd.android.cursor.item/vnd.google.note</code>.  The activity can
414 * either VIEW a note or allow the user to EDIT it.  Again we support the
415 * DEFAULT category to allow the activity to be launched without explicitly
416 * specifying its component.</p>
417 * <li><pre>
418 * &lt;intent-filter&gt;
419 *     &lt;action android:name="{@link #ACTION_INSERT android.intent.action.INSERT}" /&gt;
420 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
421 *     &lt;data android:mimeType="vnd.android.cursor.dir/<i>vnd.google.note</i>" /&gt;
422 * &lt;/intent-filter&gt;</pre>
423 * <p>The secondary use of this activity is to insert a new note entry into
424 * an existing directory of notes.  This is used when the user creates a new
425 * note: the INSERT action is executed on the directory of notes, causing
426 * this activity to run and have the user create the new note data which
427 * it then adds to the content provider.</p>
428 * </ol>
429 *
430 * <p>Given these capabilities, the following intents will resolve to the
431 * NoteEditor activity:</p>
432 *
433 * <ul>
434 *     <li> <p><b>{ action=android.intent.action.VIEW
435 *          data=content://com.google.provider.NotePad/notes/<var>{ID}</var> }</b>
436 *         shows the user the content of note <var>{ID}</var>.</p>
437 *     <li> <p><b>{ action=android.app.action.EDIT
438 *          data=content://com.google.provider.NotePad/notes/<var>{ID}</var> }</b>
439 *         allows the user to edit the content of note <var>{ID}</var>.</p>
440 *     <li> <p><b>{ action=android.app.action.INSERT
441 *          data=content://com.google.provider.NotePad/notes }</b>
442 *         creates a new, empty note in the notes list at
443 *         "content://com.google.provider.NotePad/notes"
444 *         and allows the user to edit it.  If they keep their changes, the URI
445 *         of the newly created note is returned to the caller.</p>
446 * </ul>
447 *
448 * <p>The last activity,
449 * <code>com.android.notepad.TitleEditor</code>, allows the user to
450 * edit the title of a note.  This could be implemented as a class that the
451 * application directly invokes (by explicitly setting its component in
452 * the Intent), but here we show a way you can publish alternative
453 * operations on existing data:</p>
454 *
455 * <pre>
456 * &lt;intent-filter android:label="@string/resolve_title"&gt;
457 *     &lt;action android:name="<i>com.android.notepad.action.EDIT_TITLE</i>" /&gt;
458 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
459 *     &lt;category android:name="{@link #CATEGORY_ALTERNATIVE android.intent.category.ALTERNATIVE}" /&gt;
460 *     &lt;category android:name="{@link #CATEGORY_SELECTED_ALTERNATIVE android.intent.category.SELECTED_ALTERNATIVE}" /&gt;
461 *     &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
462 * &lt;/intent-filter&gt;</pre>
463 *
464 * <p>In the single intent template here, we
465 * have created our own private action called
466 * <code>com.android.notepad.action.EDIT_TITLE</code> which means to
467 * edit the title of a note.  It must be invoked on a specific note
468 * (data type <code>vnd.android.cursor.item/vnd.google.note</code>) like the previous
469 * view and edit actions, but here displays and edits the title contained
470 * in the note data.
471 *
472 * <p>In addition to supporting the default category as usual, our title editor
473 * also supports two other standard categories: ALTERNATIVE and
474 * SELECTED_ALTERNATIVE.  Implementing
475 * these categories allows others to find the special action it provides
476 * without directly knowing about it, through the
477 * {@link android.content.pm.PackageManager#queryIntentActivityOptions} method, or
478 * more often to build dynamic menu items with
479 * {@link android.view.Menu#addIntentOptions}.  Note that in the intent
480 * template here was also supply an explicit name for the template
481 * (via <code>android:label="@string/resolve_title"</code>) to better control
482 * what the user sees when presented with this activity as an alternative
483 * action to the data they are viewing.
484 *
485 * <p>Given these capabilities, the following intent will resolve to the
486 * TitleEditor activity:</p>
487 *
488 * <ul>
489 *     <li> <p><b>{ action=com.android.notepad.action.EDIT_TITLE
490 *          data=content://com.google.provider.NotePad/notes/<var>{ID}</var> }</b>
491 *         displays and allows the user to edit the title associated
492 *         with note <var>{ID}</var>.</p>
493 * </ul>
494 *
495 * <h3>Standard Activity Actions</h3>
496 *
497 * <p>These are the current standard actions that Intent defines for launching
498 * activities (usually through {@link Context#startActivity}.  The most
499 * important, and by far most frequently used, are {@link #ACTION_MAIN} and
500 * {@link #ACTION_EDIT}.
501 *
502 * <ul>
503 *     <li> {@link #ACTION_MAIN}
504 *     <li> {@link #ACTION_VIEW}
505 *     <li> {@link #ACTION_ATTACH_DATA}
506 *     <li> {@link #ACTION_EDIT}
507 *     <li> {@link #ACTION_PICK}
508 *     <li> {@link #ACTION_CHOOSER}
509 *     <li> {@link #ACTION_GET_CONTENT}
510 *     <li> {@link #ACTION_DIAL}
511 *     <li> {@link #ACTION_CALL}
512 *     <li> {@link #ACTION_SEND}
513 *     <li> {@link #ACTION_SENDTO}
514 *     <li> {@link #ACTION_ANSWER}
515 *     <li> {@link #ACTION_INSERT}
516 *     <li> {@link #ACTION_DELETE}
517 *     <li> {@link #ACTION_RUN}
518 *     <li> {@link #ACTION_SYNC}
519 *     <li> {@link #ACTION_PICK_ACTIVITY}
520 *     <li> {@link #ACTION_SEARCH}
521 *     <li> {@link #ACTION_WEB_SEARCH}
522 *     <li> {@link #ACTION_FACTORY_TEST}
523 * </ul>
524 *
525 * <h3>Standard Broadcast Actions</h3>
526 *
527 * <p>These are the current standard actions that Intent defines for receiving
528 * broadcasts (usually through {@link Context#registerReceiver} or a
529 * &lt;receiver&gt; tag in a manifest).
530 *
531 * <ul>
532 *     <li> {@link #ACTION_TIME_TICK}
533 *     <li> {@link #ACTION_TIME_CHANGED}
534 *     <li> {@link #ACTION_TIMEZONE_CHANGED}
535 *     <li> {@link #ACTION_BOOT_COMPLETED}
536 *     <li> {@link #ACTION_PACKAGE_ADDED}
537 *     <li> {@link #ACTION_PACKAGE_CHANGED}
538 *     <li> {@link #ACTION_PACKAGE_REMOVED}
539 *     <li> {@link #ACTION_PACKAGE_RESTARTED}
540 *     <li> {@link #ACTION_PACKAGE_DATA_CLEARED}
541 *     <li> {@link #ACTION_PACKAGES_SUSPENDED}
542 *     <li> {@link #ACTION_PACKAGES_UNSUSPENDED}
543 *     <li> {@link #ACTION_UID_REMOVED}
544 *     <li> {@link #ACTION_BATTERY_CHANGED}
545 *     <li> {@link #ACTION_POWER_CONNECTED}
546 *     <li> {@link #ACTION_POWER_DISCONNECTED}
547 *     <li> {@link #ACTION_SHUTDOWN}
548 * </ul>
549 *
550 * <h3>Standard Categories</h3>
551 *
552 * <p>These are the current standard categories that can be used to further
553 * clarify an Intent via {@link #addCategory}.
554 *
555 * <ul>
556 *     <li> {@link #CATEGORY_DEFAULT}
557 *     <li> {@link #CATEGORY_BROWSABLE}
558 *     <li> {@link #CATEGORY_TAB}
559 *     <li> {@link #CATEGORY_ALTERNATIVE}
560 *     <li> {@link #CATEGORY_SELECTED_ALTERNATIVE}
561 *     <li> {@link #CATEGORY_LAUNCHER}
562 *     <li> {@link #CATEGORY_INFO}
563 *     <li> {@link #CATEGORY_HOME}
564 *     <li> {@link #CATEGORY_PREFERENCE}
565 *     <li> {@link #CATEGORY_TEST}
566 *     <li> {@link #CATEGORY_CAR_DOCK}
567 *     <li> {@link #CATEGORY_DESK_DOCK}
568 *     <li> {@link #CATEGORY_LE_DESK_DOCK}
569 *     <li> {@link #CATEGORY_HE_DESK_DOCK}
570 *     <li> {@link #CATEGORY_CAR_MODE}
571 *     <li> {@link #CATEGORY_APP_MARKET}
572 * </ul>
573 *
574 * <h3>Standard Extra Data</h3>
575 *
576 * <p>These are the current standard fields that can be used as extra data via
577 * {@link #putExtra}.
578 *
579 * <ul>
580 *     <li> {@link #EXTRA_ALARM_COUNT}
581 *     <li> {@link #EXTRA_BCC}
582 *     <li> {@link #EXTRA_CC}
583 *     <li> {@link #EXTRA_CHANGED_COMPONENT_NAME}
584 *     <li> {@link #EXTRA_DATA_REMOVED}
585 *     <li> {@link #EXTRA_DOCK_STATE}
586 *     <li> {@link #EXTRA_DOCK_STATE_HE_DESK}
587 *     <li> {@link #EXTRA_DOCK_STATE_LE_DESK}
588 *     <li> {@link #EXTRA_DOCK_STATE_CAR}
589 *     <li> {@link #EXTRA_DOCK_STATE_DESK}
590 *     <li> {@link #EXTRA_DOCK_STATE_UNDOCKED}
591 *     <li> {@link #EXTRA_DONT_KILL_APP}
592 *     <li> {@link #EXTRA_EMAIL}
593 *     <li> {@link #EXTRA_INITIAL_INTENTS}
594 *     <li> {@link #EXTRA_INTENT}
595 *     <li> {@link #EXTRA_KEY_EVENT}
596 *     <li> {@link #EXTRA_ORIGINATING_URI}
597 *     <li> {@link #EXTRA_PHONE_NUMBER}
598 *     <li> {@link #EXTRA_REFERRER}
599 *     <li> {@link #EXTRA_REMOTE_INTENT_TOKEN}
600 *     <li> {@link #EXTRA_REPLACING}
601 *     <li> {@link #EXTRA_SHORTCUT_ICON}
602 *     <li> {@link #EXTRA_SHORTCUT_ICON_RESOURCE}
603 *     <li> {@link #EXTRA_SHORTCUT_INTENT}
604 *     <li> {@link #EXTRA_STREAM}
605 *     <li> {@link #EXTRA_SHORTCUT_NAME}
606 *     <li> {@link #EXTRA_SUBJECT}
607 *     <li> {@link #EXTRA_TEMPLATE}
608 *     <li> {@link #EXTRA_TEXT}
609 *     <li> {@link #EXTRA_TITLE}
610 *     <li> {@link #EXTRA_UID}
611 * </ul>
612 *
613 * <h3>Flags</h3>
614 *
615 * <p>These are the possible flags that can be used in the Intent via
616 * {@link #setFlags} and {@link #addFlags}.  See {@link #setFlags} for a list
617 * of all possible flags.
618 */
619public class Intent implements Parcelable, Cloneable {
620    private static final String ATTR_ACTION = "action";
621    private static final String TAG_CATEGORIES = "categories";
622    private static final String ATTR_CATEGORY = "category";
623    private static final String TAG_EXTRA = "extra";
624    private static final String ATTR_TYPE = "type";
625    private static final String ATTR_COMPONENT = "component";
626    private static final String ATTR_DATA = "data";
627    private static final String ATTR_FLAGS = "flags";
628
629    // ---------------------------------------------------------------------
630    // ---------------------------------------------------------------------
631    // Standard intent activity actions (see action variable).
632
633    /**
634     *  Activity Action: Start as a main entry point, does not expect to
635     *  receive data.
636     *  <p>Input: nothing
637     *  <p>Output: nothing
638     */
639    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
640    public static final String ACTION_MAIN = "android.intent.action.MAIN";
641
642    /**
643     * Activity Action: Display the data to the user.  This is the most common
644     * action performed on data -- it is the generic action you can use on
645     * a piece of data to get the most reasonable thing to occur.  For example,
646     * when used on a contacts entry it will view the entry; when used on a
647     * mailto: URI it will bring up a compose window filled with the information
648     * supplied by the URI; when used with a tel: URI it will invoke the
649     * dialer.
650     * <p>Input: {@link #getData} is URI from which to retrieve data.
651     * <p>Output: nothing.
652     */
653    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
654    public static final String ACTION_VIEW = "android.intent.action.VIEW";
655
656    /**
657     * A synonym for {@link #ACTION_VIEW}, the "standard" action that is
658     * performed on a piece of data.
659     */
660    public static final String ACTION_DEFAULT = ACTION_VIEW;
661
662    /**
663     * Activity Action: Quick view the data. Launches a quick viewer for
664     * a URI or a list of URIs.
665     * <p>Activities handling this intent action should handle the vast majority of
666     * MIME types rather than only specific ones.
667     * <p>Input: {@link #getData} is a mandatory content URI of the item to
668     * preview. {@link #getClipData} contains an optional list of content URIs
669     * if there is more than one item to preview. {@link #EXTRA_INDEX} is an
670     * optional index of the URI in the clip data to show first.
671     * <p>Output: nothing.
672     */
673    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
674    public static final String ACTION_QUICK_VIEW = "android.intent.action.QUICK_VIEW";
675
676    /**
677     * Used to indicate that some piece of data should be attached to some other
678     * place.  For example, image data could be attached to a contact.  It is up
679     * to the recipient to decide where the data should be attached; the intent
680     * does not specify the ultimate destination.
681     * <p>Input: {@link #getData} is URI of data to be attached.
682     * <p>Output: nothing.
683     */
684    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
685    public static final String ACTION_ATTACH_DATA = "android.intent.action.ATTACH_DATA";
686
687    /**
688     * Activity Action: Provide explicit editable access to the given data.
689     * <p>Input: {@link #getData} is URI of data to be edited.
690     * <p>Output: nothing.
691     */
692    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
693    public static final String ACTION_EDIT = "android.intent.action.EDIT";
694
695    /**
696     * Activity Action: Pick an existing item, or insert a new item, and then edit it.
697     * <p>Input: {@link #getType} is the desired MIME type of the item to create or edit.
698     * The extras can contain type specific data to pass through to the editing/creating
699     * activity.
700     * <p>Output: The URI of the item that was picked.  This must be a content:
701     * URI so that any receiver can access it.
702     */
703    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
704    public static final String ACTION_INSERT_OR_EDIT = "android.intent.action.INSERT_OR_EDIT";
705
706    /**
707     * Activity Action: Pick an item from the data, returning what was selected.
708     * <p>Input: {@link #getData} is URI containing a directory of data
709     * (vnd.android.cursor.dir/*) from which to pick an item.
710     * <p>Output: The URI of the item that was picked.
711     */
712    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
713    public static final String ACTION_PICK = "android.intent.action.PICK";
714
715    /**
716     * Activity Action: Creates a shortcut.
717     * <p>Input: Nothing.</p>
718     * <p>Output: An Intent representing the shortcut. The intent must contain three
719     * extras: SHORTCUT_INTENT (value: Intent), SHORTCUT_NAME (value: String),
720     * and SHORTCUT_ICON (value: Bitmap) or SHORTCUT_ICON_RESOURCE
721     * (value: ShortcutIconResource).</p>
722     *
723     * @see #EXTRA_SHORTCUT_INTENT
724     * @see #EXTRA_SHORTCUT_NAME
725     * @see #EXTRA_SHORTCUT_ICON
726     * @see #EXTRA_SHORTCUT_ICON_RESOURCE
727     * @see android.content.Intent.ShortcutIconResource
728     */
729    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
730    public static final String ACTION_CREATE_SHORTCUT = "android.intent.action.CREATE_SHORTCUT";
731
732    /**
733     * The name of the extra used to define the Intent of a shortcut.
734     *
735     * @see #ACTION_CREATE_SHORTCUT
736     */
737    public static final String EXTRA_SHORTCUT_INTENT = "android.intent.extra.shortcut.INTENT";
738    /**
739     * The name of the extra used to define the name of a shortcut.
740     *
741     * @see #ACTION_CREATE_SHORTCUT
742     */
743    public static final String EXTRA_SHORTCUT_NAME = "android.intent.extra.shortcut.NAME";
744    /**
745     * The name of the extra used to define the icon, as a Bitmap, of a shortcut.
746     *
747     * @see #ACTION_CREATE_SHORTCUT
748     */
749    public static final String EXTRA_SHORTCUT_ICON = "android.intent.extra.shortcut.ICON";
750    /**
751     * The name of the extra used to define the icon, as a ShortcutIconResource, of a shortcut.
752     *
753     * @see #ACTION_CREATE_SHORTCUT
754     * @see android.content.Intent.ShortcutIconResource
755     */
756    public static final String EXTRA_SHORTCUT_ICON_RESOURCE =
757            "android.intent.extra.shortcut.ICON_RESOURCE";
758
759    /**
760     * An activity that provides a user interface for adjusting application preferences.
761     * Optional but recommended settings for all applications which have settings.
762     */
763    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
764    public static final String ACTION_APPLICATION_PREFERENCES
765            = "android.intent.action.APPLICATION_PREFERENCES";
766
767    /**
768     * Activity Action: Launch an activity showing the app information.
769     * For applications which install other applications (such as app stores), it is recommended
770     * to handle this action for providing the app information to the user.
771     *
772     * <p>Input: {@link #EXTRA_PACKAGE_NAME} specifies the package whose information needs
773     * to be displayed.
774     * <p>Output: Nothing.
775     */
776    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
777    public static final String ACTION_SHOW_APP_INFO
778            = "android.intent.action.SHOW_APP_INFO";
779
780    /**
781     * Represents a shortcut/live folder icon resource.
782     *
783     * @see Intent#ACTION_CREATE_SHORTCUT
784     * @see Intent#EXTRA_SHORTCUT_ICON_RESOURCE
785     * @see android.provider.LiveFolders#ACTION_CREATE_LIVE_FOLDER
786     * @see android.provider.LiveFolders#EXTRA_LIVE_FOLDER_ICON
787     */
788    public static class ShortcutIconResource implements Parcelable {
789        /**
790         * The package name of the application containing the icon.
791         */
792        public String packageName;
793
794        /**
795         * The resource name of the icon, including package, name and type.
796         */
797        public String resourceName;
798
799        /**
800         * Creates a new ShortcutIconResource for the specified context and resource
801         * identifier.
802         *
803         * @param context The context of the application.
804         * @param resourceId The resource identifier for the icon.
805         * @return A new ShortcutIconResource with the specified's context package name
806         *         and icon resource identifier.``
807         */
808        public static ShortcutIconResource fromContext(Context context, @AnyRes int resourceId) {
809            ShortcutIconResource icon = new ShortcutIconResource();
810            icon.packageName = context.getPackageName();
811            icon.resourceName = context.getResources().getResourceName(resourceId);
812            return icon;
813        }
814
815        /**
816         * Used to read a ShortcutIconResource from a Parcel.
817         */
818        public static final Parcelable.Creator<ShortcutIconResource> CREATOR =
819            new Parcelable.Creator<ShortcutIconResource>() {
820
821                public ShortcutIconResource createFromParcel(Parcel source) {
822                    ShortcutIconResource icon = new ShortcutIconResource();
823                    icon.packageName = source.readString();
824                    icon.resourceName = source.readString();
825                    return icon;
826                }
827
828                public ShortcutIconResource[] newArray(int size) {
829                    return new ShortcutIconResource[size];
830                }
831            };
832
833        /**
834         * No special parcel contents.
835         */
836        public int describeContents() {
837            return 0;
838        }
839
840        public void writeToParcel(Parcel dest, int flags) {
841            dest.writeString(packageName);
842            dest.writeString(resourceName);
843        }
844
845        @Override
846        public String toString() {
847            return resourceName;
848        }
849    }
850
851    /**
852     * Activity Action: Display an activity chooser, allowing the user to pick
853     * what they want to before proceeding.  This can be used as an alternative
854     * to the standard activity picker that is displayed by the system when
855     * you try to start an activity with multiple possible matches, with these
856     * differences in behavior:
857     * <ul>
858     * <li>You can specify the title that will appear in the activity chooser.
859     * <li>The user does not have the option to make one of the matching
860     * activities a preferred activity, and all possible activities will
861     * always be shown even if one of them is currently marked as the
862     * preferred activity.
863     * </ul>
864     * <p>
865     * This action should be used when the user will naturally expect to
866     * select an activity in order to proceed.  An example if when not to use
867     * it is when the user clicks on a "mailto:" link.  They would naturally
868     * expect to go directly to their mail app, so startActivity() should be
869     * called directly: it will
870     * either launch the current preferred app, or put up a dialog allowing the
871     * user to pick an app to use and optionally marking that as preferred.
872     * <p>
873     * In contrast, if the user is selecting a menu item to send a picture
874     * they are viewing to someone else, there are many different things they
875     * may want to do at this point: send it through e-mail, upload it to a
876     * web service, etc.  In this case the CHOOSER action should be used, to
877     * always present to the user a list of the things they can do, with a
878     * nice title given by the caller such as "Send this photo with:".
879     * <p>
880     * If you need to grant URI permissions through a chooser, you must specify
881     * the permissions to be granted on the ACTION_CHOOSER Intent
882     * <em>in addition</em> to the EXTRA_INTENT inside.  This means using
883     * {@link #setClipData} to specify the URIs to be granted as well as
884     * {@link #FLAG_GRANT_READ_URI_PERMISSION} and/or
885     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION} as appropriate.
886     * <p>
887     * As a convenience, an Intent of this form can be created with the
888     * {@link #createChooser} function.
889     * <p>
890     * Input: No data should be specified.  get*Extra must have
891     * a {@link #EXTRA_INTENT} field containing the Intent being executed,
892     * and can optionally have a {@link #EXTRA_TITLE} field containing the
893     * title text to display in the chooser.
894     * <p>
895     * Output: Depends on the protocol of {@link #EXTRA_INTENT}.
896     */
897    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
898    public static final String ACTION_CHOOSER = "android.intent.action.CHOOSER";
899
900    /**
901     * Convenience function for creating a {@link #ACTION_CHOOSER} Intent.
902     *
903     * <p>Builds a new {@link #ACTION_CHOOSER} Intent that wraps the given
904     * target intent, also optionally supplying a title.  If the target
905     * intent has specified {@link #FLAG_GRANT_READ_URI_PERMISSION} or
906     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, then these flags will also be
907     * set in the returned chooser intent, with its ClipData set appropriately:
908     * either a direct reflection of {@link #getClipData()} if that is non-null,
909     * or a new ClipData built from {@link #getData()}.
910     *
911     * @param target The Intent that the user will be selecting an activity
912     * to perform.
913     * @param title Optional title that will be displayed in the chooser.
914     * @return Return a new Intent object that you can hand to
915     * {@link Context#startActivity(Intent) Context.startActivity()} and
916     * related methods.
917     */
918    public static Intent createChooser(Intent target, CharSequence title) {
919        return createChooser(target, title, null);
920    }
921
922    /**
923     * Convenience function for creating a {@link #ACTION_CHOOSER} Intent.
924     *
925     * <p>Builds a new {@link #ACTION_CHOOSER} Intent that wraps the given
926     * target intent, also optionally supplying a title.  If the target
927     * intent has specified {@link #FLAG_GRANT_READ_URI_PERMISSION} or
928     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, then these flags will also be
929     * set in the returned chooser intent, with its ClipData set appropriately:
930     * either a direct reflection of {@link #getClipData()} if that is non-null,
931     * or a new ClipData built from {@link #getData()}.</p>
932     *
933     * <p>The caller may optionally supply an {@link IntentSender} to receive a callback
934     * when the user makes a choice. This can be useful if the calling application wants
935     * to remember the last chosen target and surface it as a more prominent or one-touch
936     * affordance elsewhere in the UI for next time.</p>
937     *
938     * @param target The Intent that the user will be selecting an activity
939     * to perform.
940     * @param title Optional title that will be displayed in the chooser.
941     * @param sender Optional IntentSender to be called when a choice is made.
942     * @return Return a new Intent object that you can hand to
943     * {@link Context#startActivity(Intent) Context.startActivity()} and
944     * related methods.
945     */
946    public static Intent createChooser(Intent target, CharSequence title, IntentSender sender) {
947        Intent intent = new Intent(ACTION_CHOOSER);
948        intent.putExtra(EXTRA_INTENT, target);
949        if (title != null) {
950            intent.putExtra(EXTRA_TITLE, title);
951        }
952
953        if (sender != null) {
954            intent.putExtra(EXTRA_CHOSEN_COMPONENT_INTENT_SENDER, sender);
955        }
956
957        // Migrate any clip data and flags from target.
958        int permFlags = target.getFlags() & (FLAG_GRANT_READ_URI_PERMISSION
959                | FLAG_GRANT_WRITE_URI_PERMISSION | FLAG_GRANT_PERSISTABLE_URI_PERMISSION
960                | FLAG_GRANT_PREFIX_URI_PERMISSION);
961        if (permFlags != 0) {
962            ClipData targetClipData = target.getClipData();
963            if (targetClipData == null && target.getData() != null) {
964                ClipData.Item item = new ClipData.Item(target.getData());
965                String[] mimeTypes;
966                if (target.getType() != null) {
967                    mimeTypes = new String[] { target.getType() };
968                } else {
969                    mimeTypes = new String[] { };
970                }
971                targetClipData = new ClipData(null, mimeTypes, item);
972            }
973            if (targetClipData != null) {
974                intent.setClipData(targetClipData);
975                intent.addFlags(permFlags);
976            }
977        }
978
979        return intent;
980    }
981
982    /**
983     * Activity Action: Allow the user to select a particular kind of data and
984     * return it.  This is different than {@link #ACTION_PICK} in that here we
985     * just say what kind of data is desired, not a URI of existing data from
986     * which the user can pick.  An ACTION_GET_CONTENT could allow the user to
987     * create the data as it runs (for example taking a picture or recording a
988     * sound), let them browse over the web and download the desired data,
989     * etc.
990     * <p>
991     * There are two main ways to use this action: if you want a specific kind
992     * of data, such as a person contact, you set the MIME type to the kind of
993     * data you want and launch it with {@link Context#startActivity(Intent)}.
994     * The system will then launch the best application to select that kind
995     * of data for you.
996     * <p>
997     * You may also be interested in any of a set of types of content the user
998     * can pick.  For example, an e-mail application that wants to allow the
999     * user to add an attachment to an e-mail message can use this action to
1000     * bring up a list of all of the types of content the user can attach.
1001     * <p>
1002     * In this case, you should wrap the GET_CONTENT intent with a chooser
1003     * (through {@link #createChooser}), which will give the proper interface
1004     * for the user to pick how to send your data and allow you to specify
1005     * a prompt indicating what they are doing.  You will usually specify a
1006     * broad MIME type (such as image/* or {@literal *}/*), resulting in a
1007     * broad range of content types the user can select from.
1008     * <p>
1009     * When using such a broad GET_CONTENT action, it is often desirable to
1010     * only pick from data that can be represented as a stream.  This is
1011     * accomplished by requiring the {@link #CATEGORY_OPENABLE} in the Intent.
1012     * <p>
1013     * Callers can optionally specify {@link #EXTRA_LOCAL_ONLY} to request that
1014     * the launched content chooser only returns results representing data that
1015     * is locally available on the device.  For example, if this extra is set
1016     * to true then an image picker should not show any pictures that are available
1017     * from a remote server but not already on the local device (thus requiring
1018     * they be downloaded when opened).
1019     * <p>
1020     * If the caller can handle multiple returned items (the user performing
1021     * multiple selection), then it can specify {@link #EXTRA_ALLOW_MULTIPLE}
1022     * to indicate this.
1023     * <p>
1024     * Input: {@link #getType} is the desired MIME type to retrieve.  Note
1025     * that no URI is supplied in the intent, as there are no constraints on
1026     * where the returned data originally comes from.  You may also include the
1027     * {@link #CATEGORY_OPENABLE} if you can only accept data that can be
1028     * opened as a stream.  You may use {@link #EXTRA_LOCAL_ONLY} to limit content
1029     * selection to local data.  You may use {@link #EXTRA_ALLOW_MULTIPLE} to
1030     * allow the user to select multiple items.
1031     * <p>
1032     * Output: The URI of the item that was picked.  This must be a content:
1033     * URI so that any receiver can access it.
1034     */
1035    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1036    public static final String ACTION_GET_CONTENT = "android.intent.action.GET_CONTENT";
1037    /**
1038     * Activity Action: Dial a number as specified by the data.  This shows a
1039     * UI with the number being dialed, allowing the user to explicitly
1040     * initiate the call.
1041     * <p>Input: If nothing, an empty dialer is started; else {@link #getData}
1042     * is URI of a phone number to be dialed or a tel: URI of an explicit phone
1043     * number.
1044     * <p>Output: nothing.
1045     */
1046    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1047    public static final String ACTION_DIAL = "android.intent.action.DIAL";
1048    /**
1049     * Activity Action: Perform a call to someone specified by the data.
1050     * <p>Input: If nothing, an empty dialer is started; else {@link #getData}
1051     * is URI of a phone number to be dialed or a tel: URI of an explicit phone
1052     * number.
1053     * <p>Output: nothing.
1054     *
1055     * <p>Note: there will be restrictions on which applications can initiate a
1056     * call; most applications should use the {@link #ACTION_DIAL}.
1057     * <p>Note: this Intent <strong>cannot</strong> be used to call emergency
1058     * numbers.  Applications can <strong>dial</strong> emergency numbers using
1059     * {@link #ACTION_DIAL}, however.
1060     *
1061     * <p>Note: if you app targets {@link android.os.Build.VERSION_CODES#M M}
1062     * and above and declares as using the {@link android.Manifest.permission#CALL_PHONE}
1063     * permission which is not granted, then attempting to use this action will
1064     * result in a {@link java.lang.SecurityException}.
1065     */
1066    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1067    public static final String ACTION_CALL = "android.intent.action.CALL";
1068    /**
1069     * Activity Action: Perform a call to an emergency number specified by the
1070     * data.
1071     * <p>Input: {@link #getData} is URI of a phone number to be dialed or a
1072     * tel: URI of an explicit phone number.
1073     * <p>Output: nothing.
1074     * @hide
1075     */
1076    public static final String ACTION_CALL_EMERGENCY = "android.intent.action.CALL_EMERGENCY";
1077    /**
1078     * Activity action: Perform a call to any number (emergency or not)
1079     * specified by the data.
1080     * <p>Input: {@link #getData} is URI of a phone number to be dialed or a
1081     * tel: URI of an explicit phone number.
1082     * <p>Output: nothing.
1083     * @hide
1084     */
1085    public static final String ACTION_CALL_PRIVILEGED = "android.intent.action.CALL_PRIVILEGED";
1086    /**
1087     * Activity action: Activate the current SIM card.  If SIM cards do not require activation,
1088     * sending this intent is a no-op.
1089     * <p>Input: No data should be specified.  get*Extra may have an optional
1090     * {@link #EXTRA_SIM_ACTIVATION_RESPONSE} field containing a PendingIntent through which to
1091     * send the activation result.
1092     * <p>Output: nothing.
1093     * @hide
1094     */
1095    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1096    public static final String ACTION_SIM_ACTIVATION_REQUEST =
1097            "android.intent.action.SIM_ACTIVATION_REQUEST";
1098    /**
1099     * Activity Action: Send a message to someone specified by the data.
1100     * <p>Input: {@link #getData} is URI describing the target.
1101     * <p>Output: nothing.
1102     */
1103    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1104    public static final String ACTION_SENDTO = "android.intent.action.SENDTO";
1105    /**
1106     * Activity Action: Deliver some data to someone else.  Who the data is
1107     * being delivered to is not specified; it is up to the receiver of this
1108     * action to ask the user where the data should be sent.
1109     * <p>
1110     * When launching a SEND intent, you should usually wrap it in a chooser
1111     * (through {@link #createChooser}), which will give the proper interface
1112     * for the user to pick how to send your data and allow you to specify
1113     * a prompt indicating what they are doing.
1114     * <p>
1115     * Input: {@link #getType} is the MIME type of the data being sent.
1116     * get*Extra can have either a {@link #EXTRA_TEXT}
1117     * or {@link #EXTRA_STREAM} field, containing the data to be sent.  If
1118     * using EXTRA_TEXT, the MIME type should be "text/plain"; otherwise it
1119     * should be the MIME type of the data in EXTRA_STREAM.  Use {@literal *}/*
1120     * if the MIME type is unknown (this will only allow senders that can
1121     * handle generic data streams).  If using {@link #EXTRA_TEXT}, you can
1122     * also optionally supply {@link #EXTRA_HTML_TEXT} for clients to retrieve
1123     * your text with HTML formatting.
1124     * <p>
1125     * As of {@link android.os.Build.VERSION_CODES#JELLY_BEAN}, the data
1126     * being sent can be supplied through {@link #setClipData(ClipData)}.  This
1127     * allows you to use {@link #FLAG_GRANT_READ_URI_PERMISSION} when sharing
1128     * content: URIs and other advanced features of {@link ClipData}.  If
1129     * using this approach, you still must supply the same data through the
1130     * {@link #EXTRA_TEXT} or {@link #EXTRA_STREAM} fields described below
1131     * for compatibility with old applications.  If you don't set a ClipData,
1132     * it will be copied there for you when calling {@link Context#startActivity(Intent)}.
1133     * <p>
1134     * Optional standard extras, which may be interpreted by some recipients as
1135     * appropriate, are: {@link #EXTRA_EMAIL}, {@link #EXTRA_CC},
1136     * {@link #EXTRA_BCC}, {@link #EXTRA_SUBJECT}.
1137     * <p>
1138     * Output: nothing.
1139     */
1140    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1141    public static final String ACTION_SEND = "android.intent.action.SEND";
1142    /**
1143     * Activity Action: Deliver multiple data to someone else.
1144     * <p>
1145     * Like {@link #ACTION_SEND}, except the data is multiple.
1146     * <p>
1147     * Input: {@link #getType} is the MIME type of the data being sent.
1148     * get*ArrayListExtra can have either a {@link #EXTRA_TEXT} or {@link
1149     * #EXTRA_STREAM} field, containing the data to be sent.  If using
1150     * {@link #EXTRA_TEXT}, you can also optionally supply {@link #EXTRA_HTML_TEXT}
1151     * for clients to retrieve your text with HTML formatting.
1152     * <p>
1153     * Multiple types are supported, and receivers should handle mixed types
1154     * whenever possible. The right way for the receiver to check them is to
1155     * use the content resolver on each URI. The intent sender should try to
1156     * put the most concrete mime type in the intent type, but it can fall
1157     * back to {@literal <type>/*} or {@literal *}/* as needed.
1158     * <p>
1159     * e.g. if you are sending image/jpg and image/jpg, the intent's type can
1160     * be image/jpg, but if you are sending image/jpg and image/png, then the
1161     * intent's type should be image/*.
1162     * <p>
1163     * As of {@link android.os.Build.VERSION_CODES#JELLY_BEAN}, the data
1164     * being sent can be supplied through {@link #setClipData(ClipData)}.  This
1165     * allows you to use {@link #FLAG_GRANT_READ_URI_PERMISSION} when sharing
1166     * content: URIs and other advanced features of {@link ClipData}.  If
1167     * using this approach, you still must supply the same data through the
1168     * {@link #EXTRA_TEXT} or {@link #EXTRA_STREAM} fields described below
1169     * for compatibility with old applications.  If you don't set a ClipData,
1170     * it will be copied there for you when calling {@link Context#startActivity(Intent)}.
1171     * <p>
1172     * Optional standard extras, which may be interpreted by some recipients as
1173     * appropriate, are: {@link #EXTRA_EMAIL}, {@link #EXTRA_CC},
1174     * {@link #EXTRA_BCC}, {@link #EXTRA_SUBJECT}.
1175     * <p>
1176     * Output: nothing.
1177     */
1178    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1179    public static final String ACTION_SEND_MULTIPLE = "android.intent.action.SEND_MULTIPLE";
1180    /**
1181     * Activity Action: Handle an incoming phone call.
1182     * <p>Input: nothing.
1183     * <p>Output: nothing.
1184     */
1185    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1186    public static final String ACTION_ANSWER = "android.intent.action.ANSWER";
1187    /**
1188     * Activity Action: Insert an empty item into the given container.
1189     * <p>Input: {@link #getData} is URI of the directory (vnd.android.cursor.dir/*)
1190     * in which to place the data.
1191     * <p>Output: URI of the new data that was created.
1192     */
1193    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1194    public static final String ACTION_INSERT = "android.intent.action.INSERT";
1195    /**
1196     * Activity Action: Create a new item in the given container, initializing it
1197     * from the current contents of the clipboard.
1198     * <p>Input: {@link #getData} is URI of the directory (vnd.android.cursor.dir/*)
1199     * in which to place the data.
1200     * <p>Output: URI of the new data that was created.
1201     */
1202    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1203    public static final String ACTION_PASTE = "android.intent.action.PASTE";
1204    /**
1205     * Activity Action: Delete the given data from its container.
1206     * <p>Input: {@link #getData} is URI of data to be deleted.
1207     * <p>Output: nothing.
1208     */
1209    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1210    public static final String ACTION_DELETE = "android.intent.action.DELETE";
1211    /**
1212     * Activity Action: Run the data, whatever that means.
1213     * <p>Input: ?  (Note: this is currently specific to the test harness.)
1214     * <p>Output: nothing.
1215     */
1216    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1217    public static final String ACTION_RUN = "android.intent.action.RUN";
1218    /**
1219     * Activity Action: Perform a data synchronization.
1220     * <p>Input: ?
1221     * <p>Output: ?
1222     */
1223    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1224    public static final String ACTION_SYNC = "android.intent.action.SYNC";
1225    /**
1226     * Activity Action: Pick an activity given an intent, returning the class
1227     * selected.
1228     * <p>Input: get*Extra field {@link #EXTRA_INTENT} is an Intent
1229     * used with {@link PackageManager#queryIntentActivities} to determine the
1230     * set of activities from which to pick.
1231     * <p>Output: Class name of the activity that was selected.
1232     */
1233    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1234    public static final String ACTION_PICK_ACTIVITY = "android.intent.action.PICK_ACTIVITY";
1235    /**
1236     * Activity Action: Perform a search.
1237     * <p>Input: {@link android.app.SearchManager#QUERY getStringExtra(SearchManager.QUERY)}
1238     * is the text to search for.  If empty, simply
1239     * enter your search results Activity with the search UI activated.
1240     * <p>Output: nothing.
1241     */
1242    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1243    public static final String ACTION_SEARCH = "android.intent.action.SEARCH";
1244    /**
1245     * Activity Action: Start the platform-defined tutorial
1246     * <p>Input: {@link android.app.SearchManager#QUERY getStringExtra(SearchManager.QUERY)}
1247     * is the text to search for.  If empty, simply
1248     * enter your search results Activity with the search UI activated.
1249     * <p>Output: nothing.
1250     */
1251    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1252    public static final String ACTION_SYSTEM_TUTORIAL = "android.intent.action.SYSTEM_TUTORIAL";
1253    /**
1254     * Activity Action: Perform a web search.
1255     * <p>
1256     * Input: {@link android.app.SearchManager#QUERY
1257     * getStringExtra(SearchManager.QUERY)} is the text to search for. If it is
1258     * a url starts with http or https, the site will be opened. If it is plain
1259     * text, Google search will be applied.
1260     * <p>
1261     * Output: nothing.
1262     */
1263    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1264    public static final String ACTION_WEB_SEARCH = "android.intent.action.WEB_SEARCH";
1265
1266    /**
1267     * Activity Action: Perform assist action.
1268     * <p>
1269     * Input: {@link #EXTRA_ASSIST_PACKAGE}, {@link #EXTRA_ASSIST_CONTEXT}, can provide
1270     * additional optional contextual information about where the user was when they
1271     * requested the assist; {@link #EXTRA_REFERRER} may be set with additional referrer
1272     * information.
1273     * Output: nothing.
1274     */
1275    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1276    public static final String ACTION_ASSIST = "android.intent.action.ASSIST";
1277
1278    /**
1279     * Activity Action: Perform voice assist action.
1280     * <p>
1281     * Input: {@link #EXTRA_ASSIST_PACKAGE}, {@link #EXTRA_ASSIST_CONTEXT}, can provide
1282     * additional optional contextual information about where the user was when they
1283     * requested the voice assist.
1284     * Output: nothing.
1285     * @hide
1286     */
1287    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1288    public static final String ACTION_VOICE_ASSIST = "android.intent.action.VOICE_ASSIST";
1289
1290    /**
1291     * An optional field on {@link #ACTION_ASSIST} containing the name of the current foreground
1292     * application package at the time the assist was invoked.
1293     */
1294    public static final String EXTRA_ASSIST_PACKAGE
1295            = "android.intent.extra.ASSIST_PACKAGE";
1296
1297    /**
1298     * An optional field on {@link #ACTION_ASSIST} containing the uid of the current foreground
1299     * application package at the time the assist was invoked.
1300     */
1301    public static final String EXTRA_ASSIST_UID
1302            = "android.intent.extra.ASSIST_UID";
1303
1304    /**
1305     * An optional field on {@link #ACTION_ASSIST} and containing additional contextual
1306     * information supplied by the current foreground app at the time of the assist request.
1307     * This is a {@link Bundle} of additional data.
1308     */
1309    public static final String EXTRA_ASSIST_CONTEXT
1310            = "android.intent.extra.ASSIST_CONTEXT";
1311
1312    /**
1313     * An optional field on {@link #ACTION_ASSIST} suggesting that the user will likely use a
1314     * keyboard as the primary input device for assistance.
1315     */
1316    public static final String EXTRA_ASSIST_INPUT_HINT_KEYBOARD =
1317            "android.intent.extra.ASSIST_INPUT_HINT_KEYBOARD";
1318
1319    /**
1320     * An optional field on {@link #ACTION_ASSIST} containing the InputDevice id
1321     * that was used to invoke the assist.
1322     */
1323    public static final String EXTRA_ASSIST_INPUT_DEVICE_ID =
1324            "android.intent.extra.ASSIST_INPUT_DEVICE_ID";
1325
1326    /**
1327     * Activity Action: List all available applications.
1328     * <p>Input: Nothing.
1329     * <p>Output: nothing.
1330     */
1331    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1332    public static final String ACTION_ALL_APPS = "android.intent.action.ALL_APPS";
1333    /**
1334     * Activity Action: Show settings for choosing wallpaper.
1335     * <p>Input: Nothing.
1336     * <p>Output: Nothing.
1337     */
1338    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1339    public static final String ACTION_SET_WALLPAPER = "android.intent.action.SET_WALLPAPER";
1340
1341    /**
1342     * Activity Action: Show activity for reporting a bug.
1343     * <p>Input: Nothing.
1344     * <p>Output: Nothing.
1345     */
1346    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1347    public static final String ACTION_BUG_REPORT = "android.intent.action.BUG_REPORT";
1348
1349    /**
1350     *  Activity Action: Main entry point for factory tests.  Only used when
1351     *  the device is booting in factory test node.  The implementing package
1352     *  must be installed in the system image.
1353     *  <p>Input: nothing
1354     *  <p>Output: nothing
1355     */
1356    public static final String ACTION_FACTORY_TEST = "android.intent.action.FACTORY_TEST";
1357
1358    /**
1359     * Activity Action: The user pressed the "call" button to go to the dialer
1360     * or other appropriate UI for placing a call.
1361     * <p>Input: Nothing.
1362     * <p>Output: Nothing.
1363     */
1364    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1365    public static final String ACTION_CALL_BUTTON = "android.intent.action.CALL_BUTTON";
1366
1367    /**
1368     * Activity Action: Start Voice Command.
1369     * <p>Input: Nothing.
1370     * <p>Output: Nothing.
1371     */
1372    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1373    public static final String ACTION_VOICE_COMMAND = "android.intent.action.VOICE_COMMAND";
1374
1375    /**
1376     * Activity Action: Start action associated with long pressing on the
1377     * search key.
1378     * <p>Input: Nothing.
1379     * <p>Output: Nothing.
1380     */
1381    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1382    public static final String ACTION_SEARCH_LONG_PRESS = "android.intent.action.SEARCH_LONG_PRESS";
1383
1384    /**
1385     * Activity Action: The user pressed the "Report" button in the crash/ANR dialog.
1386     * This intent is delivered to the package which installed the application, usually
1387     * Google Play.
1388     * <p>Input: No data is specified. The bug report is passed in using
1389     * an {@link #EXTRA_BUG_REPORT} field.
1390     * <p>Output: Nothing.
1391     *
1392     * @see #EXTRA_BUG_REPORT
1393     */
1394    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1395    public static final String ACTION_APP_ERROR = "android.intent.action.APP_ERROR";
1396
1397    /**
1398     * Activity Action: Show power usage information to the user.
1399     * <p>Input: Nothing.
1400     * <p>Output: Nothing.
1401     */
1402    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1403    public static final String ACTION_POWER_USAGE_SUMMARY = "android.intent.action.POWER_USAGE_SUMMARY";
1404
1405    /**
1406     * Activity Action: Setup wizard to launch after a platform update.  This
1407     * activity should have a string meta-data field associated with it,
1408     * {@link #METADATA_SETUP_VERSION}, which defines the current version of
1409     * the platform for setup.  The activity will be launched only if
1410     * {@link android.provider.Settings.Secure#LAST_SETUP_SHOWN} is not the
1411     * same value.
1412     * <p>Input: Nothing.
1413     * <p>Output: Nothing.
1414     * @hide
1415     */
1416    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1417    public static final String ACTION_UPGRADE_SETUP = "android.intent.action.UPGRADE_SETUP";
1418
1419    /**
1420     * Activity Action: Start the Keyboard Shortcuts Helper screen.
1421     * <p>Input: Nothing.
1422     * <p>Output: Nothing.
1423     * @hide
1424     */
1425    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1426    public static final String ACTION_SHOW_KEYBOARD_SHORTCUTS =
1427            "android.intent.action.SHOW_KEYBOARD_SHORTCUTS";
1428
1429    /**
1430     * Activity Action: Dismiss the Keyboard Shortcuts Helper screen.
1431     * <p>Input: Nothing.
1432     * <p>Output: Nothing.
1433     * @hide
1434     */
1435    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1436    public static final String ACTION_DISMISS_KEYBOARD_SHORTCUTS =
1437            "android.intent.action.DISMISS_KEYBOARD_SHORTCUTS";
1438
1439    /**
1440     * Activity Action: Show settings for managing network data usage of a
1441     * specific application. Applications should define an activity that offers
1442     * options to control data usage.
1443     */
1444    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1445    public static final String ACTION_MANAGE_NETWORK_USAGE =
1446            "android.intent.action.MANAGE_NETWORK_USAGE";
1447
1448    /**
1449     * Activity Action: Launch application installer.
1450     * <p>
1451     * Input: The data must be a content: or file: URI at which the application
1452     * can be retrieved.  As of {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1},
1453     * you can also use "package:<package-name>" to install an application for the
1454     * current user that is already installed for another user. You can optionally supply
1455     * {@link #EXTRA_INSTALLER_PACKAGE_NAME}, {@link #EXTRA_NOT_UNKNOWN_SOURCE},
1456     * {@link #EXTRA_ALLOW_REPLACE}, and {@link #EXTRA_RETURN_RESULT}.
1457     * <p>
1458     * Output: If {@link #EXTRA_RETURN_RESULT}, returns whether the install
1459     * succeeded.
1460     * <p>
1461     * <strong>Note:</strong>If your app is targeting API level higher than 22 you
1462     * need to hold {@link android.Manifest.permission#REQUEST_INSTALL_PACKAGES}
1463     * in order to launch the application installer.
1464     * </p>
1465     *
1466     * @see #EXTRA_INSTALLER_PACKAGE_NAME
1467     * @see #EXTRA_NOT_UNKNOWN_SOURCE
1468     * @see #EXTRA_RETURN_RESULT
1469     */
1470    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1471    public static final String ACTION_INSTALL_PACKAGE = "android.intent.action.INSTALL_PACKAGE";
1472
1473    /**
1474     * Activity Action: Launch ephemeral installer.
1475     * <p>
1476     * Input: The data must be a http: URI that the ephemeral application is registered
1477     * to handle.
1478     * <p class="note">
1479     * This is a protected intent that can only be sent by the system.
1480     * </p>
1481     *
1482     * @hide
1483     */
1484    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1485    public static final String ACTION_INSTALL_EPHEMERAL_PACKAGE
1486            = "android.intent.action.INSTALL_EPHEMERAL_PACKAGE";
1487
1488    /**
1489     * Service Action: Resolve ephemeral application.
1490     * <p>
1491     * The system will have a persistent connection to this service.
1492     * This is a protected intent that can only be sent by the system.
1493     * </p>
1494     *
1495     * @hide
1496     */
1497    @SdkConstant(SdkConstantType.SERVICE_ACTION)
1498    public static final String ACTION_RESOLVE_EPHEMERAL_PACKAGE
1499            = "android.intent.action.RESOLVE_EPHEMERAL_PACKAGE";
1500
1501    /**
1502     * Used as a string extra field with {@link #ACTION_INSTALL_PACKAGE} to install a
1503     * package.  Specifies the installer package name; this package will receive the
1504     * {@link #ACTION_APP_ERROR} intent.
1505     */
1506    public static final String EXTRA_INSTALLER_PACKAGE_NAME
1507            = "android.intent.extra.INSTALLER_PACKAGE_NAME";
1508
1509    /**
1510     * Used as a boolean extra field with {@link #ACTION_INSTALL_PACKAGE} to install a
1511     * package.  Specifies that the application being installed should not be
1512     * treated as coming from an unknown source, but as coming from the app
1513     * invoking the Intent.  For this to work you must start the installer with
1514     * startActivityForResult().
1515     */
1516    public static final String EXTRA_NOT_UNKNOWN_SOURCE
1517            = "android.intent.extra.NOT_UNKNOWN_SOURCE";
1518
1519    /**
1520     * Used as a URI extra field with {@link #ACTION_INSTALL_PACKAGE} and
1521     * {@link #ACTION_VIEW} to indicate the URI from which the local APK in the Intent
1522     * data field originated from.
1523     */
1524    public static final String EXTRA_ORIGINATING_URI
1525            = "android.intent.extra.ORIGINATING_URI";
1526
1527    /**
1528     * This extra can be used with any Intent used to launch an activity, supplying information
1529     * about who is launching that activity.  This field contains a {@link android.net.Uri}
1530     * object, typically an http: or https: URI of the web site that the referral came from;
1531     * it can also use the {@link #URI_ANDROID_APP_SCHEME android-app:} scheme to identify
1532     * a native application that it came from.
1533     *
1534     * <p>To retrieve this value in a client, use {@link android.app.Activity#getReferrer}
1535     * instead of directly retrieving the extra.  It is also valid for applications to
1536     * instead supply {@link #EXTRA_REFERRER_NAME} for cases where they can only create
1537     * a string, not a Uri; the field here, if supplied, will always take precedence,
1538     * however.</p>
1539     *
1540     * @see #EXTRA_REFERRER_NAME
1541     */
1542    public static final String EXTRA_REFERRER
1543            = "android.intent.extra.REFERRER";
1544
1545    /**
1546     * Alternate version of {@link #EXTRA_REFERRER} that supplies the URI as a String rather
1547     * than a {@link android.net.Uri} object.  Only for use in cases where Uri objects can
1548     * not be created, in particular when Intent extras are supplied through the
1549     * {@link #URI_INTENT_SCHEME intent:} or {@link #URI_ANDROID_APP_SCHEME android-app:}
1550     * schemes.
1551     *
1552     * @see #EXTRA_REFERRER
1553     */
1554    public static final String EXTRA_REFERRER_NAME
1555            = "android.intent.extra.REFERRER_NAME";
1556
1557    /**
1558     * Used as an int extra field with {@link #ACTION_INSTALL_PACKAGE} and
1559     * {@link #ACTION_VIEW} to indicate the uid of the package that initiated the install
1560     * @hide
1561     */
1562    @SystemApi
1563    public static final String EXTRA_ORIGINATING_UID
1564            = "android.intent.extra.ORIGINATING_UID";
1565
1566    /**
1567     * Used as a boolean extra field with {@link #ACTION_INSTALL_PACKAGE} to install a
1568     * package.  Tells the installer UI to skip the confirmation with the user
1569     * if the .apk is replacing an existing one.
1570     * @deprecated As of {@link android.os.Build.VERSION_CODES#JELLY_BEAN}, Android
1571     * will no longer show an interstitial message about updating existing
1572     * applications so this is no longer needed.
1573     */
1574    @Deprecated
1575    public static final String EXTRA_ALLOW_REPLACE
1576            = "android.intent.extra.ALLOW_REPLACE";
1577
1578    /**
1579     * Used as a boolean extra field with {@link #ACTION_INSTALL_PACKAGE} or
1580     * {@link #ACTION_UNINSTALL_PACKAGE}.  Specifies that the installer UI should
1581     * return to the application the result code of the install/uninstall.  The returned result
1582     * code will be {@link android.app.Activity#RESULT_OK} on success or
1583     * {@link android.app.Activity#RESULT_FIRST_USER} on failure.
1584     */
1585    public static final String EXTRA_RETURN_RESULT
1586            = "android.intent.extra.RETURN_RESULT";
1587
1588    /**
1589     * Package manager install result code.  @hide because result codes are not
1590     * yet ready to be exposed.
1591     */
1592    public static final String EXTRA_INSTALL_RESULT
1593            = "android.intent.extra.INSTALL_RESULT";
1594
1595    /**
1596     * Activity Action: Launch application uninstaller.
1597     * <p>
1598     * Input: The data must be a package: URI whose scheme specific part is
1599     * the package name of the current installed package to be uninstalled.
1600     * You can optionally supply {@link #EXTRA_RETURN_RESULT}.
1601     * <p>
1602     * Output: If {@link #EXTRA_RETURN_RESULT}, returns whether the install
1603     * succeeded.
1604     */
1605    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1606    public static final String ACTION_UNINSTALL_PACKAGE = "android.intent.action.UNINSTALL_PACKAGE";
1607
1608    /**
1609     * Specify whether the package should be uninstalled for all users.
1610     * @hide because these should not be part of normal application flow.
1611     */
1612    public static final String EXTRA_UNINSTALL_ALL_USERS
1613            = "android.intent.extra.UNINSTALL_ALL_USERS";
1614
1615    /**
1616     * A string associated with a {@link #ACTION_UPGRADE_SETUP} activity
1617     * describing the last run version of the platform that was setup.
1618     * @hide
1619     */
1620    public static final String METADATA_SETUP_VERSION = "android.SETUP_VERSION";
1621
1622    /**
1623     * Activity action: Launch UI to manage the permissions of an app.
1624     * <p>
1625     * Input: {@link #EXTRA_PACKAGE_NAME} specifies the package whose permissions
1626     * will be managed by the launched UI.
1627     * </p>
1628     * <p>
1629     * Output: Nothing.
1630     * </p>
1631     *
1632     * @see #EXTRA_PACKAGE_NAME
1633     *
1634     * @hide
1635     */
1636    @SystemApi
1637    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1638    public static final String ACTION_MANAGE_APP_PERMISSIONS =
1639            "android.intent.action.MANAGE_APP_PERMISSIONS";
1640
1641    /**
1642     * Activity action: Launch UI to manage permissions.
1643     * <p>
1644     * Input: Nothing.
1645     * </p>
1646     * <p>
1647     * Output: Nothing.
1648     * </p>
1649     *
1650     * @hide
1651     */
1652    @SystemApi
1653    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1654    public static final String ACTION_MANAGE_PERMISSIONS =
1655            "android.intent.action.MANAGE_PERMISSIONS";
1656
1657    /**
1658     * Activity action: Launch UI to review permissions for an app.
1659     * The system uses this intent if permission review for apps not
1660     * supporting the new runtime permissions model is enabled. In
1661     * this mode a permission review is required before any of the
1662     * app components can run.
1663     * <p>
1664     * Input: {@link #EXTRA_PACKAGE_NAME} specifies the package whose
1665     * permissions will be reviewed (mandatory).
1666     * </p>
1667     * <p>
1668     * Input: {@link #EXTRA_INTENT} specifies a pending intent to
1669     * be fired after the permission review (optional).
1670     * </p>
1671     * <p>
1672     * Input: {@link #EXTRA_REMOTE_CALLBACK} specifies a callback to
1673     * be invoked after the permission review (optional).
1674     * </p>
1675     * <p>
1676     * Input: {@link #EXTRA_RESULT_NEEDED} specifies whether the intent
1677     * passed via {@link #EXTRA_INTENT} needs a result (optional).
1678     * </p>
1679     * <p>
1680     * Output: Nothing.
1681     * </p>
1682     *
1683     * @see #EXTRA_PACKAGE_NAME
1684     * @see #EXTRA_INTENT
1685     * @see #EXTRA_REMOTE_CALLBACK
1686     * @see #EXTRA_RESULT_NEEDED
1687     *
1688     * @hide
1689     */
1690    @SystemApi
1691    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1692    public static final String ACTION_REVIEW_PERMISSIONS =
1693            "android.intent.action.REVIEW_PERMISSIONS";
1694
1695    /**
1696     * Intent extra: A callback for reporting remote result as a bundle.
1697     * <p>
1698     * Type: IRemoteCallback
1699     * </p>
1700     *
1701     * @hide
1702     */
1703    @SystemApi
1704    public static final String EXTRA_REMOTE_CALLBACK = "android.intent.extra.REMOTE_CALLBACK";
1705
1706    /**
1707     * Intent extra: An app package name.
1708     * <p>
1709     * Type: String
1710     * </p>
1711     *
1712     */
1713    public static final String EXTRA_PACKAGE_NAME = "android.intent.extra.PACKAGE_NAME";
1714
1715    /**
1716     * Intent extra: An extra for specifying whether a result is needed.
1717     * <p>
1718     * Type: boolean
1719     * </p>
1720     *
1721     * @hide
1722     */
1723    @SystemApi
1724    public static final String EXTRA_RESULT_NEEDED = "android.intent.extra.RESULT_NEEDED";
1725
1726    /**
1727     * Activity action: Launch UI to manage which apps have a given permission.
1728     * <p>
1729     * Input: {@link #EXTRA_PERMISSION_NAME} specifies the permission access
1730     * to which will be managed by the launched UI.
1731     * </p>
1732     * <p>
1733     * Output: Nothing.
1734     * </p>
1735     *
1736     * @see #EXTRA_PERMISSION_NAME
1737     *
1738     * @hide
1739     */
1740    @SystemApi
1741    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1742    public static final String ACTION_MANAGE_PERMISSION_APPS =
1743            "android.intent.action.MANAGE_PERMISSION_APPS";
1744
1745    /**
1746     * Intent extra: The name of a permission.
1747     * <p>
1748     * Type: String
1749     * </p>
1750     *
1751     * @hide
1752     */
1753    @SystemApi
1754    public static final String EXTRA_PERMISSION_NAME = "android.intent.extra.PERMISSION_NAME";
1755
1756    // ---------------------------------------------------------------------
1757    // ---------------------------------------------------------------------
1758    // Standard intent broadcast actions (see action variable).
1759
1760    /**
1761     * Broadcast Action: Sent when the device goes to sleep and becomes non-interactive.
1762     * <p>
1763     * For historical reasons, the name of this broadcast action refers to the power
1764     * state of the screen but it is actually sent in response to changes in the
1765     * overall interactive state of the device.
1766     * </p><p>
1767     * This broadcast is sent when the device becomes non-interactive which may have
1768     * nothing to do with the screen turning off.  To determine the
1769     * actual state of the screen, use {@link android.view.Display#getState}.
1770     * </p><p>
1771     * See {@link android.os.PowerManager#isInteractive} for details.
1772     * </p>
1773     * You <em>cannot</em> receive this through components declared in
1774     * manifests, only by explicitly registering for it with
1775     * {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
1776     * Context.registerReceiver()}.
1777     *
1778     * <p class="note">This is a protected intent that can only be sent
1779     * by the system.
1780     */
1781    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1782    public static final String ACTION_SCREEN_OFF = "android.intent.action.SCREEN_OFF";
1783
1784    /**
1785     * Broadcast Action: Sent when the device wakes up and becomes interactive.
1786     * <p>
1787     * For historical reasons, the name of this broadcast action refers to the power
1788     * state of the screen but it is actually sent in response to changes in the
1789     * overall interactive state of the device.
1790     * </p><p>
1791     * This broadcast is sent when the device becomes interactive which may have
1792     * nothing to do with the screen turning on.  To determine the
1793     * actual state of the screen, use {@link android.view.Display#getState}.
1794     * </p><p>
1795     * See {@link android.os.PowerManager#isInteractive} for details.
1796     * </p>
1797     * You <em>cannot</em> receive this through components declared in
1798     * manifests, only by explicitly registering for it with
1799     * {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
1800     * Context.registerReceiver()}.
1801     *
1802     * <p class="note">This is a protected intent that can only be sent
1803     * by the system.
1804     */
1805    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1806    public static final String ACTION_SCREEN_ON = "android.intent.action.SCREEN_ON";
1807
1808    /**
1809     * Broadcast Action: Sent after the system stops dreaming.
1810     *
1811     * <p class="note">This is a protected intent that can only be sent by the system.
1812     * It is only sent to registered receivers.</p>
1813     */
1814    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1815    public static final String ACTION_DREAMING_STOPPED = "android.intent.action.DREAMING_STOPPED";
1816
1817    /**
1818     * Broadcast Action: Sent after the system starts dreaming.
1819     *
1820     * <p class="note">This is a protected intent that can only be sent by the system.
1821     * It is only sent to registered receivers.</p>
1822     */
1823    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1824    public static final String ACTION_DREAMING_STARTED = "android.intent.action.DREAMING_STARTED";
1825
1826    /**
1827     * Broadcast Action: Sent when the user is present after device wakes up (e.g when the
1828     * keyguard is gone).
1829     *
1830     * <p class="note">This is a protected intent that can only be sent
1831     * by the system.
1832     */
1833    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1834    public static final String ACTION_USER_PRESENT = "android.intent.action.USER_PRESENT";
1835
1836    /**
1837     * Broadcast Action: The current time has changed.  Sent every
1838     * minute.  You <em>cannot</em> receive this through components declared
1839     * in manifests, only by explicitly registering for it with
1840     * {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
1841     * Context.registerReceiver()}.
1842     *
1843     * <p class="note">This is a protected intent that can only be sent
1844     * by the system.
1845     */
1846    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1847    public static final String ACTION_TIME_TICK = "android.intent.action.TIME_TICK";
1848    /**
1849     * Broadcast Action: The time was set.
1850     */
1851    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1852    public static final String ACTION_TIME_CHANGED = "android.intent.action.TIME_SET";
1853    /**
1854     * Broadcast Action: The date has changed.
1855     */
1856    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1857    public static final String ACTION_DATE_CHANGED = "android.intent.action.DATE_CHANGED";
1858    /**
1859     * Broadcast Action: The timezone has changed. The intent will have the following extra values:</p>
1860     * <ul>
1861     *   <li><em>time-zone</em> - The java.util.TimeZone.getID() value identifying the new time zone.</li>
1862     * </ul>
1863     *
1864     * <p class="note">This is a protected intent that can only be sent
1865     * by the system.
1866     */
1867    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1868    public static final String ACTION_TIMEZONE_CHANGED = "android.intent.action.TIMEZONE_CHANGED";
1869    /**
1870     * Clear DNS Cache Action: This is broadcast when networks have changed and old
1871     * DNS entries should be tossed.
1872     * @hide
1873     */
1874    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1875    public static final String ACTION_CLEAR_DNS_CACHE = "android.intent.action.CLEAR_DNS_CACHE";
1876    /**
1877     * Alarm Changed Action: This is broadcast when the AlarmClock
1878     * application's alarm is set or unset.  It is used by the
1879     * AlarmClock application and the StatusBar service.
1880     * @hide
1881     */
1882    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1883    public static final String ACTION_ALARM_CHANGED = "android.intent.action.ALARM_CHANGED";
1884
1885    /**
1886     * Broadcast Action: This is broadcast once, after the user has finished
1887     * booting, but while still in the "locked" state. It can be used to perform
1888     * application-specific initialization, such as installing alarms. You must
1889     * hold the {@link android.Manifest.permission#RECEIVE_BOOT_COMPLETED}
1890     * permission in order to receive this broadcast.
1891     * <p>
1892     * This broadcast is sent immediately at boot by all devices (regardless of
1893     * direct boot support) running {@link android.os.Build.VERSION_CODES#N} or
1894     * higher. Upon receipt of this broadcast, the user is still locked and only
1895     * device-protected storage can be accessed safely. If you want to access
1896     * credential-protected storage, you need to wait for the user to be
1897     * unlocked (typically by entering their lock pattern or PIN for the first
1898     * time), after which the {@link #ACTION_USER_UNLOCKED} and
1899     * {@link #ACTION_BOOT_COMPLETED} broadcasts are sent.
1900     * <p>
1901     * To receive this broadcast, your receiver component must be marked as
1902     * being {@link ComponentInfo#directBootAware}.
1903     * <p class="note">
1904     * This is a protected intent that can only be sent by the system.
1905     *
1906     * @see Context#createDeviceProtectedStorageContext()
1907     */
1908    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1909    public static final String ACTION_LOCKED_BOOT_COMPLETED = "android.intent.action.LOCKED_BOOT_COMPLETED";
1910
1911    /**
1912     * Broadcast Action: This is broadcast once, after the user has finished
1913     * booting. It can be used to perform application-specific initialization,
1914     * such as installing alarms. You must hold the
1915     * {@link android.Manifest.permission#RECEIVE_BOOT_COMPLETED} permission in
1916     * order to receive this broadcast.
1917     * <p>
1918     * This broadcast is sent at boot by all devices (both with and without
1919     * direct boot support). Upon receipt of this broadcast, the user is
1920     * unlocked and both device-protected and credential-protected storage can
1921     * accessed safely.
1922     * <p>
1923     * If you need to run while the user is still locked (before they've entered
1924     * their lock pattern or PIN for the first time), you can listen for the
1925     * {@link #ACTION_LOCKED_BOOT_COMPLETED} broadcast.
1926     * <p class="note">
1927     * This is a protected intent that can only be sent by the system.
1928     */
1929    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1930    public static final String ACTION_BOOT_COMPLETED = "android.intent.action.BOOT_COMPLETED";
1931
1932    /**
1933     * Broadcast Action: This is broadcast when a user action should request a
1934     * temporary system dialog to dismiss.  Some examples of temporary system
1935     * dialogs are the notification window-shade and the recent tasks dialog.
1936     */
1937    public static final String ACTION_CLOSE_SYSTEM_DIALOGS = "android.intent.action.CLOSE_SYSTEM_DIALOGS";
1938    /**
1939     * Broadcast Action: Trigger the download and eventual installation
1940     * of a package.
1941     * <p>Input: {@link #getData} is the URI of the package file to download.
1942     *
1943     * <p class="note">This is a protected intent that can only be sent
1944     * by the system.
1945     *
1946     * @deprecated This constant has never been used.
1947     */
1948    @Deprecated
1949    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1950    public static final String ACTION_PACKAGE_INSTALL = "android.intent.action.PACKAGE_INSTALL";
1951    /**
1952     * Broadcast Action: A new application package has been installed on the
1953     * device. The data contains the name of the package.  Note that the
1954     * newly installed package does <em>not</em> receive this broadcast.
1955     * <p>May include the following extras:
1956     * <ul>
1957     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the new package.
1958     * <li> {@link #EXTRA_REPLACING} is set to true if this is following
1959     * an {@link #ACTION_PACKAGE_REMOVED} broadcast for the same package.
1960     * </ul>
1961     *
1962     * <p class="note">This is a protected intent that can only be sent
1963     * by the system.
1964     */
1965    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1966    public static final String ACTION_PACKAGE_ADDED = "android.intent.action.PACKAGE_ADDED";
1967    /**
1968     * Broadcast Action: A new version of an application package has been
1969     * installed, replacing an existing version that was previously installed.
1970     * The data contains the name of the package.
1971     * <p>May include the following extras:
1972     * <ul>
1973     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the new package.
1974     * </ul>
1975     *
1976     * <p class="note">This is a protected intent that can only be sent
1977     * by the system.
1978     */
1979    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1980    public static final String ACTION_PACKAGE_REPLACED = "android.intent.action.PACKAGE_REPLACED";
1981    /**
1982     * Broadcast Action: A new version of your application has been installed
1983     * over an existing one.  This is only sent to the application that was
1984     * replaced.  It does not contain any additional data; to receive it, just
1985     * use an intent filter for this action.
1986     *
1987     * <p class="note">This is a protected intent that can only be sent
1988     * by the system.
1989     */
1990    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1991    public static final String ACTION_MY_PACKAGE_REPLACED = "android.intent.action.MY_PACKAGE_REPLACED";
1992    /**
1993     * Broadcast Action: An existing application package has been removed from
1994     * the device.  The data contains the name of the package.  The package
1995     * that is being removed does <em>not</em> receive this Intent.
1996     * <ul>
1997     * <li> {@link #EXTRA_UID} containing the integer uid previously assigned
1998     * to the package.
1999     * <li> {@link #EXTRA_DATA_REMOVED} is set to true if the entire
2000     * application -- data and code -- is being removed.
2001     * <li> {@link #EXTRA_REPLACING} is set to true if this will be followed
2002     * by an {@link #ACTION_PACKAGE_ADDED} broadcast for the same package.
2003     * </ul>
2004     *
2005     * <p class="note">This is a protected intent that can only be sent
2006     * by the system.
2007     */
2008    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2009    public static final String ACTION_PACKAGE_REMOVED = "android.intent.action.PACKAGE_REMOVED";
2010    /**
2011     * Broadcast Action: An existing application package has been completely
2012     * removed from the device.  The data contains the name of the package.
2013     * This is like {@link #ACTION_PACKAGE_REMOVED}, but only set when
2014     * {@link #EXTRA_DATA_REMOVED} is true and
2015     * {@link #EXTRA_REPLACING} is false of that broadcast.
2016     *
2017     * <ul>
2018     * <li> {@link #EXTRA_UID} containing the integer uid previously assigned
2019     * to the package.
2020     * </ul>
2021     *
2022     * <p class="note">This is a protected intent that can only be sent
2023     * by the system.
2024     */
2025    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2026    public static final String ACTION_PACKAGE_FULLY_REMOVED
2027            = "android.intent.action.PACKAGE_FULLY_REMOVED";
2028    /**
2029     * Broadcast Action: An existing application package has been changed (for
2030     * example, a component has been enabled or disabled).  The data contains
2031     * the name of the package.
2032     * <ul>
2033     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the package.
2034     * <li> {@link #EXTRA_CHANGED_COMPONENT_NAME_LIST} containing the class name
2035     * of the changed components (or the package name itself).
2036     * <li> {@link #EXTRA_DONT_KILL_APP} containing boolean field to override the
2037     * default action of restarting the application.
2038     * </ul>
2039     *
2040     * <p class="note">This is a protected intent that can only be sent
2041     * by the system.
2042     */
2043    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2044    public static final String ACTION_PACKAGE_CHANGED = "android.intent.action.PACKAGE_CHANGED";
2045    /**
2046     * @hide
2047     * Broadcast Action: Ask system services if there is any reason to
2048     * restart the given package.  The data contains the name of the
2049     * package.
2050     * <ul>
2051     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the package.
2052     * <li> {@link #EXTRA_PACKAGES} String array of all packages to check.
2053     * </ul>
2054     *
2055     * <p class="note">This is a protected intent that can only be sent
2056     * by the system.
2057     */
2058    @SystemApi
2059    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2060    public static final String ACTION_QUERY_PACKAGE_RESTART = "android.intent.action.QUERY_PACKAGE_RESTART";
2061    /**
2062     * Broadcast Action: The user has restarted a package, and all of its
2063     * processes have been killed.  All runtime state
2064     * associated with it (processes, alarms, notifications, etc) should
2065     * be removed.  Note that the restarted package does <em>not</em>
2066     * receive this broadcast.
2067     * The data contains the name of the package.
2068     * <ul>
2069     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the package.
2070     * </ul>
2071     *
2072     * <p class="note">This is a protected intent that can only be sent
2073     * by the system.
2074     */
2075    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2076    public static final String ACTION_PACKAGE_RESTARTED = "android.intent.action.PACKAGE_RESTARTED";
2077    /**
2078     * Broadcast Action: The user has cleared the data of a package.  This should
2079     * be preceded by {@link #ACTION_PACKAGE_RESTARTED}, after which all of
2080     * its persistent data is erased and this broadcast sent.
2081     * Note that the cleared package does <em>not</em>
2082     * receive this broadcast. The data contains the name of the package.
2083     * <ul>
2084     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the package.
2085     * </ul>
2086     *
2087     * <p class="note">This is a protected intent that can only be sent
2088     * by the system.
2089     */
2090    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2091    public static final String ACTION_PACKAGE_DATA_CLEARED = "android.intent.action.PACKAGE_DATA_CLEARED";
2092    /**
2093     * Broadcast Action: Packages have been suspended.
2094     * <p>Includes the following extras:
2095     * <ul>
2096     * <li> {@link #EXTRA_CHANGED_PACKAGE_LIST} is the set of packages which have been suspended
2097     * </ul>
2098     *
2099     * <p class="note">This is a protected intent that can only be sent
2100     * by the system. It is only sent to registered receivers.
2101     */
2102    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2103    public static final String ACTION_PACKAGES_SUSPENDED = "android.intent.action.PACKAGES_SUSPENDED";
2104    /**
2105     * Broadcast Action: Packages have been unsuspended.
2106     * <p>Includes the following extras:
2107     * <ul>
2108     * <li> {@link #EXTRA_CHANGED_PACKAGE_LIST} is the set of packages which have been unsuspended
2109     * </ul>
2110     *
2111     * <p class="note">This is a protected intent that can only be sent
2112     * by the system. It is only sent to registered receivers.
2113     */
2114    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2115    public static final String ACTION_PACKAGES_UNSUSPENDED = "android.intent.action.PACKAGES_UNSUSPENDED";
2116    /**
2117     * Broadcast Action: A user ID has been removed from the system.  The user
2118     * ID number is stored in the extra data under {@link #EXTRA_UID}.
2119     *
2120     * <p class="note">This is a protected intent that can only be sent
2121     * by the system.
2122     */
2123    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2124    public static final String ACTION_UID_REMOVED = "android.intent.action.UID_REMOVED";
2125
2126    /**
2127     * Broadcast Action: Sent to the installer package of an application when
2128     * that application is first launched (that is the first time it is moved
2129     * out of the stopped state).  The data contains the name of the package.
2130     *
2131     * <p class="note">This is a protected intent that can only be sent
2132     * by the system.
2133     */
2134    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2135    public static final String ACTION_PACKAGE_FIRST_LAUNCH = "android.intent.action.PACKAGE_FIRST_LAUNCH";
2136
2137    /**
2138     * Broadcast Action: Sent to the system package verifier when a package
2139     * needs to be verified. The data contains the package URI.
2140     * <p class="note">
2141     * This is a protected intent that can only be sent by the system.
2142     * </p>
2143     */
2144    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2145    public static final String ACTION_PACKAGE_NEEDS_VERIFICATION = "android.intent.action.PACKAGE_NEEDS_VERIFICATION";
2146
2147    /**
2148     * Broadcast Action: Sent to the system package verifier when a package is
2149     * verified. The data contains the package URI.
2150     * <p class="note">
2151     * This is a protected intent that can only be sent by the system.
2152     */
2153    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2154    public static final String ACTION_PACKAGE_VERIFIED = "android.intent.action.PACKAGE_VERIFIED";
2155
2156    /**
2157     * Broadcast Action: Sent to the system intent filter verifier when an
2158     * intent filter needs to be verified. The data contains the filter data
2159     * hosts to be verified against.
2160     * <p class="note">
2161     * This is a protected intent that can only be sent by the system.
2162     * </p>
2163     *
2164     * @hide
2165     */
2166    @SystemApi
2167    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2168    public static final String ACTION_INTENT_FILTER_NEEDS_VERIFICATION = "android.intent.action.INTENT_FILTER_NEEDS_VERIFICATION";
2169
2170    /**
2171     * Broadcast Action: Resources for a set of packages (which were
2172     * previously unavailable) are currently
2173     * available since the media on which they exist is available.
2174     * The extra data {@link #EXTRA_CHANGED_PACKAGE_LIST} contains a
2175     * list of packages whose availability changed.
2176     * The extra data {@link #EXTRA_CHANGED_UID_LIST} contains a
2177     * list of uids of packages whose availability changed.
2178     * Note that the
2179     * packages in this list do <em>not</em> receive this broadcast.
2180     * The specified set of packages are now available on the system.
2181     * <p>Includes the following extras:
2182     * <ul>
2183     * <li> {@link #EXTRA_CHANGED_PACKAGE_LIST} is the set of packages
2184     * whose resources(were previously unavailable) are currently available.
2185     * {@link #EXTRA_CHANGED_UID_LIST} is the set of uids of the
2186     * packages whose resources(were previously unavailable)
2187     * are  currently available.
2188     * </ul>
2189     *
2190     * <p class="note">This is a protected intent that can only be sent
2191     * by the system.
2192     */
2193    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2194    public static final String ACTION_EXTERNAL_APPLICATIONS_AVAILABLE =
2195        "android.intent.action.EXTERNAL_APPLICATIONS_AVAILABLE";
2196
2197    /**
2198     * Broadcast Action: Resources for a set of packages are currently
2199     * unavailable since the media on which they exist is unavailable.
2200     * The extra data {@link #EXTRA_CHANGED_PACKAGE_LIST} contains a
2201     * list of packages whose availability changed.
2202     * The extra data {@link #EXTRA_CHANGED_UID_LIST} contains a
2203     * list of uids of packages whose availability changed.
2204     * The specified set of packages can no longer be
2205     * launched and are practically unavailable on the system.
2206     * <p>Inclues the following extras:
2207     * <ul>
2208     * <li> {@link #EXTRA_CHANGED_PACKAGE_LIST} is the set of packages
2209     * whose resources are no longer available.
2210     * {@link #EXTRA_CHANGED_UID_LIST} is the set of packages
2211     * whose resources are no longer available.
2212     * </ul>
2213     *
2214     * <p class="note">This is a protected intent that can only be sent
2215     * by the system.
2216     */
2217    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2218    public static final String ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE =
2219        "android.intent.action.EXTERNAL_APPLICATIONS_UNAVAILABLE";
2220
2221    /**
2222     * Broadcast Action: preferred activities have changed *explicitly*.
2223     *
2224     * <p>Note there are cases where a preferred activity is invalidated *implicitly*, e.g.
2225     * when an app is installed or uninstalled, but in such cases this broadcast will *not*
2226     * be sent.
2227     *
2228     * {@link #EXTRA_USER_HANDLE} contains the user ID in question.
2229     *
2230     * @hide
2231     */
2232    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2233    public static final String ACTION_PREFERRED_ACTIVITY_CHANGED =
2234            "android.intent.action.ACTION_PREFERRED_ACTIVITY_CHANGED";
2235
2236
2237    /**
2238     * Broadcast Action:  The current system wallpaper has changed.  See
2239     * {@link android.app.WallpaperManager} for retrieving the new wallpaper.
2240     * This should <em>only</em> be used to determine when the wallpaper
2241     * has changed to show the new wallpaper to the user.  You should certainly
2242     * never, in response to this, change the wallpaper or other attributes of
2243     * it such as the suggested size.  That would be crazy, right?  You'd cause
2244     * all kinds of loops, especially if other apps are doing similar things,
2245     * right?  Of course.  So please don't do this.
2246     *
2247     * @deprecated Modern applications should use
2248     * {@link android.view.WindowManager.LayoutParams#FLAG_SHOW_WALLPAPER
2249     * WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER} to have the wallpaper
2250     * shown behind their UI, rather than watching for this broadcast and
2251     * rendering the wallpaper on their own.
2252     */
2253    @Deprecated @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2254    public static final String ACTION_WALLPAPER_CHANGED = "android.intent.action.WALLPAPER_CHANGED";
2255    /**
2256     * Broadcast Action: The current device {@link android.content.res.Configuration}
2257     * (orientation, locale, etc) has changed.  When such a change happens, the
2258     * UIs (view hierarchy) will need to be rebuilt based on this new
2259     * information; for the most part, applications don't need to worry about
2260     * this, because the system will take care of stopping and restarting the
2261     * application to make sure it sees the new changes.  Some system code that
2262     * can not be restarted will need to watch for this action and handle it
2263     * appropriately.
2264     *
2265     * <p class="note">
2266     * You <em>cannot</em> receive this through components declared
2267     * in manifests, only by explicitly registering for it with
2268     * {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
2269     * Context.registerReceiver()}.
2270     *
2271     * <p class="note">This is a protected intent that can only be sent
2272     * by the system.
2273     *
2274     * @see android.content.res.Configuration
2275     */
2276    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2277    public static final String ACTION_CONFIGURATION_CHANGED = "android.intent.action.CONFIGURATION_CHANGED";
2278    /**
2279     * Broadcast Action: The current device's locale has changed.
2280     *
2281     * <p class="note">This is a protected intent that can only be sent
2282     * by the system.
2283     */
2284    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2285    public static final String ACTION_LOCALE_CHANGED = "android.intent.action.LOCALE_CHANGED";
2286    /**
2287     * Broadcast Action:  This is a <em>sticky broadcast</em> containing the
2288     * charging state, level, and other information about the battery.
2289     * See {@link android.os.BatteryManager} for documentation on the
2290     * contents of the Intent.
2291     *
2292     * <p class="note">
2293     * You <em>cannot</em> receive this through components declared
2294     * in manifests, only by explicitly registering for it with
2295     * {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
2296     * Context.registerReceiver()}.  See {@link #ACTION_BATTERY_LOW},
2297     * {@link #ACTION_BATTERY_OKAY}, {@link #ACTION_POWER_CONNECTED},
2298     * and {@link #ACTION_POWER_DISCONNECTED} for distinct battery-related
2299     * broadcasts that are sent and can be received through manifest
2300     * receivers.
2301     *
2302     * <p class="note">This is a protected intent that can only be sent
2303     * by the system.
2304     */
2305    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2306    public static final String ACTION_BATTERY_CHANGED = "android.intent.action.BATTERY_CHANGED";
2307    /**
2308     * Broadcast Action:  Indicates low battery condition on the device.
2309     * This broadcast corresponds to the "Low battery warning" system dialog.
2310     *
2311     * <p class="note">This is a protected intent that can only be sent
2312     * by the system.
2313     */
2314    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2315    public static final String ACTION_BATTERY_LOW = "android.intent.action.BATTERY_LOW";
2316    /**
2317     * Broadcast Action:  Indicates the battery is now okay after being low.
2318     * This will be sent after {@link #ACTION_BATTERY_LOW} once the battery has
2319     * gone back up to an okay state.
2320     *
2321     * <p class="note">This is a protected intent that can only be sent
2322     * by the system.
2323     */
2324    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2325    public static final String ACTION_BATTERY_OKAY = "android.intent.action.BATTERY_OKAY";
2326    /**
2327     * Broadcast Action:  External power has been connected to the device.
2328     * This is intended for applications that wish to register specifically to this notification.
2329     * Unlike ACTION_BATTERY_CHANGED, applications will be woken for this and so do not have to
2330     * stay active to receive this notification.  This action can be used to implement actions
2331     * that wait until power is available to trigger.
2332     *
2333     * <p class="note">This is a protected intent that can only be sent
2334     * by the system.
2335     */
2336    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2337    public static final String ACTION_POWER_CONNECTED = "android.intent.action.ACTION_POWER_CONNECTED";
2338    /**
2339     * Broadcast Action:  External power has been removed from the device.
2340     * This is intended for applications that wish to register specifically to this notification.
2341     * Unlike ACTION_BATTERY_CHANGED, applications will be woken for this and so do not have to
2342     * stay active to receive this notification.  This action can be used to implement actions
2343     * that wait until power is available to trigger.
2344     *
2345     * <p class="note">This is a protected intent that can only be sent
2346     * by the system.
2347     */
2348    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2349    public static final String ACTION_POWER_DISCONNECTED =
2350            "android.intent.action.ACTION_POWER_DISCONNECTED";
2351    /**
2352     * Broadcast Action:  Device is shutting down.
2353     * This is broadcast when the device is being shut down (completely turned
2354     * off, not sleeping).  Once the broadcast is complete, the final shutdown
2355     * will proceed and all unsaved data lost.  Apps will not normally need
2356     * to handle this, since the foreground activity will be paused as well.
2357     *
2358     * <p class="note">This is a protected intent that can only be sent
2359     * by the system.
2360     * <p>May include the following extras:
2361     * <ul>
2362     * <li> {@link #EXTRA_SHUTDOWN_USERSPACE_ONLY} a boolean that is set to true if this
2363     * shutdown is only for userspace processes.  If not set, assumed to be false.
2364     * </ul>
2365     */
2366    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2367    public static final String ACTION_SHUTDOWN = "android.intent.action.ACTION_SHUTDOWN";
2368    /**
2369     * Activity Action:  Start this activity to request system shutdown.
2370     * The optional boolean extra field {@link #EXTRA_KEY_CONFIRM} can be set to true
2371     * to request confirmation from the user before shutting down. The optional boolean
2372     * extra field {@link #EXTRA_USER_REQUESTED_SHUTDOWN} can be set to true to
2373     * indicate that the shutdown is requested by the user.
2374     *
2375     * <p class="note">This is a protected intent that can only be sent
2376     * by the system.
2377     *
2378     * {@hide}
2379     */
2380    public static final String ACTION_REQUEST_SHUTDOWN = "android.intent.action.ACTION_REQUEST_SHUTDOWN";
2381    /**
2382     * Broadcast Action:  A sticky broadcast that indicates low memory
2383     * condition on the device
2384     *
2385     * <p class="note">This is a protected intent that can only be sent
2386     * by the system.
2387     */
2388    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2389    public static final String ACTION_DEVICE_STORAGE_LOW = "android.intent.action.DEVICE_STORAGE_LOW";
2390    /**
2391     * Broadcast Action:  Indicates low memory condition on the device no longer exists
2392     *
2393     * <p class="note">This is a protected intent that can only be sent
2394     * by the system.
2395     */
2396    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2397    public static final String ACTION_DEVICE_STORAGE_OK = "android.intent.action.DEVICE_STORAGE_OK";
2398    /**
2399     * Broadcast Action:  A sticky broadcast that indicates a memory full
2400     * condition on the device. This is intended for activities that want
2401     * to be able to fill the data partition completely, leaving only
2402     * enough free space to prevent system-wide SQLite failures.
2403     *
2404     * <p class="note">This is a protected intent that can only be sent
2405     * by the system.
2406     *
2407     * {@hide}
2408     */
2409    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2410    public static final String ACTION_DEVICE_STORAGE_FULL = "android.intent.action.DEVICE_STORAGE_FULL";
2411    /**
2412     * Broadcast Action:  Indicates memory full condition on the device
2413     * no longer exists.
2414     *
2415     * <p class="note">This is a protected intent that can only be sent
2416     * by the system.
2417     *
2418     * {@hide}
2419     */
2420    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2421    public static final String ACTION_DEVICE_STORAGE_NOT_FULL = "android.intent.action.DEVICE_STORAGE_NOT_FULL";
2422    /**
2423     * Broadcast Action:  Indicates low memory condition notification acknowledged by user
2424     * and package management should be started.
2425     * This is triggered by the user from the ACTION_DEVICE_STORAGE_LOW
2426     * notification.
2427     */
2428    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2429    public static final String ACTION_MANAGE_PACKAGE_STORAGE = "android.intent.action.MANAGE_PACKAGE_STORAGE";
2430    /**
2431     * Broadcast Action:  The device has entered USB Mass Storage mode.
2432     * This is used mainly for the USB Settings panel.
2433     * Apps should listen for ACTION_MEDIA_MOUNTED and ACTION_MEDIA_UNMOUNTED broadcasts to be notified
2434     * when the SD card file system is mounted or unmounted
2435     * @deprecated replaced by android.os.storage.StorageEventListener
2436     */
2437    @Deprecated
2438    public static final String ACTION_UMS_CONNECTED = "android.intent.action.UMS_CONNECTED";
2439
2440    /**
2441     * Broadcast Action:  The device has exited USB Mass Storage mode.
2442     * This is used mainly for the USB Settings panel.
2443     * Apps should listen for ACTION_MEDIA_MOUNTED and ACTION_MEDIA_UNMOUNTED broadcasts to be notified
2444     * when the SD card file system is mounted or unmounted
2445     * @deprecated replaced by android.os.storage.StorageEventListener
2446     */
2447    @Deprecated
2448    public static final String ACTION_UMS_DISCONNECTED = "android.intent.action.UMS_DISCONNECTED";
2449
2450    /**
2451     * Broadcast Action:  External media has been removed.
2452     * The path to the mount point for the removed media is contained in the Intent.mData field.
2453     */
2454    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2455    public static final String ACTION_MEDIA_REMOVED = "android.intent.action.MEDIA_REMOVED";
2456
2457    /**
2458     * Broadcast Action:  External media is present, but not mounted at its mount point.
2459     * The path to the mount point for the unmounted media is contained in the Intent.mData field.
2460     */
2461    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2462    public static final String ACTION_MEDIA_UNMOUNTED = "android.intent.action.MEDIA_UNMOUNTED";
2463
2464    /**
2465     * Broadcast Action:  External media is present, and being disk-checked
2466     * The path to the mount point for the checking media is contained in the Intent.mData field.
2467     */
2468    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2469    public static final String ACTION_MEDIA_CHECKING = "android.intent.action.MEDIA_CHECKING";
2470
2471    /**
2472     * Broadcast Action:  External media is present, but is using an incompatible fs (or is blank)
2473     * The path to the mount point for the checking media is contained in the Intent.mData field.
2474     */
2475    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2476    public static final String ACTION_MEDIA_NOFS = "android.intent.action.MEDIA_NOFS";
2477
2478    /**
2479     * Broadcast Action:  External media is present and mounted at its mount point.
2480     * The path to the mount point for the mounted media is contained in the Intent.mData field.
2481     * The Intent contains an extra with name "read-only" and Boolean value to indicate if the
2482     * media was mounted read only.
2483     */
2484    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2485    public static final String ACTION_MEDIA_MOUNTED = "android.intent.action.MEDIA_MOUNTED";
2486
2487    /**
2488     * Broadcast Action:  External media is unmounted because it is being shared via USB mass storage.
2489     * The path to the mount point for the shared media is contained in the Intent.mData field.
2490     */
2491    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2492    public static final String ACTION_MEDIA_SHARED = "android.intent.action.MEDIA_SHARED";
2493
2494    /**
2495     * Broadcast Action:  External media is no longer being shared via USB mass storage.
2496     * The path to the mount point for the previously shared media is contained in the Intent.mData field.
2497     *
2498     * @hide
2499     */
2500    public static final String ACTION_MEDIA_UNSHARED = "android.intent.action.MEDIA_UNSHARED";
2501
2502    /**
2503     * Broadcast Action:  External media was removed from SD card slot, but mount point was not unmounted.
2504     * The path to the mount point for the removed media is contained in the Intent.mData field.
2505     */
2506    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2507    public static final String ACTION_MEDIA_BAD_REMOVAL = "android.intent.action.MEDIA_BAD_REMOVAL";
2508
2509    /**
2510     * Broadcast Action:  External media is present but cannot be mounted.
2511     * The path to the mount point for the unmountable media is contained in the Intent.mData field.
2512     */
2513    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2514    public static final String ACTION_MEDIA_UNMOUNTABLE = "android.intent.action.MEDIA_UNMOUNTABLE";
2515
2516   /**
2517     * Broadcast Action:  User has expressed the desire to remove the external storage media.
2518     * Applications should close all files they have open within the mount point when they receive this intent.
2519     * The path to the mount point for the media to be ejected is contained in the Intent.mData field.
2520     */
2521    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2522    public static final String ACTION_MEDIA_EJECT = "android.intent.action.MEDIA_EJECT";
2523
2524    /**
2525     * Broadcast Action:  The media scanner has started scanning a directory.
2526     * The path to the directory being scanned is contained in the Intent.mData field.
2527     */
2528    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2529    public static final String ACTION_MEDIA_SCANNER_STARTED = "android.intent.action.MEDIA_SCANNER_STARTED";
2530
2531   /**
2532     * Broadcast Action:  The media scanner has finished scanning a directory.
2533     * The path to the scanned directory is contained in the Intent.mData field.
2534     */
2535    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2536    public static final String ACTION_MEDIA_SCANNER_FINISHED = "android.intent.action.MEDIA_SCANNER_FINISHED";
2537
2538   /**
2539     * Broadcast Action:  Request the media scanner to scan a file and add it to the media database.
2540     * The path to the file is contained in the Intent.mData field.
2541     */
2542    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2543    public static final String ACTION_MEDIA_SCANNER_SCAN_FILE = "android.intent.action.MEDIA_SCANNER_SCAN_FILE";
2544
2545   /**
2546     * Broadcast Action:  The "Media Button" was pressed.  Includes a single
2547     * extra field, {@link #EXTRA_KEY_EVENT}, containing the key event that
2548     * caused the broadcast.
2549     */
2550    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2551    public static final String ACTION_MEDIA_BUTTON = "android.intent.action.MEDIA_BUTTON";
2552
2553    /**
2554     * Broadcast Action:  The "Camera Button" was pressed.  Includes a single
2555     * extra field, {@link #EXTRA_KEY_EVENT}, containing the key event that
2556     * caused the broadcast.
2557     */
2558    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2559    public static final String ACTION_CAMERA_BUTTON = "android.intent.action.CAMERA_BUTTON";
2560
2561    // *** NOTE: @todo(*) The following really should go into a more domain-specific
2562    // location; they are not general-purpose actions.
2563
2564    /**
2565     * Broadcast Action: A GTalk connection has been established.
2566     */
2567    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2568    public static final String ACTION_GTALK_SERVICE_CONNECTED =
2569            "android.intent.action.GTALK_CONNECTED";
2570
2571    /**
2572     * Broadcast Action: A GTalk connection has been disconnected.
2573     */
2574    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2575    public static final String ACTION_GTALK_SERVICE_DISCONNECTED =
2576            "android.intent.action.GTALK_DISCONNECTED";
2577
2578    /**
2579     * Broadcast Action: An input method has been changed.
2580     */
2581    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2582    public static final String ACTION_INPUT_METHOD_CHANGED =
2583            "android.intent.action.INPUT_METHOD_CHANGED";
2584
2585    /**
2586     * <p>Broadcast Action: The user has switched the phone into or out of Airplane Mode. One or
2587     * more radios have been turned off or on. The intent will have the following extra value:</p>
2588     * <ul>
2589     *   <li><em>state</em> - A boolean value indicating whether Airplane Mode is on. If true,
2590     *   then cell radio and possibly other radios such as bluetooth or WiFi may have also been
2591     *   turned off</li>
2592     * </ul>
2593     *
2594     * <p class="note">This is a protected intent that can only be sent by the system.</p>
2595     */
2596    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2597    public static final String ACTION_AIRPLANE_MODE_CHANGED = "android.intent.action.AIRPLANE_MODE";
2598
2599    /**
2600     * Broadcast Action: Some content providers have parts of their namespace
2601     * where they publish new events or items that the user may be especially
2602     * interested in. For these things, they may broadcast this action when the
2603     * set of interesting items change.
2604     *
2605     * For example, GmailProvider sends this notification when the set of unread
2606     * mail in the inbox changes.
2607     *
2608     * <p>The data of the intent identifies which part of which provider
2609     * changed. When queried through the content resolver, the data URI will
2610     * return the data set in question.
2611     *
2612     * <p>The intent will have the following extra values:
2613     * <ul>
2614     *   <li><em>count</em> - The number of items in the data set. This is the
2615     *       same as the number of items in the cursor returned by querying the
2616     *       data URI. </li>
2617     * </ul>
2618     *
2619     * This intent will be sent at boot (if the count is non-zero) and when the
2620     * data set changes. It is possible for the data set to change without the
2621     * count changing (for example, if a new unread message arrives in the same
2622     * sync operation in which a message is archived). The phone should still
2623     * ring/vibrate/etc as normal in this case.
2624     */
2625    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2626    public static final String ACTION_PROVIDER_CHANGED =
2627            "android.intent.action.PROVIDER_CHANGED";
2628
2629    /**
2630     * Broadcast Action: Wired Headset plugged in or unplugged.
2631     *
2632     * Same as {@link android.media.AudioManager#ACTION_HEADSET_PLUG}, to be consulted for value
2633     *   and documentation.
2634     * <p>If the minimum SDK version of your application is
2635     * {@link android.os.Build.VERSION_CODES#LOLLIPOP}, it is recommended to refer
2636     * to the <code>AudioManager</code> constant in your receiver registration code instead.
2637     */
2638    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2639    public static final String ACTION_HEADSET_PLUG = android.media.AudioManager.ACTION_HEADSET_PLUG;
2640
2641    /**
2642     * <p>Broadcast Action: The user has switched on advanced settings in the settings app:</p>
2643     * <ul>
2644     *   <li><em>state</em> - A boolean value indicating whether the settings is on or off.</li>
2645     * </ul>
2646     *
2647     * <p class="note">This is a protected intent that can only be sent
2648     * by the system.
2649     *
2650     * @hide
2651     */
2652    //@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2653    public static final String ACTION_ADVANCED_SETTINGS_CHANGED
2654            = "android.intent.action.ADVANCED_SETTINGS";
2655
2656    /**
2657     *  Broadcast Action: Sent after application restrictions are changed.
2658     *
2659     * <p class="note">This is a protected intent that can only be sent
2660     * by the system.</p>
2661     */
2662    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2663    public static final String ACTION_APPLICATION_RESTRICTIONS_CHANGED =
2664            "android.intent.action.APPLICATION_RESTRICTIONS_CHANGED";
2665
2666    /**
2667     * Broadcast Action: An outgoing call is about to be placed.
2668     *
2669     * <p>The Intent will have the following extra value:</p>
2670     * <ul>
2671     *   <li><em>{@link android.content.Intent#EXTRA_PHONE_NUMBER}</em> -
2672     *       the phone number originally intended to be dialed.</li>
2673     * </ul>
2674     * <p>Once the broadcast is finished, the resultData is used as the actual
2675     * number to call.  If  <code>null</code>, no call will be placed.</p>
2676     * <p>It is perfectly acceptable for multiple receivers to process the
2677     * outgoing call in turn: for example, a parental control application
2678     * might verify that the user is authorized to place the call at that
2679     * time, then a number-rewriting application might add an area code if
2680     * one was not specified.</p>
2681     * <p>For consistency, any receiver whose purpose is to prohibit phone
2682     * calls should have a priority of 0, to ensure it will see the final
2683     * phone number to be dialed.
2684     * Any receiver whose purpose is to rewrite phone numbers to be called
2685     * should have a positive priority.
2686     * Negative priorities are reserved for the system for this broadcast;
2687     * using them may cause problems.</p>
2688     * <p>Any BroadcastReceiver receiving this Intent <em>must not</em>
2689     * abort the broadcast.</p>
2690     * <p>Emergency calls cannot be intercepted using this mechanism, and
2691     * other calls cannot be modified to call emergency numbers using this
2692     * mechanism.
2693     * <p>Some apps (such as VoIP apps) may want to redirect the outgoing
2694     * call to use their own service instead. Those apps should first prevent
2695     * the call from being placed by setting resultData to <code>null</code>
2696     * and then start their own app to make the call.
2697     * <p>You must hold the
2698     * {@link android.Manifest.permission#PROCESS_OUTGOING_CALLS}
2699     * permission to receive this Intent.</p>
2700     *
2701     * <p class="note">This is a protected intent that can only be sent
2702     * by the system.
2703     */
2704    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2705    public static final String ACTION_NEW_OUTGOING_CALL =
2706            "android.intent.action.NEW_OUTGOING_CALL";
2707
2708    /**
2709     * Broadcast Action: Have the device reboot.  This is only for use by
2710     * system code.
2711     *
2712     * <p class="note">This is a protected intent that can only be sent
2713     * by the system.
2714     */
2715    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2716    public static final String ACTION_REBOOT =
2717            "android.intent.action.REBOOT";
2718
2719    /**
2720     * Broadcast Action:  A sticky broadcast for changes in the physical
2721     * docking state of the device.
2722     *
2723     * <p>The intent will have the following extra values:
2724     * <ul>
2725     *   <li><em>{@link #EXTRA_DOCK_STATE}</em> - the current dock
2726     *       state, indicating which dock the device is physically in.</li>
2727     * </ul>
2728     * <p>This is intended for monitoring the current physical dock state.
2729     * See {@link android.app.UiModeManager} for the normal API dealing with
2730     * dock mode changes.
2731     */
2732    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2733    public static final String ACTION_DOCK_EVENT =
2734            "android.intent.action.DOCK_EVENT";
2735
2736    /**
2737     * Broadcast Action: A broadcast when idle maintenance can be started.
2738     * This means that the user is not interacting with the device and is
2739     * not expected to do so soon. Typical use of the idle maintenance is
2740     * to perform somehow expensive tasks that can be postponed at a moment
2741     * when they will not degrade user experience.
2742     * <p>
2743     * <p class="note">In order to keep the device responsive in case of an
2744     * unexpected user interaction, implementations of a maintenance task
2745     * should be interruptible. In such a scenario a broadcast with action
2746     * {@link #ACTION_IDLE_MAINTENANCE_END} will be sent. In other words, you
2747     * should not do the maintenance work in
2748     * {@link BroadcastReceiver#onReceive(Context, Intent)}, rather start a
2749     * maintenance service by {@link Context#startService(Intent)}. Also
2750     * you should hold a wake lock while your maintenance service is running
2751     * to prevent the device going to sleep.
2752     * </p>
2753     * <p>
2754     * <p class="note">This is a protected intent that can only be sent by
2755     * the system.
2756     * </p>
2757     *
2758     * @see #ACTION_IDLE_MAINTENANCE_END
2759     *
2760     * @hide
2761     */
2762    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2763    public static final String ACTION_IDLE_MAINTENANCE_START =
2764            "android.intent.action.ACTION_IDLE_MAINTENANCE_START";
2765
2766    /**
2767     * Broadcast Action:  A broadcast when idle maintenance should be stopped.
2768     * This means that the user was not interacting with the device as a result
2769     * of which a broadcast with action {@link #ACTION_IDLE_MAINTENANCE_START}
2770     * was sent and now the user started interacting with the device. Typical
2771     * use of the idle maintenance is to perform somehow expensive tasks that
2772     * can be postponed at a moment when they will not degrade user experience.
2773     * <p>
2774     * <p class="note">In order to keep the device responsive in case of an
2775     * unexpected user interaction, implementations of a maintenance task
2776     * should be interruptible. Hence, on receiving a broadcast with this
2777     * action, the maintenance task should be interrupted as soon as possible.
2778     * In other words, you should not do the maintenance work in
2779     * {@link BroadcastReceiver#onReceive(Context, Intent)}, rather stop the
2780     * maintenance service that was started on receiving of
2781     * {@link #ACTION_IDLE_MAINTENANCE_START}.Also you should release the wake
2782     * lock you acquired when your maintenance service started.
2783     * </p>
2784     * <p class="note">This is a protected intent that can only be sent
2785     * by the system.
2786     *
2787     * @see #ACTION_IDLE_MAINTENANCE_START
2788     *
2789     * @hide
2790     */
2791    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2792    public static final String ACTION_IDLE_MAINTENANCE_END =
2793            "android.intent.action.ACTION_IDLE_MAINTENANCE_END";
2794
2795    /**
2796     * Broadcast Action: a remote intent is to be broadcasted.
2797     *
2798     * A remote intent is used for remote RPC between devices. The remote intent
2799     * is serialized and sent from one device to another device. The receiving
2800     * device parses the remote intent and broadcasts it. Note that anyone can
2801     * broadcast a remote intent. However, if the intent receiver of the remote intent
2802     * does not trust intent broadcasts from arbitrary intent senders, it should require
2803     * the sender to hold certain permissions so only trusted sender's broadcast will be
2804     * let through.
2805     * @hide
2806     */
2807    public static final String ACTION_REMOTE_INTENT =
2808            "com.google.android.c2dm.intent.RECEIVE";
2809
2810    /**
2811     * Broadcast Action: This is broadcast once when the user is booting after a
2812     * system update. It can be used to perform cleanup or upgrades after a
2813     * system update.
2814     * <p>
2815     * This broadcast is sent after the {@link #ACTION_LOCKED_BOOT_COMPLETED}
2816     * broadcast but before the {@link #ACTION_BOOT_COMPLETED} broadcast. It's
2817     * only sent when the {@link Build#FINGERPRINT} has changed, and it's only
2818     * sent to receivers in the system image.
2819     *
2820     * @hide
2821     */
2822    public static final String ACTION_PRE_BOOT_COMPLETED =
2823            "android.intent.action.PRE_BOOT_COMPLETED";
2824
2825    /**
2826     * Broadcast to a specific application to query any supported restrictions to impose
2827     * on restricted users. The broadcast intent contains an extra
2828     * {@link #EXTRA_RESTRICTIONS_BUNDLE} with the currently persisted
2829     * restrictions as a Bundle of key/value pairs. The value types can be Boolean, String or
2830     * String[] depending on the restriction type.<p/>
2831     * The response should contain an extra {@link #EXTRA_RESTRICTIONS_LIST},
2832     * which is of type <code>ArrayList&lt;RestrictionEntry&gt;</code>. It can also
2833     * contain an extra {@link #EXTRA_RESTRICTIONS_INTENT}, which is of type <code>Intent</code>.
2834     * The activity specified by that intent will be launched for a result which must contain
2835     * one of the extras {@link #EXTRA_RESTRICTIONS_LIST} or {@link #EXTRA_RESTRICTIONS_BUNDLE}.
2836     * The keys and values of the returned restrictions will be persisted.
2837     * @see RestrictionEntry
2838     */
2839    public static final String ACTION_GET_RESTRICTION_ENTRIES =
2840            "android.intent.action.GET_RESTRICTION_ENTRIES";
2841
2842    /**
2843     * Sent the first time a user is starting, to allow system apps to
2844     * perform one time initialization.  (This will not be seen by third
2845     * party applications because a newly initialized user does not have any
2846     * third party applications installed for it.)  This is sent early in
2847     * starting the user, around the time the home app is started, before
2848     * {@link #ACTION_BOOT_COMPLETED} is sent.  This is sent as a foreground
2849     * broadcast, since it is part of a visible user interaction; be as quick
2850     * as possible when handling it.
2851     */
2852    public static final String ACTION_USER_INITIALIZE =
2853            "android.intent.action.USER_INITIALIZE";
2854
2855    /**
2856     * Sent when a user switch is happening, causing the process's user to be
2857     * brought to the foreground.  This is only sent to receivers registered
2858     * through {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
2859     * Context.registerReceiver}.  It is sent to the user that is going to the
2860     * foreground.  This is sent as a foreground
2861     * broadcast, since it is part of a visible user interaction; be as quick
2862     * as possible when handling it.
2863     */
2864    public static final String ACTION_USER_FOREGROUND =
2865            "android.intent.action.USER_FOREGROUND";
2866
2867    /**
2868     * Sent when a user switch is happening, causing the process's user to be
2869     * sent to the background.  This is only sent to receivers registered
2870     * through {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
2871     * Context.registerReceiver}.  It is sent to the user that is going to the
2872     * background.  This is sent as a foreground
2873     * broadcast, since it is part of a visible user interaction; be as quick
2874     * as possible when handling it.
2875     */
2876    public static final String ACTION_USER_BACKGROUND =
2877            "android.intent.action.USER_BACKGROUND";
2878
2879    /**
2880     * Broadcast sent to the system when a user is added. Carries an extra
2881     * EXTRA_USER_HANDLE that has the userHandle of the new user.  It is sent to
2882     * all running users.  You must hold
2883     * {@link android.Manifest.permission#MANAGE_USERS} to receive this broadcast.
2884     * @hide
2885     */
2886    public static final String ACTION_USER_ADDED =
2887            "android.intent.action.USER_ADDED";
2888
2889    /**
2890     * Broadcast sent by the system when a user is started. Carries an extra
2891     * EXTRA_USER_HANDLE that has the userHandle of the user.  This is only sent to
2892     * registered receivers, not manifest receivers.  It is sent to the user
2893     * that has been started.  This is sent as a foreground
2894     * broadcast, since it is part of a visible user interaction; be as quick
2895     * as possible when handling it.
2896     * @hide
2897     */
2898    public static final String ACTION_USER_STARTED =
2899            "android.intent.action.USER_STARTED";
2900
2901    /**
2902     * Broadcast sent when a user is in the process of starting.  Carries an extra
2903     * EXTRA_USER_HANDLE that has the userHandle of the user.  This is only
2904     * sent to registered receivers, not manifest receivers.  It is sent to all
2905     * users (including the one that is being started).  You must hold
2906     * {@link android.Manifest.permission#INTERACT_ACROSS_USERS} to receive
2907     * this broadcast.  This is sent as a background broadcast, since
2908     * its result is not part of the primary UX flow; to safely keep track of
2909     * started/stopped state of a user you can use this in conjunction with
2910     * {@link #ACTION_USER_STOPPING}.  It is <b>not</b> generally safe to use with
2911     * other user state broadcasts since those are foreground broadcasts so can
2912     * execute in a different order.
2913     * @hide
2914     */
2915    public static final String ACTION_USER_STARTING =
2916            "android.intent.action.USER_STARTING";
2917
2918    /**
2919     * Broadcast sent when a user is going to be stopped.  Carries an extra
2920     * EXTRA_USER_HANDLE that has the userHandle of the user.  This is only
2921     * sent to registered receivers, not manifest receivers.  It is sent to all
2922     * users (including the one that is being stopped).  You must hold
2923     * {@link android.Manifest.permission#INTERACT_ACROSS_USERS} to receive
2924     * this broadcast.  The user will not stop until all receivers have
2925     * handled the broadcast.  This is sent as a background broadcast, since
2926     * its result is not part of the primary UX flow; to safely keep track of
2927     * started/stopped state of a user you can use this in conjunction with
2928     * {@link #ACTION_USER_STARTING}.  It is <b>not</b> generally safe to use with
2929     * other user state broadcasts since those are foreground broadcasts so can
2930     * execute in a different order.
2931     * @hide
2932     */
2933    public static final String ACTION_USER_STOPPING =
2934            "android.intent.action.USER_STOPPING";
2935
2936    /**
2937     * Broadcast sent to the system when a user is stopped. Carries an extra
2938     * EXTRA_USER_HANDLE that has the userHandle of the user.  This is similar to
2939     * {@link #ACTION_PACKAGE_RESTARTED}, but for an entire user instead of a
2940     * specific package.  This is only sent to registered receivers, not manifest
2941     * receivers.  It is sent to all running users <em>except</em> the one that
2942     * has just been stopped (which is no longer running).
2943     * @hide
2944     */
2945    public static final String ACTION_USER_STOPPED =
2946            "android.intent.action.USER_STOPPED";
2947
2948    /**
2949     * Broadcast sent to the system when a user is removed. Carries an extra EXTRA_USER_HANDLE that has
2950     * the userHandle of the user.  It is sent to all running users except the
2951     * one that has been removed. The user will not be completely removed until all receivers have
2952     * handled the broadcast. You must hold
2953     * {@link android.Manifest.permission#MANAGE_USERS} to receive this broadcast.
2954     * @hide
2955     */
2956    public static final String ACTION_USER_REMOVED =
2957            "android.intent.action.USER_REMOVED";
2958
2959    /**
2960     * Broadcast sent to the system when the user switches. Carries an extra EXTRA_USER_HANDLE that has
2961     * the userHandle of the user to become the current one. This is only sent to
2962     * registered receivers, not manifest receivers.  It is sent to all running users.
2963     * You must hold
2964     * {@link android.Manifest.permission#MANAGE_USERS} to receive this broadcast.
2965     * @hide
2966     */
2967    public static final String ACTION_USER_SWITCHED =
2968            "android.intent.action.USER_SWITCHED";
2969
2970    /**
2971     * Broadcast Action: Sent when the credential-encrypted private storage has
2972     * become unlocked for the target user. This is only sent to registered
2973     * receivers, not manifest receivers.
2974     */
2975    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2976    public static final String ACTION_USER_UNLOCKED = "android.intent.action.USER_UNLOCKED";
2977
2978    /**
2979     * Broadcast sent to the system when a user's information changes. Carries an extra
2980     * {@link #EXTRA_USER_HANDLE} to indicate which user's information changed.
2981     * This is only sent to registered receivers, not manifest receivers. It is sent to all users.
2982     * @hide
2983     */
2984    public static final String ACTION_USER_INFO_CHANGED =
2985            "android.intent.action.USER_INFO_CHANGED";
2986
2987    /**
2988     * Broadcast sent to the primary user when an associated managed profile is added (the profile
2989     * was created and is ready to be used). Carries an extra {@link #EXTRA_USER} that specifies
2990     * the UserHandle of the profile that was added. Only applications (for example Launchers)
2991     * that need to display merged content across both primary and managed profiles need to
2992     * worry about this broadcast. This is only sent to registered receivers,
2993     * not manifest receivers.
2994     */
2995    public static final String ACTION_MANAGED_PROFILE_ADDED =
2996            "android.intent.action.MANAGED_PROFILE_ADDED";
2997
2998    /**
2999     * Broadcast sent to the primary user when an associated managed profile is removed. Carries an
3000     * extra {@link #EXTRA_USER} that specifies the UserHandle of the profile that was removed.
3001     * Only applications (for example Launchers) that need to display merged content across both
3002     * primary and managed profiles need to worry about this broadcast. This is only sent to
3003     * registered receivers, not manifest receivers.
3004     */
3005    public static final String ACTION_MANAGED_PROFILE_REMOVED =
3006            "android.intent.action.MANAGED_PROFILE_REMOVED";
3007
3008    /**
3009     * Broadcast sent to the primary user when the credential-encrypted private storage for
3010     * an associated managed profile is unlocked. Carries an extra {@link #EXTRA_USER} that
3011     * specifies the UserHandle of the profile that was unlocked. Only applications (for example
3012     * Launchers) that need to display merged content across both primary and managed profiles
3013     * need to worry about this broadcast. This is only sent to registered receivers,
3014     * not manifest receivers.
3015     */
3016    public static final String ACTION_MANAGED_PROFILE_UNLOCKED =
3017            "android.intent.action.MANAGED_PROFILE_UNLOCKED";
3018
3019    /**
3020     * Broadcast sent to the primary user when an associated managed profile has become available.
3021     * Currently this includes when the user disables quiet mode for the profile. Carries an extra
3022     * {@link #EXTRA_USER} that specifies the UserHandle of the profile. When quiet mode is changed,
3023     * this broadcast will carry a boolean extra {@link #EXTRA_QUIET_MODE} indicating the new state
3024     * of quiet mode. This is only sent to registered receivers, not manifest receivers.
3025     */
3026    public static final String ACTION_MANAGED_PROFILE_AVAILABLE =
3027            "android.intent.action.MANAGED_PROFILE_AVAILABLE";
3028
3029    /**
3030     * Broadcast sent to the primary user when an associated managed profile has become unavailable.
3031     * Currently this includes when the user enables quiet mode for the profile. Carries an extra
3032     * {@link #EXTRA_USER} that specifies the UserHandle of the profile. When quiet mode is changed,
3033     * this broadcast will carry a boolean extra {@link #EXTRA_QUIET_MODE} indicating the new state
3034     * of quiet mode. This is only sent to registered receivers, not manifest receivers.
3035     */
3036    public static final String ACTION_MANAGED_PROFILE_UNAVAILABLE =
3037            "android.intent.action.MANAGED_PROFILE_UNAVAILABLE";
3038
3039    /**
3040     * Sent when the user taps on the clock widget in the system's "quick settings" area.
3041     */
3042    public static final String ACTION_QUICK_CLOCK =
3043            "android.intent.action.QUICK_CLOCK";
3044
3045    /**
3046     * Activity Action: Shows the brightness setting dialog.
3047     * @hide
3048     */
3049    public static final String ACTION_SHOW_BRIGHTNESS_DIALOG =
3050            "android.intent.action.SHOW_BRIGHTNESS_DIALOG";
3051
3052    /**
3053     * Broadcast Action:  A global button was pressed.  Includes a single
3054     * extra field, {@link #EXTRA_KEY_EVENT}, containing the key event that
3055     * caused the broadcast.
3056     * @hide
3057     */
3058    public static final String ACTION_GLOBAL_BUTTON = "android.intent.action.GLOBAL_BUTTON";
3059
3060    /**
3061     * Broadcast Action: Sent when media resource is granted.
3062     * <p>
3063     * {@link #EXTRA_PACKAGES} specifies the packages on the process holding the media resource
3064     * granted.
3065     * </p>
3066     * <p class="note">
3067     * This is a protected intent that can only be sent by the system.
3068     * </p>
3069     * <p class="note">
3070     * This requires {@link android.Manifest.permission#RECEIVE_MEDIA_RESOURCE_USAGE} permission.
3071     * </p>
3072     *
3073     * @hide
3074     */
3075    public static final String ACTION_MEDIA_RESOURCE_GRANTED =
3076            "android.intent.action.MEDIA_RESOURCE_GRANTED";
3077
3078    /**
3079     * Activity Action: Allow the user to select and return one or more existing
3080     * documents. When invoked, the system will display the various
3081     * {@link DocumentsProvider} instances installed on the device, letting the
3082     * user interactively navigate through them. These documents include local
3083     * media, such as photos and video, and documents provided by installed
3084     * cloud storage providers.
3085     * <p>
3086     * Each document is represented as a {@code content://} URI backed by a
3087     * {@link DocumentsProvider}, which can be opened as a stream with
3088     * {@link ContentResolver#openFileDescriptor(Uri, String)}, or queried for
3089     * {@link android.provider.DocumentsContract.Document} metadata.
3090     * <p>
3091     * All selected documents are returned to the calling application with
3092     * persistable read and write permission grants. If you want to maintain
3093     * access to the documents across device reboots, you need to explicitly
3094     * take the persistable permissions using
3095     * {@link ContentResolver#takePersistableUriPermission(Uri, int)}.
3096     * <p>
3097     * Callers must indicate the acceptable document MIME types through
3098     * {@link #setType(String)}. For example, to select photos, use
3099     * {@code image/*}. If multiple disjoint MIME types are acceptable, define
3100     * them in {@link #EXTRA_MIME_TYPES} and {@link #setType(String)} to
3101     * {@literal *}/*.
3102     * <p>
3103     * If the caller can handle multiple returned items (the user performing
3104     * multiple selection), then you can specify {@link #EXTRA_ALLOW_MULTIPLE}
3105     * to indicate this.
3106     * <p>
3107     * Callers must include {@link #CATEGORY_OPENABLE} in the Intent to obtain
3108     * URIs that can be opened with
3109     * {@link ContentResolver#openFileDescriptor(Uri, String)}.
3110     * <p>
3111     * Output: The URI of the item that was picked, returned in
3112     * {@link #getData()}. This must be a {@code content://} URI so that any
3113     * receiver can access it. If multiple documents were selected, they are
3114     * returned in {@link #getClipData()}.
3115     *
3116     * @see DocumentsContract
3117     * @see #ACTION_OPEN_DOCUMENT_TREE
3118     * @see #ACTION_CREATE_DOCUMENT
3119     * @see #FLAG_GRANT_PERSISTABLE_URI_PERMISSION
3120     */
3121    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
3122    public static final String ACTION_OPEN_DOCUMENT = "android.intent.action.OPEN_DOCUMENT";
3123
3124    /**
3125     * Activity Action: Allow the user to create a new document. When invoked,
3126     * the system will display the various {@link DocumentsProvider} instances
3127     * installed on the device, letting the user navigate through them. The
3128     * returned document may be a newly created document with no content, or it
3129     * may be an existing document with the requested MIME type.
3130     * <p>
3131     * Each document is represented as a {@code content://} URI backed by a
3132     * {@link DocumentsProvider}, which can be opened as a stream with
3133     * {@link ContentResolver#openFileDescriptor(Uri, String)}, or queried for
3134     * {@link android.provider.DocumentsContract.Document} metadata.
3135     * <p>
3136     * Callers must indicate the concrete MIME type of the document being
3137     * created by setting {@link #setType(String)}. This MIME type cannot be
3138     * changed after the document is created.
3139     * <p>
3140     * Callers can provide an initial display name through {@link #EXTRA_TITLE},
3141     * but the user may change this value before creating the file.
3142     * <p>
3143     * Callers must include {@link #CATEGORY_OPENABLE} in the Intent to obtain
3144     * URIs that can be opened with
3145     * {@link ContentResolver#openFileDescriptor(Uri, String)}.
3146     * <p>
3147     * Output: The URI of the item that was created. This must be a
3148     * {@code content://} URI so that any receiver can access it.
3149     *
3150     * @see DocumentsContract
3151     * @see #ACTION_OPEN_DOCUMENT
3152     * @see #ACTION_OPEN_DOCUMENT_TREE
3153     * @see #FLAG_GRANT_PERSISTABLE_URI_PERMISSION
3154     */
3155    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
3156    public static final String ACTION_CREATE_DOCUMENT = "android.intent.action.CREATE_DOCUMENT";
3157
3158    /**
3159     * Activity Action: Allow the user to pick a directory subtree. When
3160     * invoked, the system will display the various {@link DocumentsProvider}
3161     * instances installed on the device, letting the user navigate through
3162     * them. Apps can fully manage documents within the returned directory.
3163     * <p>
3164     * To gain access to descendant (child, grandchild, etc) documents, use
3165     * {@link DocumentsContract#buildDocumentUriUsingTree(Uri, String)} and
3166     * {@link DocumentsContract#buildChildDocumentsUriUsingTree(Uri, String)}
3167     * with the returned URI.
3168     * <p>
3169     * Output: The URI representing the selected directory tree.
3170     *
3171     * @see DocumentsContract
3172     */
3173    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
3174    public static final String
3175            ACTION_OPEN_DOCUMENT_TREE = "android.intent.action.OPEN_DOCUMENT_TREE";
3176
3177    /**
3178     * Broadcast Action: List of dynamic sensor is changed due to new sensor being connected or
3179     * exisiting sensor being disconnected.
3180     *
3181     * <p class="note">This is a protected intent that can only be sent by the system.</p>
3182     *
3183     * {@hide}
3184     */
3185    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
3186    public static final String
3187            ACTION_DYNAMIC_SENSOR_CHANGED = "android.intent.action.DYNAMIC_SENSOR_CHANGED";
3188
3189    /** {@hide} */
3190    public static final String ACTION_MASTER_CLEAR = "android.intent.action.MASTER_CLEAR";
3191
3192    /**
3193     * Boolean intent extra to be used with {@link ACTION_MASTER_CLEAR} in order to force a factory
3194     * reset even if {@link android.os.UserManager.DISALLOW_FACTORY_RESET} is set.
3195     * @hide
3196     */
3197    public static final String EXTRA_FORCE_MASTER_CLEAR =
3198            "android.intent.extra.FORCE_MASTER_CLEAR";
3199
3200    /**
3201     * Broadcast action: report that a settings element is being restored from backup.  The intent
3202     * contains three extras: EXTRA_SETTING_NAME is a string naming the restored setting,
3203     * EXTRA_SETTING_NEW_VALUE is the value being restored, and EXTRA_SETTING_PREVIOUS_VALUE
3204     * is the value of that settings entry prior to the restore operation.  All of these values are
3205     * represented as strings.
3206     *
3207     * <p>This broadcast is sent only for settings provider entries known to require special handling
3208     * around restore time.  These entries are found in the BROADCAST_ON_RESTORE table within
3209     * the provider's backup agent implementation.
3210     *
3211     * @see #EXTRA_SETTING_NAME
3212     * @see #EXTRA_SETTING_PREVIOUS_VALUE
3213     * @see #EXTRA_SETTING_NEW_VALUE
3214     * {@hide}
3215     */
3216    public static final String ACTION_SETTING_RESTORED = "android.os.action.SETTING_RESTORED";
3217
3218    /** {@hide} */
3219    public static final String EXTRA_SETTING_NAME = "setting_name";
3220    /** {@hide} */
3221    public static final String EXTRA_SETTING_PREVIOUS_VALUE = "previous_value";
3222    /** {@hide} */
3223    public static final String EXTRA_SETTING_NEW_VALUE = "new_value";
3224
3225    /**
3226     * Activity Action: Process a piece of text.
3227     * <p>Input: {@link #EXTRA_PROCESS_TEXT} contains the text to be processed.
3228     * {@link #EXTRA_PROCESS_TEXT_READONLY} states if the resulting text will be read-only.</p>
3229     * <p>Output: {@link #EXTRA_PROCESS_TEXT} contains the processed text.</p>
3230     */
3231    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
3232    public static final String ACTION_PROCESS_TEXT = "android.intent.action.PROCESS_TEXT";
3233    /**
3234     * The name of the extra used to define the text to be processed, as a
3235     * CharSequence. Note that this may be a styled CharSequence, so you must use
3236     * {@link Bundle#getCharSequence(String) Bundle.getCharSequence()} to retrieve it.
3237     */
3238    public static final String EXTRA_PROCESS_TEXT = "android.intent.extra.PROCESS_TEXT";
3239    /**
3240     * The name of the boolean extra used to define if the processed text will be used as read-only.
3241     */
3242    public static final String EXTRA_PROCESS_TEXT_READONLY =
3243            "android.intent.extra.PROCESS_TEXT_READONLY";
3244
3245    /**
3246     * Broadcast action: reports when a new thermal event has been reached. When the device
3247     * is reaching its maximum temperatue, the thermal level reported
3248     * {@hide}
3249     */
3250    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
3251    public static final String ACTION_THERMAL_EVENT = "android.intent.action.THERMAL_EVENT";
3252
3253    /** {@hide} */
3254    public static final String EXTRA_THERMAL_STATE = "android.intent.extra.THERMAL_STATE";
3255
3256    /**
3257     * Thermal state when the device is normal. This state is sent in the
3258     * {@link #ACTION_THERMAL_EVENT} broadcast as {@link #EXTRA_THERMAL_STATE}.
3259     * {@hide}
3260     */
3261    public static final int EXTRA_THERMAL_STATE_NORMAL = 0;
3262
3263    /**
3264     * Thermal state where the device is approaching its maximum threshold. This state is sent in
3265     * the {@link #ACTION_THERMAL_EVENT} broadcast as {@link #EXTRA_THERMAL_STATE}.
3266     * {@hide}
3267     */
3268    public static final int EXTRA_THERMAL_STATE_WARNING = 1;
3269
3270    /**
3271     * Thermal state where the device has reached its maximum threshold. This state is sent in the
3272     * {@link #ACTION_THERMAL_EVENT} broadcast as {@link #EXTRA_THERMAL_STATE}.
3273     * {@hide}
3274     */
3275    public static final int EXTRA_THERMAL_STATE_EXCEEDED = 2;
3276
3277
3278    // ---------------------------------------------------------------------
3279    // ---------------------------------------------------------------------
3280    // Standard intent categories (see addCategory()).
3281
3282    /**
3283     * Set if the activity should be an option for the default action
3284     * (center press) to perform on a piece of data.  Setting this will
3285     * hide from the user any activities without it set when performing an
3286     * action on some data.  Note that this is normally -not- set in the
3287     * Intent when initiating an action -- it is for use in intent filters
3288     * specified in packages.
3289     */
3290    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3291    public static final String CATEGORY_DEFAULT = "android.intent.category.DEFAULT";
3292    /**
3293     * Activities that can be safely invoked from a browser must support this
3294     * category.  For example, if the user is viewing a web page or an e-mail
3295     * and clicks on a link in the text, the Intent generated execute that
3296     * link will require the BROWSABLE category, so that only activities
3297     * supporting this category will be considered as possible actions.  By
3298     * supporting this category, you are promising that there is nothing
3299     * damaging (without user intervention) that can happen by invoking any
3300     * matching Intent.
3301     */
3302    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3303    public static final String CATEGORY_BROWSABLE = "android.intent.category.BROWSABLE";
3304    /**
3305     * Categories for activities that can participate in voice interaction.
3306     * An activity that supports this category must be prepared to run with
3307     * no UI shown at all (though in some case it may have a UI shown), and
3308     * rely on {@link android.app.VoiceInteractor} to interact with the user.
3309     */
3310    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3311    public static final String CATEGORY_VOICE = "android.intent.category.VOICE";
3312    /**
3313     * Set if the activity should be considered as an alternative action to
3314     * the data the user is currently viewing.  See also
3315     * {@link #CATEGORY_SELECTED_ALTERNATIVE} for an alternative action that
3316     * applies to the selection in a list of items.
3317     *
3318     * <p>Supporting this category means that you would like your activity to be
3319     * displayed in the set of alternative things the user can do, usually as
3320     * part of the current activity's options menu.  You will usually want to
3321     * include a specific label in the &lt;intent-filter&gt; of this action
3322     * describing to the user what it does.
3323     *
3324     * <p>The action of IntentFilter with this category is important in that it
3325     * describes the specific action the target will perform.  This generally
3326     * should not be a generic action (such as {@link #ACTION_VIEW}, but rather
3327     * a specific name such as "com.android.camera.action.CROP.  Only one
3328     * alternative of any particular action will be shown to the user, so using
3329     * a specific action like this makes sure that your alternative will be
3330     * displayed while also allowing other applications to provide their own
3331     * overrides of that particular action.
3332     */
3333    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3334    public static final String CATEGORY_ALTERNATIVE = "android.intent.category.ALTERNATIVE";
3335    /**
3336     * Set if the activity should be considered as an alternative selection
3337     * action to the data the user has currently selected.  This is like
3338     * {@link #CATEGORY_ALTERNATIVE}, but is used in activities showing a list
3339     * of items from which the user can select, giving them alternatives to the
3340     * default action that will be performed on it.
3341     */
3342    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3343    public static final String CATEGORY_SELECTED_ALTERNATIVE = "android.intent.category.SELECTED_ALTERNATIVE";
3344    /**
3345     * Intended to be used as a tab inside of a containing TabActivity.
3346     */
3347    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3348    public static final String CATEGORY_TAB = "android.intent.category.TAB";
3349    /**
3350     * Should be displayed in the top-level launcher.
3351     */
3352    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3353    public static final String CATEGORY_LAUNCHER = "android.intent.category.LAUNCHER";
3354    /**
3355     * Indicates an activity optimized for Leanback mode, and that should
3356     * be displayed in the Leanback launcher.
3357     */
3358    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3359    public static final String CATEGORY_LEANBACK_LAUNCHER = "android.intent.category.LEANBACK_LAUNCHER";
3360    /**
3361     * Indicates a Leanback settings activity to be displayed in the Leanback launcher.
3362     * @hide
3363     */
3364    @SystemApi
3365    public static final String CATEGORY_LEANBACK_SETTINGS = "android.intent.category.LEANBACK_SETTINGS";
3366    /**
3367     * Provides information about the package it is in; typically used if
3368     * a package does not contain a {@link #CATEGORY_LAUNCHER} to provide
3369     * a front-door to the user without having to be shown in the all apps list.
3370     */
3371    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3372    public static final String CATEGORY_INFO = "android.intent.category.INFO";
3373    /**
3374     * This is the home activity, that is the first activity that is displayed
3375     * when the device boots.
3376     */
3377    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3378    public static final String CATEGORY_HOME = "android.intent.category.HOME";
3379    /**
3380     * This is the home activity that is displayed when the device is finished setting up and ready
3381     * for use.
3382     * @hide
3383     */
3384    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3385    public static final String CATEGORY_HOME_MAIN = "android.intent.category.HOME_MAIN";
3386    /**
3387     * This is the setup wizard activity, that is the first activity that is displayed
3388     * when the user sets up the device for the first time.
3389     * @hide
3390     */
3391    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3392    public static final String CATEGORY_SETUP_WIZARD = "android.intent.category.SETUP_WIZARD";
3393    /**
3394     * This activity is a preference panel.
3395     */
3396    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3397    public static final String CATEGORY_PREFERENCE = "android.intent.category.PREFERENCE";
3398    /**
3399     * This activity is a development preference panel.
3400     */
3401    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3402    public static final String CATEGORY_DEVELOPMENT_PREFERENCE = "android.intent.category.DEVELOPMENT_PREFERENCE";
3403    /**
3404     * Capable of running inside a parent activity container.
3405     */
3406    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3407    public static final String CATEGORY_EMBED = "android.intent.category.EMBED";
3408    /**
3409     * This activity allows the user to browse and download new applications.
3410     */
3411    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3412    public static final String CATEGORY_APP_MARKET = "android.intent.category.APP_MARKET";
3413    /**
3414     * This activity may be exercised by the monkey or other automated test tools.
3415     */
3416    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3417    public static final String CATEGORY_MONKEY = "android.intent.category.MONKEY";
3418    /**
3419     * To be used as a test (not part of the normal user experience).
3420     */
3421    public static final String CATEGORY_TEST = "android.intent.category.TEST";
3422    /**
3423     * To be used as a unit test (run through the Test Harness).
3424     */
3425    public static final String CATEGORY_UNIT_TEST = "android.intent.category.UNIT_TEST";
3426    /**
3427     * To be used as a sample code example (not part of the normal user
3428     * experience).
3429     */
3430    public static final String CATEGORY_SAMPLE_CODE = "android.intent.category.SAMPLE_CODE";
3431
3432    /**
3433     * Used to indicate that an intent only wants URIs that can be opened with
3434     * {@link ContentResolver#openFileDescriptor(Uri, String)}. Openable URIs
3435     * must support at least the columns defined in {@link OpenableColumns} when
3436     * queried.
3437     *
3438     * @see #ACTION_GET_CONTENT
3439     * @see #ACTION_OPEN_DOCUMENT
3440     * @see #ACTION_CREATE_DOCUMENT
3441     */
3442    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3443    public static final String CATEGORY_OPENABLE = "android.intent.category.OPENABLE";
3444
3445    /**
3446     * To be used as code under test for framework instrumentation tests.
3447     */
3448    public static final String CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST =
3449            "android.intent.category.FRAMEWORK_INSTRUMENTATION_TEST";
3450    /**
3451     * An activity to run when device is inserted into a car dock.
3452     * Used with {@link #ACTION_MAIN} to launch an activity.  For more
3453     * information, see {@link android.app.UiModeManager}.
3454     */
3455    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3456    public static final String CATEGORY_CAR_DOCK = "android.intent.category.CAR_DOCK";
3457    /**
3458     * An activity to run when device is inserted into a car dock.
3459     * Used with {@link #ACTION_MAIN} to launch an activity.  For more
3460     * information, see {@link android.app.UiModeManager}.
3461     */
3462    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3463    public static final String CATEGORY_DESK_DOCK = "android.intent.category.DESK_DOCK";
3464    /**
3465     * An activity to run when device is inserted into a analog (low end) dock.
3466     * Used with {@link #ACTION_MAIN} to launch an activity.  For more
3467     * information, see {@link android.app.UiModeManager}.
3468     */
3469    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3470    public static final String CATEGORY_LE_DESK_DOCK = "android.intent.category.LE_DESK_DOCK";
3471
3472    /**
3473     * An activity to run when device is inserted into a digital (high end) dock.
3474     * Used with {@link #ACTION_MAIN} to launch an activity.  For more
3475     * information, see {@link android.app.UiModeManager}.
3476     */
3477    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3478    public static final String CATEGORY_HE_DESK_DOCK = "android.intent.category.HE_DESK_DOCK";
3479
3480    /**
3481     * Used to indicate that the activity can be used in a car environment.
3482     */
3483    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3484    public static final String CATEGORY_CAR_MODE = "android.intent.category.CAR_MODE";
3485
3486    // ---------------------------------------------------------------------
3487    // ---------------------------------------------------------------------
3488    // Application launch intent categories (see addCategory()).
3489
3490    /**
3491     * Used with {@link #ACTION_MAIN} to launch the browser application.
3492     * The activity should be able to browse the Internet.
3493     * <p>NOTE: This should not be used as the primary key of an Intent,
3494     * since it will not result in the app launching with the correct
3495     * action and category.  Instead, use this with
3496     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3497     * Intent with this category in the selector.</p>
3498     */
3499    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3500    public static final String CATEGORY_APP_BROWSER = "android.intent.category.APP_BROWSER";
3501
3502    /**
3503     * Used with {@link #ACTION_MAIN} to launch the calculator application.
3504     * The activity should be able to perform standard arithmetic operations.
3505     * <p>NOTE: This should not be used as the primary key of an Intent,
3506     * since it will not result in the app launching with the correct
3507     * action and category.  Instead, use this with
3508     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3509     * Intent with this category in the selector.</p>
3510     */
3511    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3512    public static final String CATEGORY_APP_CALCULATOR = "android.intent.category.APP_CALCULATOR";
3513
3514    /**
3515     * Used with {@link #ACTION_MAIN} to launch the calendar application.
3516     * The activity should be able to view and manipulate calendar entries.
3517     * <p>NOTE: This should not be used as the primary key of an Intent,
3518     * since it will not result in the app launching with the correct
3519     * action and category.  Instead, use this with
3520     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3521     * Intent with this category in the selector.</p>
3522     */
3523    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3524    public static final String CATEGORY_APP_CALENDAR = "android.intent.category.APP_CALENDAR";
3525
3526    /**
3527     * Used with {@link #ACTION_MAIN} to launch the contacts application.
3528     * The activity should be able to view and manipulate address book entries.
3529     * <p>NOTE: This should not be used as the primary key of an Intent,
3530     * since it will not result in the app launching with the correct
3531     * action and category.  Instead, use this with
3532     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3533     * Intent with this category in the selector.</p>
3534     */
3535    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3536    public static final String CATEGORY_APP_CONTACTS = "android.intent.category.APP_CONTACTS";
3537
3538    /**
3539     * Used with {@link #ACTION_MAIN} to launch the email application.
3540     * The activity should be able to send and receive email.
3541     * <p>NOTE: This should not be used as the primary key of an Intent,
3542     * since it will not result in the app launching with the correct
3543     * action and category.  Instead, use this with
3544     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3545     * Intent with this category in the selector.</p>
3546     */
3547    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3548    public static final String CATEGORY_APP_EMAIL = "android.intent.category.APP_EMAIL";
3549
3550    /**
3551     * Used with {@link #ACTION_MAIN} to launch the gallery application.
3552     * The activity should be able to view and manipulate image and video files
3553     * stored on the device.
3554     * <p>NOTE: This should not be used as the primary key of an Intent,
3555     * since it will not result in the app launching with the correct
3556     * action and category.  Instead, use this with
3557     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3558     * Intent with this category in the selector.</p>
3559     */
3560    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3561    public static final String CATEGORY_APP_GALLERY = "android.intent.category.APP_GALLERY";
3562
3563    /**
3564     * Used with {@link #ACTION_MAIN} to launch the maps application.
3565     * The activity should be able to show the user's current location and surroundings.
3566     * <p>NOTE: This should not be used as the primary key of an Intent,
3567     * since it will not result in the app launching with the correct
3568     * action and category.  Instead, use this with
3569     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3570     * Intent with this category in the selector.</p>
3571     */
3572    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3573    public static final String CATEGORY_APP_MAPS = "android.intent.category.APP_MAPS";
3574
3575    /**
3576     * Used with {@link #ACTION_MAIN} to launch the messaging application.
3577     * The activity should be able to send and receive text messages.
3578     * <p>NOTE: This should not be used as the primary key of an Intent,
3579     * since it will not result in the app launching with the correct
3580     * action and category.  Instead, use this with
3581     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3582     * Intent with this category in the selector.</p>
3583     */
3584    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3585    public static final String CATEGORY_APP_MESSAGING = "android.intent.category.APP_MESSAGING";
3586
3587    /**
3588     * Used with {@link #ACTION_MAIN} to launch the music application.
3589     * The activity should be able to play, browse, or manipulate music files
3590     * stored on the device.
3591     * <p>NOTE: This should not be used as the primary key of an Intent,
3592     * since it will not result in the app launching with the correct
3593     * action and category.  Instead, use this with
3594     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3595     * Intent with this category in the selector.</p>
3596     */
3597    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3598    public static final String CATEGORY_APP_MUSIC = "android.intent.category.APP_MUSIC";
3599
3600    // ---------------------------------------------------------------------
3601    // ---------------------------------------------------------------------
3602    // Standard extra data keys.
3603
3604    /**
3605     * The initial data to place in a newly created record.  Use with
3606     * {@link #ACTION_INSERT}.  The data here is a Map containing the same
3607     * fields as would be given to the underlying ContentProvider.insert()
3608     * call.
3609     */
3610    public static final String EXTRA_TEMPLATE = "android.intent.extra.TEMPLATE";
3611
3612    /**
3613     * A constant CharSequence that is associated with the Intent, used with
3614     * {@link #ACTION_SEND} to supply the literal data to be sent.  Note that
3615     * this may be a styled CharSequence, so you must use
3616     * {@link Bundle#getCharSequence(String) Bundle.getCharSequence()} to
3617     * retrieve it.
3618     */
3619    public static final String EXTRA_TEXT = "android.intent.extra.TEXT";
3620
3621    /**
3622     * A constant String that is associated with the Intent, used with
3623     * {@link #ACTION_SEND} to supply an alternative to {@link #EXTRA_TEXT}
3624     * as HTML formatted text.  Note that you <em>must</em> also supply
3625     * {@link #EXTRA_TEXT}.
3626     */
3627    public static final String EXTRA_HTML_TEXT = "android.intent.extra.HTML_TEXT";
3628
3629    /**
3630     * A content: URI holding a stream of data associated with the Intent,
3631     * used with {@link #ACTION_SEND} to supply the data being sent.
3632     */
3633    public static final String EXTRA_STREAM = "android.intent.extra.STREAM";
3634
3635    /**
3636     * A String[] holding e-mail addresses that should be delivered to.
3637     */
3638    public static final String EXTRA_EMAIL       = "android.intent.extra.EMAIL";
3639
3640    /**
3641     * A String[] holding e-mail addresses that should be carbon copied.
3642     */
3643    public static final String EXTRA_CC       = "android.intent.extra.CC";
3644
3645    /**
3646     * A String[] holding e-mail addresses that should be blind carbon copied.
3647     */
3648    public static final String EXTRA_BCC      = "android.intent.extra.BCC";
3649
3650    /**
3651     * A constant string holding the desired subject line of a message.
3652     */
3653    public static final String EXTRA_SUBJECT  = "android.intent.extra.SUBJECT";
3654
3655    /**
3656     * An Intent describing the choices you would like shown with
3657     * {@link #ACTION_PICK_ACTIVITY} or {@link #ACTION_CHOOSER}.
3658     */
3659    public static final String EXTRA_INTENT = "android.intent.extra.INTENT";
3660
3661    /**
3662     * An int representing the user id to be used.
3663     *
3664     * @hide
3665     */
3666    public static final String EXTRA_USER_ID = "android.intent.extra.USER_ID";
3667
3668    /**
3669     * An int representing the task id to be retrieved. This is used when a launch from recents is
3670     * intercepted by another action such as credentials confirmation to remember which task should
3671     * be resumed when complete.
3672     *
3673     * @hide
3674     */
3675    public static final String EXTRA_TASK_ID = "android.intent.extra.TASK_ID";
3676
3677    /**
3678     * An Intent[] describing additional, alternate choices you would like shown with
3679     * {@link #ACTION_CHOOSER}.
3680     *
3681     * <p>An app may be capable of providing several different payload types to complete a
3682     * user's intended action. For example, an app invoking {@link #ACTION_SEND} to share photos
3683     * with another app may use EXTRA_ALTERNATE_INTENTS to have the chooser transparently offer
3684     * several different supported sending mechanisms for sharing, such as the actual "image/*"
3685     * photo data or a hosted link where the photos can be viewed.</p>
3686     *
3687     * <p>The intent present in {@link #EXTRA_INTENT} will be treated as the
3688     * first/primary/preferred intent in the set. Additional intents specified in
3689     * this extra are ordered; by default intents that appear earlier in the array will be
3690     * preferred over intents that appear later in the array as matches for the same
3691     * target component. To alter this preference, a calling app may also supply
3692     * {@link #EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER}.</p>
3693     */
3694    public static final String EXTRA_ALTERNATE_INTENTS = "android.intent.extra.ALTERNATE_INTENTS";
3695
3696    /**
3697     * A {@link ComponentName ComponentName[]} describing components that should be filtered out
3698     * and omitted from a list of components presented to the user.
3699     *
3700     * <p>When used with {@link #ACTION_CHOOSER}, the chooser will omit any of the components
3701     * in this array if it otherwise would have shown them. Useful for omitting specific targets
3702     * from your own package or other apps from your organization if the idea of sending to those
3703     * targets would be redundant with other app functionality. Filtered components will not
3704     * be able to present targets from an associated <code>ChooserTargetService</code>.</p>
3705     */
3706    public static final String EXTRA_EXCLUDE_COMPONENTS
3707            = "android.intent.extra.EXCLUDE_COMPONENTS";
3708
3709    /**
3710     * A {@link android.service.chooser.ChooserTarget ChooserTarget[]} for {@link #ACTION_CHOOSER}
3711     * describing additional high-priority deep-link targets for the chooser to present to the user.
3712     *
3713     * <p>Targets provided in this way will be presented inline with all other targets provided
3714     * by services from other apps. They will be prioritized before other service targets, but
3715     * after those targets provided by sources that the user has manually pinned to the front.</p>
3716     *
3717     * @see #ACTION_CHOOSER
3718     */
3719    public static final String EXTRA_CHOOSER_TARGETS = "android.intent.extra.CHOOSER_TARGETS";
3720
3721    /**
3722     * An {@link IntentSender} for an Activity that will be invoked when the user makes a selection
3723     * from the chooser activity presented by {@link #ACTION_CHOOSER}.
3724     *
3725     * <p>An app preparing an action for another app to complete may wish to allow the user to
3726     * disambiguate between several options for completing the action based on the chosen target
3727     * or otherwise refine the action before it is invoked.
3728     * </p>
3729     *
3730     * <p>When sent, this IntentSender may be filled in with the following extras:</p>
3731     * <ul>
3732     *     <li>{@link #EXTRA_INTENT} The first intent that matched the user's chosen target</li>
3733     *     <li>{@link #EXTRA_ALTERNATE_INTENTS} Any additional intents that also matched the user's
3734     *     chosen target beyond the first</li>
3735     *     <li>{@link #EXTRA_RESULT_RECEIVER} A {@link ResultReceiver} that the refinement activity
3736     *     should fill in and send once the disambiguation is complete</li>
3737     * </ul>
3738     */
3739    public static final String EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER
3740            = "android.intent.extra.CHOOSER_REFINEMENT_INTENT_SENDER";
3741
3742    /**
3743     * A {@link ResultReceiver} used to return data back to the sender.
3744     *
3745     * <p>Used to complete an app-specific
3746     * {@link #EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER refinement} for {@link #ACTION_CHOOSER}.</p>
3747     *
3748     * <p>If {@link #EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER} is present in the intent
3749     * used to start a {@link #ACTION_CHOOSER} activity this extra will be
3750     * {@link #fillIn(Intent, int) filled in} to that {@link IntentSender} and sent
3751     * when the user selects a target component from the chooser. It is up to the recipient
3752     * to send a result to this ResultReceiver to signal that disambiguation is complete
3753     * and that the chooser should invoke the user's choice.</p>
3754     *
3755     * <p>The disambiguator should provide a Bundle to the ResultReceiver with an intent
3756     * assigned to the key {@link #EXTRA_INTENT}. This supplied intent will be used by the chooser
3757     * to match and fill in the final Intent or ChooserTarget before starting it.
3758     * The supplied intent must {@link #filterEquals(Intent) match} one of the intents from
3759     * {@link #EXTRA_INTENT} or {@link #EXTRA_ALTERNATE_INTENTS} passed to
3760     * {@link #EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER} to be accepted.</p>
3761     *
3762     * <p>The result code passed to the ResultReceiver should be
3763     * {@link android.app.Activity#RESULT_OK} if the refinement succeeded and the supplied intent's
3764     * target in the chooser should be started, or {@link android.app.Activity#RESULT_CANCELED} if
3765     * the chooser should finish without starting a target.</p>
3766     */
3767    public static final String EXTRA_RESULT_RECEIVER
3768            = "android.intent.extra.RESULT_RECEIVER";
3769
3770    /**
3771     * A CharSequence dialog title to provide to the user when used with a
3772     * {@link #ACTION_CHOOSER}.
3773     */
3774    public static final String EXTRA_TITLE = "android.intent.extra.TITLE";
3775
3776    /**
3777     * A Parcelable[] of {@link Intent} or
3778     * {@link android.content.pm.LabeledIntent} objects as set with
3779     * {@link #putExtra(String, Parcelable[])} of additional activities to place
3780     * a the front of the list of choices, when shown to the user with a
3781     * {@link #ACTION_CHOOSER}.
3782     */
3783    public static final String EXTRA_INITIAL_INTENTS = "android.intent.extra.INITIAL_INTENTS";
3784
3785    /**
3786     * A {@link IntentSender} to start after ephemeral installation success.
3787     * @hide
3788     */
3789    public static final String EXTRA_EPHEMERAL_SUCCESS = "android.intent.extra.EPHEMERAL_SUCCESS";
3790
3791    /**
3792     * A {@link IntentSender} to start after ephemeral installation failure.
3793     * @hide
3794     */
3795    public static final String EXTRA_EPHEMERAL_FAILURE = "android.intent.extra.EPHEMERAL_FAILURE";
3796
3797    /**
3798     * A Bundle forming a mapping of potential target package names to different extras Bundles
3799     * to add to the default intent extras in {@link #EXTRA_INTENT} when used with
3800     * {@link #ACTION_CHOOSER}. Each key should be a package name. The package need not
3801     * be currently installed on the device.
3802     *
3803     * <p>An application may choose to provide alternate extras for the case where a user
3804     * selects an activity from a predetermined set of target packages. If the activity
3805     * the user selects from the chooser belongs to a package with its package name as
3806     * a key in this bundle, the corresponding extras for that package will be merged with
3807     * the extras already present in the intent at {@link #EXTRA_INTENT}. If a replacement
3808     * extra has the same key as an extra already present in the intent it will overwrite
3809     * the extra from the intent.</p>
3810     *
3811     * <p><em>Examples:</em>
3812     * <ul>
3813     *     <li>An application may offer different {@link #EXTRA_TEXT} to an application
3814     *     when sharing with it via {@link #ACTION_SEND}, augmenting a link with additional query
3815     *     parameters for that target.</li>
3816     *     <li>An application may offer additional metadata for known targets of a given intent
3817     *     to pass along information only relevant to that target such as account or content
3818     *     identifiers already known to that application.</li>
3819     * </ul></p>
3820     */
3821    public static final String EXTRA_REPLACEMENT_EXTRAS =
3822            "android.intent.extra.REPLACEMENT_EXTRAS";
3823
3824    /**
3825     * An {@link IntentSender} that will be notified if a user successfully chooses a target
3826     * component to handle an action in an {@link #ACTION_CHOOSER} activity. The IntentSender
3827     * will have the extra {@link #EXTRA_CHOSEN_COMPONENT} appended to it containing the
3828     * {@link ComponentName} of the chosen component.
3829     *
3830     * <p>In some situations this callback may never come, for example if the user abandons
3831     * the chooser, switches to another task or any number of other reasons. Apps should not
3832     * be written assuming that this callback will always occur.</p>
3833     */
3834    public static final String EXTRA_CHOSEN_COMPONENT_INTENT_SENDER =
3835            "android.intent.extra.CHOSEN_COMPONENT_INTENT_SENDER";
3836
3837    /**
3838     * The {@link ComponentName} chosen by the user to complete an action.
3839     *
3840     * @see #EXTRA_CHOSEN_COMPONENT_INTENT_SENDER
3841     */
3842    public static final String EXTRA_CHOSEN_COMPONENT = "android.intent.extra.CHOSEN_COMPONENT";
3843
3844    /**
3845     * A {@link android.view.KeyEvent} object containing the event that
3846     * triggered the creation of the Intent it is in.
3847     */
3848    public static final String EXTRA_KEY_EVENT = "android.intent.extra.KEY_EVENT";
3849
3850    /**
3851     * Set to true in {@link #ACTION_REQUEST_SHUTDOWN} to request confirmation from the user
3852     * before shutting down.
3853     *
3854     * {@hide}
3855     */
3856    public static final String EXTRA_KEY_CONFIRM = "android.intent.extra.KEY_CONFIRM";
3857
3858    /**
3859     * Set to true in {@link #ACTION_REQUEST_SHUTDOWN} to indicate that the shutdown is
3860     * requested by the user.
3861     *
3862     * {@hide}
3863     */
3864    public static final String EXTRA_USER_REQUESTED_SHUTDOWN =
3865            "android.intent.extra.USER_REQUESTED_SHUTDOWN";
3866
3867    /**
3868     * Used as a boolean extra field in {@link android.content.Intent#ACTION_PACKAGE_REMOVED} or
3869     * {@link android.content.Intent#ACTION_PACKAGE_CHANGED} intents to override the default action
3870     * of restarting the application.
3871     */
3872    public static final String EXTRA_DONT_KILL_APP = "android.intent.extra.DONT_KILL_APP";
3873
3874    /**
3875     * A String holding the phone number originally entered in
3876     * {@link android.content.Intent#ACTION_NEW_OUTGOING_CALL}, or the actual
3877     * number to call in a {@link android.content.Intent#ACTION_CALL}.
3878     */
3879    public static final String EXTRA_PHONE_NUMBER = "android.intent.extra.PHONE_NUMBER";
3880
3881    /**
3882     * Used as an int extra field in {@link android.content.Intent#ACTION_UID_REMOVED}
3883     * intents to supply the uid the package had been assigned.  Also an optional
3884     * extra in {@link android.content.Intent#ACTION_PACKAGE_REMOVED} or
3885     * {@link android.content.Intent#ACTION_PACKAGE_CHANGED} for the same
3886     * purpose.
3887     */
3888    public static final String EXTRA_UID = "android.intent.extra.UID";
3889
3890    /**
3891     * @hide String array of package names.
3892     */
3893    @SystemApi
3894    public static final String EXTRA_PACKAGES = "android.intent.extra.PACKAGES";
3895
3896    /**
3897     * Used as a boolean extra field in {@link android.content.Intent#ACTION_PACKAGE_REMOVED}
3898     * intents to indicate whether this represents a full uninstall (removing
3899     * both the code and its data) or a partial uninstall (leaving its data,
3900     * implying that this is an update).
3901     */
3902    public static final String EXTRA_DATA_REMOVED = "android.intent.extra.DATA_REMOVED";
3903
3904    /**
3905     * @hide
3906     * Used as a boolean extra field in {@link android.content.Intent#ACTION_PACKAGE_REMOVED}
3907     * intents to indicate that at this point the package has been removed for
3908     * all users on the device.
3909     */
3910    public static final String EXTRA_REMOVED_FOR_ALL_USERS
3911            = "android.intent.extra.REMOVED_FOR_ALL_USERS";
3912
3913    /**
3914     * Used as a boolean extra field in {@link android.content.Intent#ACTION_PACKAGE_REMOVED}
3915     * intents to indicate that this is a replacement of the package, so this
3916     * broadcast will immediately be followed by an add broadcast for a
3917     * different version of the same package.
3918     */
3919    public static final String EXTRA_REPLACING = "android.intent.extra.REPLACING";
3920
3921    /**
3922     * Used as an int extra field in {@link android.app.AlarmManager} intents
3923     * to tell the application being invoked how many pending alarms are being
3924     * delievered with the intent.  For one-shot alarms this will always be 1.
3925     * For recurring alarms, this might be greater than 1 if the device was
3926     * asleep or powered off at the time an earlier alarm would have been
3927     * delivered.
3928     */
3929    public static final String EXTRA_ALARM_COUNT = "android.intent.extra.ALARM_COUNT";
3930
3931    /**
3932     * Used as an int extra field in {@link android.content.Intent#ACTION_DOCK_EVENT}
3933     * intents to request the dock state.  Possible values are
3934     * {@link android.content.Intent#EXTRA_DOCK_STATE_UNDOCKED},
3935     * {@link android.content.Intent#EXTRA_DOCK_STATE_DESK}, or
3936     * {@link android.content.Intent#EXTRA_DOCK_STATE_CAR}, or
3937     * {@link android.content.Intent#EXTRA_DOCK_STATE_LE_DESK}, or
3938     * {@link android.content.Intent#EXTRA_DOCK_STATE_HE_DESK}.
3939     */
3940    public static final String EXTRA_DOCK_STATE = "android.intent.extra.DOCK_STATE";
3941
3942    /**
3943     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3944     * to represent that the phone is not in any dock.
3945     */
3946    public static final int EXTRA_DOCK_STATE_UNDOCKED = 0;
3947
3948    /**
3949     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3950     * to represent that the phone is in a desk dock.
3951     */
3952    public static final int EXTRA_DOCK_STATE_DESK = 1;
3953
3954    /**
3955     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3956     * to represent that the phone is in a car dock.
3957     */
3958    public static final int EXTRA_DOCK_STATE_CAR = 2;
3959
3960    /**
3961     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3962     * to represent that the phone is in a analog (low end) dock.
3963     */
3964    public static final int EXTRA_DOCK_STATE_LE_DESK = 3;
3965
3966    /**
3967     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3968     * to represent that the phone is in a digital (high end) dock.
3969     */
3970    public static final int EXTRA_DOCK_STATE_HE_DESK = 4;
3971
3972    /**
3973     * Boolean that can be supplied as meta-data with a dock activity, to
3974     * indicate that the dock should take over the home key when it is active.
3975     */
3976    public static final String METADATA_DOCK_HOME = "android.dock_home";
3977
3978    /**
3979     * Used as a parcelable extra field in {@link #ACTION_APP_ERROR}, containing
3980     * the bug report.
3981     */
3982    public static final String EXTRA_BUG_REPORT = "android.intent.extra.BUG_REPORT";
3983
3984    /**
3985     * Used in the extra field in the remote intent. It's astring token passed with the
3986     * remote intent.
3987     */
3988    public static final String EXTRA_REMOTE_INTENT_TOKEN =
3989            "android.intent.extra.remote_intent_token";
3990
3991    /**
3992     * @deprecated See {@link #EXTRA_CHANGED_COMPONENT_NAME_LIST}; this field
3993     * will contain only the first name in the list.
3994     */
3995    @Deprecated public static final String EXTRA_CHANGED_COMPONENT_NAME =
3996            "android.intent.extra.changed_component_name";
3997
3998    /**
3999     * This field is part of {@link android.content.Intent#ACTION_PACKAGE_CHANGED},
4000     * and contains a string array of all of the components that have changed.  If
4001     * the state of the overall package has changed, then it will contain an entry
4002     * with the package name itself.
4003     */
4004    public static final String EXTRA_CHANGED_COMPONENT_NAME_LIST =
4005            "android.intent.extra.changed_component_name_list";
4006
4007    /**
4008     * This field is part of
4009     * {@link android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_AVAILABLE},
4010     * {@link android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE},
4011     * {@link android.content.Intent#ACTION_PACKAGES_SUSPENDED},
4012     * {@link android.content.Intent#ACTION_PACKAGES_UNSUSPENDED}
4013     * and contains a string array of all of the components that have changed.
4014     */
4015    public static final String EXTRA_CHANGED_PACKAGE_LIST =
4016            "android.intent.extra.changed_package_list";
4017
4018    /**
4019     * This field is part of
4020     * {@link android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_AVAILABLE},
4021     * {@link android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE}
4022     * and contains an integer array of uids of all of the components
4023     * that have changed.
4024     */
4025    public static final String EXTRA_CHANGED_UID_LIST =
4026            "android.intent.extra.changed_uid_list";
4027
4028    /**
4029     * @hide
4030     * Magic extra system code can use when binding, to give a label for
4031     * who it is that has bound to a service.  This is an integer giving
4032     * a framework string resource that can be displayed to the user.
4033     */
4034    public static final String EXTRA_CLIENT_LABEL =
4035            "android.intent.extra.client_label";
4036
4037    /**
4038     * @hide
4039     * Magic extra system code can use when binding, to give a PendingIntent object
4040     * that can be launched for the user to disable the system's use of this
4041     * service.
4042     */
4043    public static final String EXTRA_CLIENT_INTENT =
4044            "android.intent.extra.client_intent";
4045
4046    /**
4047     * Extra used to indicate that an intent should only return data that is on
4048     * the local device. This is a boolean extra; the default is false. If true,
4049     * an implementation should only allow the user to select data that is
4050     * already on the device, not requiring it be downloaded from a remote
4051     * service when opened.
4052     *
4053     * @see #ACTION_GET_CONTENT
4054     * @see #ACTION_OPEN_DOCUMENT
4055     * @see #ACTION_OPEN_DOCUMENT_TREE
4056     * @see #ACTION_CREATE_DOCUMENT
4057     */
4058    public static final String EXTRA_LOCAL_ONLY =
4059            "android.intent.extra.LOCAL_ONLY";
4060
4061    /**
4062     * Extra used to indicate that an intent can allow the user to select and
4063     * return multiple items. This is a boolean extra; the default is false. If
4064     * true, an implementation is allowed to present the user with a UI where
4065     * they can pick multiple items that are all returned to the caller. When
4066     * this happens, they should be returned as the {@link #getClipData()} part
4067     * of the result Intent.
4068     *
4069     * @see #ACTION_GET_CONTENT
4070     * @see #ACTION_OPEN_DOCUMENT
4071     */
4072    public static final String EXTRA_ALLOW_MULTIPLE =
4073            "android.intent.extra.ALLOW_MULTIPLE";
4074
4075    /**
4076     * The integer userHandle carried with broadcast intents related to addition, removal and
4077     * switching of users and managed profiles - {@link #ACTION_USER_ADDED},
4078     * {@link #ACTION_USER_REMOVED} and {@link #ACTION_USER_SWITCHED}.
4079     *
4080     * @hide
4081     */
4082    public static final String EXTRA_USER_HANDLE =
4083            "android.intent.extra.user_handle";
4084
4085    /**
4086     * The UserHandle carried with broadcasts intents related to addition and removal of managed
4087     * profiles - {@link #ACTION_MANAGED_PROFILE_ADDED} and {@link #ACTION_MANAGED_PROFILE_REMOVED}.
4088     */
4089    public static final String EXTRA_USER =
4090            "android.intent.extra.USER";
4091
4092    /**
4093     * Extra used in the response from a BroadcastReceiver that handles
4094     * {@link #ACTION_GET_RESTRICTION_ENTRIES}. The type of the extra is
4095     * <code>ArrayList&lt;RestrictionEntry&gt;</code>.
4096     */
4097    public static final String EXTRA_RESTRICTIONS_LIST = "android.intent.extra.restrictions_list";
4098
4099    /**
4100     * Extra sent in the intent to the BroadcastReceiver that handles
4101     * {@link #ACTION_GET_RESTRICTION_ENTRIES}. The type of the extra is a Bundle containing
4102     * the restrictions as key/value pairs.
4103     */
4104    public static final String EXTRA_RESTRICTIONS_BUNDLE =
4105            "android.intent.extra.restrictions_bundle";
4106
4107    /**
4108     * Extra used in the response from a BroadcastReceiver that handles
4109     * {@link #ACTION_GET_RESTRICTION_ENTRIES}.
4110     */
4111    public static final String EXTRA_RESTRICTIONS_INTENT =
4112            "android.intent.extra.restrictions_intent";
4113
4114    /**
4115     * Extra used to communicate a set of acceptable MIME types. The type of the
4116     * extra is {@code String[]}. Values may be a combination of concrete MIME
4117     * types (such as "image/png") and/or partial MIME types (such as
4118     * "audio/*").
4119     *
4120     * @see #ACTION_GET_CONTENT
4121     * @see #ACTION_OPEN_DOCUMENT
4122     */
4123    public static final String EXTRA_MIME_TYPES = "android.intent.extra.MIME_TYPES";
4124
4125    /**
4126     * Optional extra for {@link #ACTION_SHUTDOWN} that allows the sender to qualify that
4127     * this shutdown is only for the user space of the system, not a complete shutdown.
4128     * When this is true, hardware devices can use this information to determine that
4129     * they shouldn't do a complete shutdown of their device since this is not a
4130     * complete shutdown down to the kernel, but only user space restarting.
4131     * The default if not supplied is false.
4132     */
4133    public static final String EXTRA_SHUTDOWN_USERSPACE_ONLY
4134            = "android.intent.extra.SHUTDOWN_USERSPACE_ONLY";
4135
4136    /**
4137     * Optional boolean extra for {@link #ACTION_TIME_CHANGED} that indicates the
4138     * user has set their time format preferences to the 24 hour format.
4139     *
4140     * @hide for internal use only.
4141     */
4142    public static final String EXTRA_TIME_PREF_24_HOUR_FORMAT =
4143            "android.intent.extra.TIME_PREF_24_HOUR_FORMAT";
4144
4145    /** {@hide} */
4146    public static final String EXTRA_REASON = "android.intent.extra.REASON";
4147
4148    /** {@hide} */
4149    public static final String EXTRA_WIPE_EXTERNAL_STORAGE = "android.intent.extra.WIPE_EXTERNAL_STORAGE";
4150
4151    /**
4152     * Optional {@link android.app.PendingIntent} extra used to deliver the result of the SIM
4153     * activation request.
4154     * TODO: Add information about the structure and response data used with the pending intent.
4155     * @hide
4156     */
4157    public static final String EXTRA_SIM_ACTIVATION_RESPONSE =
4158            "android.intent.extra.SIM_ACTIVATION_RESPONSE";
4159
4160    /**
4161     * Optional index with semantics depending on the intent action.
4162     *
4163     * <p>The value must be an integer greater or equal to 0.
4164     */
4165    public static final String EXTRA_INDEX = "android.intent.extra.INDEX";
4166
4167    /**
4168     * Optional boolean extra indicating whether quiet mode has been switched on or off.
4169     * When a profile goes into quiet mode, all apps in the profile are killed and the
4170     * profile user is stopped. Widgets originating from the profile are masked, and app
4171     * launcher icons are grayed out.
4172     */
4173    public static final String EXTRA_QUIET_MODE = "android.intent.extra.QUIET_MODE";
4174
4175    /**
4176     * Used as an int extra field in {@link #ACTION_MEDIA_RESOURCE_GRANTED}
4177     * intents to specify the resource type granted. Possible values are
4178     * {@link #EXTRA_MEDIA_RESOURCE_TYPE_VIDEO_CODEC} or
4179     * {@link #EXTRA_MEDIA_RESOURCE_TYPE_AUDIO_CODEC}.
4180     *
4181     * @hide
4182     */
4183    public static final String EXTRA_MEDIA_RESOURCE_TYPE =
4184            "android.intent.extra.MEDIA_RESOURCE_TYPE";
4185
4186    /**
4187     * Used as an int value for {@link #EXTRA_MEDIA_RESOURCE_TYPE}
4188     * to represent that a video codec is allowed to use.
4189     *
4190     * @hide
4191     */
4192    public static final int EXTRA_MEDIA_RESOURCE_TYPE_VIDEO_CODEC = 0;
4193
4194    /**
4195     * Used as an int value for {@link #EXTRA_MEDIA_RESOURCE_TYPE}
4196     * to represent that a audio codec is allowed to use.
4197     *
4198     * @hide
4199     */
4200    public static final int EXTRA_MEDIA_RESOURCE_TYPE_AUDIO_CODEC = 1;
4201
4202    // ---------------------------------------------------------------------
4203    // ---------------------------------------------------------------------
4204    // Intent flags (see mFlags variable).
4205
4206    /** @hide */
4207    @IntDef(flag = true, value = {
4208            FLAG_GRANT_READ_URI_PERMISSION, FLAG_GRANT_WRITE_URI_PERMISSION,
4209            FLAG_GRANT_PERSISTABLE_URI_PERMISSION, FLAG_GRANT_PREFIX_URI_PERMISSION })
4210    @Retention(RetentionPolicy.SOURCE)
4211    public @interface GrantUriMode {}
4212
4213    /** @hide */
4214    @IntDef(flag = true, value = {
4215            FLAG_GRANT_READ_URI_PERMISSION, FLAG_GRANT_WRITE_URI_PERMISSION })
4216    @Retention(RetentionPolicy.SOURCE)
4217    public @interface AccessUriMode {}
4218
4219    /**
4220     * Test if given mode flags specify an access mode, which must be at least
4221     * read and/or write.
4222     *
4223     * @hide
4224     */
4225    public static boolean isAccessUriMode(int modeFlags) {
4226        return (modeFlags & (Intent.FLAG_GRANT_READ_URI_PERMISSION
4227                | Intent.FLAG_GRANT_WRITE_URI_PERMISSION)) != 0;
4228    }
4229
4230    /**
4231     * If set, the recipient of this Intent will be granted permission to
4232     * perform read operations on the URI in the Intent's data and any URIs
4233     * specified in its ClipData.  When applying to an Intent's ClipData,
4234     * all URIs as well as recursive traversals through data or other ClipData
4235     * in Intent items will be granted; only the grant flags of the top-level
4236     * Intent are used.
4237     */
4238    public static final int FLAG_GRANT_READ_URI_PERMISSION = 0x00000001;
4239    /**
4240     * If set, the recipient of this Intent will be granted permission to
4241     * perform write operations on the URI in the Intent's data and any URIs
4242     * specified in its ClipData.  When applying to an Intent's ClipData,
4243     * all URIs as well as recursive traversals through data or other ClipData
4244     * in Intent items will be granted; only the grant flags of the top-level
4245     * Intent are used.
4246     */
4247    public static final int FLAG_GRANT_WRITE_URI_PERMISSION = 0x00000002;
4248    /**
4249     * Can be set by the caller to indicate that this Intent is coming from
4250     * a background operation, not from direct user interaction.
4251     */
4252    public static final int FLAG_FROM_BACKGROUND = 0x00000004;
4253    /**
4254     * A flag you can enable for debugging: when set, log messages will be
4255     * printed during the resolution of this intent to show you what has
4256     * been found to create the final resolved list.
4257     */
4258    public static final int FLAG_DEBUG_LOG_RESOLUTION = 0x00000008;
4259    /**
4260     * If set, this intent will not match any components in packages that
4261     * are currently stopped.  If this is not set, then the default behavior
4262     * is to include such applications in the result.
4263     */
4264    public static final int FLAG_EXCLUDE_STOPPED_PACKAGES = 0x00000010;
4265    /**
4266     * If set, this intent will always match any components in packages that
4267     * are currently stopped.  This is the default behavior when
4268     * {@link #FLAG_EXCLUDE_STOPPED_PACKAGES} is not set.  If both of these
4269     * flags are set, this one wins (it allows overriding of exclude for
4270     * places where the framework may automatically set the exclude flag).
4271     */
4272    public static final int FLAG_INCLUDE_STOPPED_PACKAGES = 0x00000020;
4273
4274    /**
4275     * When combined with {@link #FLAG_GRANT_READ_URI_PERMISSION} and/or
4276     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, the URI permission grant can be
4277     * persisted across device reboots until explicitly revoked with
4278     * {@link Context#revokeUriPermission(Uri, int)}. This flag only offers the
4279     * grant for possible persisting; the receiving application must call
4280     * {@link ContentResolver#takePersistableUriPermission(Uri, int)} to
4281     * actually persist.
4282     *
4283     * @see ContentResolver#takePersistableUriPermission(Uri, int)
4284     * @see ContentResolver#releasePersistableUriPermission(Uri, int)
4285     * @see ContentResolver#getPersistedUriPermissions()
4286     * @see ContentResolver#getOutgoingPersistedUriPermissions()
4287     */
4288    public static final int FLAG_GRANT_PERSISTABLE_URI_PERMISSION = 0x00000040;
4289
4290    /**
4291     * When combined with {@link #FLAG_GRANT_READ_URI_PERMISSION} and/or
4292     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, the URI permission grant
4293     * applies to any URI that is a prefix match against the original granted
4294     * URI. (Without this flag, the URI must match exactly for access to be
4295     * granted.) Another URI is considered a prefix match only when scheme,
4296     * authority, and all path segments defined by the prefix are an exact
4297     * match.
4298     */
4299    public static final int FLAG_GRANT_PREFIX_URI_PERMISSION = 0x00000080;
4300
4301    /**
4302     * Internal flag used to indicate that a system component has done their
4303     * homework and verified that they correctly handle packages and components
4304     * that come and go over time. In particular:
4305     * <ul>
4306     * <li>Apps installed on external storage, which will appear to be
4307     * uninstalled while the the device is ejected.
4308     * <li>Apps with encryption unaware components, which will appear to not
4309     * exist while the device is locked.
4310     * </ul>
4311     *
4312     * @hide
4313     */
4314    public static final int FLAG_DEBUG_TRIAGED_MISSING = 0x00000100;
4315
4316    /**
4317     * Internal flag used to indicate ephemeral applications should not be
4318     * considered when resolving the intent.
4319     *
4320     * @hide
4321     */
4322    public static final int FLAG_IGNORE_EPHEMERAL = 0x00000200;
4323
4324    /**
4325     * If set, the new activity is not kept in the history stack.  As soon as
4326     * the user navigates away from it, the activity is finished.  This may also
4327     * be set with the {@link android.R.styleable#AndroidManifestActivity_noHistory
4328     * noHistory} attribute.
4329     *
4330     * <p>If set, {@link android.app.Activity#onActivityResult onActivityResult()}
4331     * is never invoked when the current activity starts a new activity which
4332     * sets a result and finishes.
4333     */
4334    public static final int FLAG_ACTIVITY_NO_HISTORY = 0x40000000;
4335    /**
4336     * If set, the activity will not be launched if it is already running
4337     * at the top of the history stack.
4338     */
4339    public static final int FLAG_ACTIVITY_SINGLE_TOP = 0x20000000;
4340    /**
4341     * If set, this activity will become the start of a new task on this
4342     * history stack.  A task (from the activity that started it to the
4343     * next task activity) defines an atomic group of activities that the
4344     * user can move to.  Tasks can be moved to the foreground and background;
4345     * all of the activities inside of a particular task always remain in
4346     * the same order.  See
4347     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
4348     * Stack</a> for more information about tasks.
4349     *
4350     * <p>This flag is generally used by activities that want
4351     * to present a "launcher" style behavior: they give the user a list of
4352     * separate things that can be done, which otherwise run completely
4353     * independently of the activity launching them.
4354     *
4355     * <p>When using this flag, if a task is already running for the activity
4356     * you are now starting, then a new activity will not be started; instead,
4357     * the current task will simply be brought to the front of the screen with
4358     * the state it was last in.  See {@link #FLAG_ACTIVITY_MULTIPLE_TASK} for a flag
4359     * to disable this behavior.
4360     *
4361     * <p>This flag can not be used when the caller is requesting a result from
4362     * the activity being launched.
4363     */
4364    public static final int FLAG_ACTIVITY_NEW_TASK = 0x10000000;
4365    /**
4366     * This flag is used to create a new task and launch an activity into it.
4367     * This flag is always paired with either {@link #FLAG_ACTIVITY_NEW_DOCUMENT}
4368     * or {@link #FLAG_ACTIVITY_NEW_TASK}. In both cases these flags alone would
4369     * search through existing tasks for ones matching this Intent. Only if no such
4370     * task is found would a new task be created. When paired with
4371     * FLAG_ACTIVITY_MULTIPLE_TASK both of these behaviors are modified to skip
4372     * the search for a matching task and unconditionally start a new task.
4373     *
4374     * <strong>When used with {@link #FLAG_ACTIVITY_NEW_TASK} do not use this
4375     * flag unless you are implementing your own
4376     * top-level application launcher.</strong>  Used in conjunction with
4377     * {@link #FLAG_ACTIVITY_NEW_TASK} to disable the
4378     * behavior of bringing an existing task to the foreground.  When set,
4379     * a new task is <em>always</em> started to host the Activity for the
4380     * Intent, regardless of whether there is already an existing task running
4381     * the same thing.
4382     *
4383     * <p><strong>Because the default system does not include graphical task management,
4384     * you should not use this flag unless you provide some way for a user to
4385     * return back to the tasks you have launched.</strong>
4386     *
4387     * See {@link #FLAG_ACTIVITY_NEW_DOCUMENT} for details of this flag's use for
4388     * creating new document tasks.
4389     *
4390     * <p>This flag is ignored if one of {@link #FLAG_ACTIVITY_NEW_TASK} or
4391     * {@link #FLAG_ACTIVITY_NEW_DOCUMENT} is not also set.
4392     *
4393     * <p>See
4394     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
4395     * Stack</a> for more information about tasks.
4396     *
4397     * @see #FLAG_ACTIVITY_NEW_DOCUMENT
4398     * @see #FLAG_ACTIVITY_NEW_TASK
4399     */
4400    public static final int FLAG_ACTIVITY_MULTIPLE_TASK = 0x08000000;
4401    /**
4402     * If set, and the activity being launched is already running in the
4403     * current task, then instead of launching a new instance of that activity,
4404     * all of the other activities on top of it will be closed and this Intent
4405     * will be delivered to the (now on top) old activity as a new Intent.
4406     *
4407     * <p>For example, consider a task consisting of the activities: A, B, C, D.
4408     * If D calls startActivity() with an Intent that resolves to the component
4409     * of activity B, then C and D will be finished and B receive the given
4410     * Intent, resulting in the stack now being: A, B.
4411     *
4412     * <p>The currently running instance of activity B in the above example will
4413     * either receive the new intent you are starting here in its
4414     * onNewIntent() method, or be itself finished and restarted with the
4415     * new intent.  If it has declared its launch mode to be "multiple" (the
4416     * default) and you have not set {@link #FLAG_ACTIVITY_SINGLE_TOP} in
4417     * the same intent, then it will be finished and re-created; for all other
4418     * launch modes or if {@link #FLAG_ACTIVITY_SINGLE_TOP} is set then this
4419     * Intent will be delivered to the current instance's onNewIntent().
4420