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     *
4421     * <p>This launch mode can also be used to good effect in conjunction with
4422     * {@link #FLAG_ACTIVITY_NEW_TASK}: if used to start the root activity
4423     * of a task, it will bring any currently running instance of that task
4424     * to the foreground, and then clear it to its root state.  This is
4425     * especially useful, for example, when launching an activity from the
4426     * notification manager.
4427     *
4428     * <p>See
4429     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
4430     * Stack</a> for more information about tasks.
4431     */
4432    public static final int FLAG_ACTIVITY_CLEAR_TOP = 0x04000000;
4433    /**
4434     * If set and this intent is being used to launch a new activity from an
4435     * existing one, then the reply target of the existing activity will be
4436     * transfered to the new activity.  This way the new activity can call
4437     * {@link android.app.Activity#setResult} and have that result sent back to
4438     * the reply target of the original activity.
4439     */
4440    public static final int FLAG_ACTIVITY_FORWARD_RESULT = 0x02000000;
4441    /**
4442     * If set and this intent is being used to launch a new activity from an
4443     * existing one, the current activity will not be counted as the top
4444     * activity for deciding whether the new intent should be delivered to
4445     * the top instead of starting a new one.  The previous activity will
4446     * be used as the top, with the assumption being that the current activity
4447     * will finish itself immediately.
4448     */
4449    public static final int FLAG_ACTIVITY_PREVIOUS_IS_TOP = 0x01000000;
4450    /**
4451     * If set, the new activity is not kept in the list of recently launched
4452     * activities.
4453     */
4454    public static final int FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS = 0x00800000;
4455    /**
4456     * This flag is not normally set by application code, but set for you by
4457     * the system as described in the
4458     * {@link android.R.styleable#AndroidManifestActivity_launchMode
4459     * launchMode} documentation for the singleTask mode.
4460     */
4461    public static final int FLAG_ACTIVITY_BROUGHT_TO_FRONT = 0x00400000;
4462    /**
4463     * If set, and this activity is either being started in a new task or
4464     * bringing to the top an existing task, then it will be launched as
4465     * the front door of the task.  This will result in the application of
4466     * any affinities needed to have that task in the proper state (either
4467     * moving activities to or from it), or simply resetting that task to
4468     * its initial state if needed.
4469     */
4470    public static final int FLAG_ACTIVITY_RESET_TASK_IF_NEEDED = 0x00200000;
4471    /**
4472     * This flag is not normally set by application code, but set for you by
4473     * the system if this activity is being launched from history
4474     * (longpress home key).
4475     */
4476    public static final int FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY = 0x00100000;
4477    /**
4478     * @deprecated As of API 21 this performs identically to
4479     * {@link #FLAG_ACTIVITY_NEW_DOCUMENT} which should be used instead of this.
4480     */
4481    public static final int FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET = 0x00080000;
4482    /**
4483     * This flag is used to open a document into a new task rooted at the activity launched
4484     * by this Intent. Through the use of this flag, or its equivalent attribute,
4485     * {@link android.R.attr#documentLaunchMode} multiple instances of the same activity
4486     * containing different documents will appear in the recent tasks list.
4487     *
4488     * <p>The use of the activity attribute form of this,
4489     * {@link android.R.attr#documentLaunchMode}, is
4490     * preferred over the Intent flag described here. The attribute form allows the
4491     * Activity to specify multiple document behavior for all launchers of the Activity
4492     * whereas using this flag requires each Intent that launches the Activity to specify it.
4493     *
4494     * <p>Note that the default semantics of this flag w.r.t. whether the recents entry for
4495     * it is kept after the activity is finished is different than the use of
4496     * {@link #FLAG_ACTIVITY_NEW_TASK} and {@link android.R.attr#documentLaunchMode} -- if
4497     * this flag is being used to create a new recents entry, then by default that entry
4498     * will be removed once the activity is finished.  You can modify this behavior with
4499     * {@link #FLAG_ACTIVITY_RETAIN_IN_RECENTS}.
4500     *
4501     * <p>FLAG_ACTIVITY_NEW_DOCUMENT may be used in conjunction with {@link
4502     * #FLAG_ACTIVITY_MULTIPLE_TASK}. When used alone it is the
4503     * equivalent of the Activity manifest specifying {@link
4504     * android.R.attr#documentLaunchMode}="intoExisting". When used with
4505     * FLAG_ACTIVITY_MULTIPLE_TASK it is the equivalent of the Activity manifest specifying
4506     * {@link android.R.attr#documentLaunchMode}="always".
4507     *
4508     * Refer to {@link android.R.attr#documentLaunchMode} for more information.
4509     *
4510     * @see android.R.attr#documentLaunchMode
4511     * @see #FLAG_ACTIVITY_MULTIPLE_TASK
4512     */
4513    public static final int FLAG_ACTIVITY_NEW_DOCUMENT = FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET;
4514    /**
4515     * If set, this flag will prevent the normal {@link android.app.Activity#onUserLeaveHint}
4516     * callback from occurring on the current frontmost activity before it is
4517     * paused as the newly-started activity is brought to the front.
4518     *
4519     * <p>Typically, an activity can rely on that callback to indicate that an
4520     * explicit user action has caused their activity to be moved out of the
4521     * foreground. The callback marks an appropriate point in the activity's
4522     * lifecycle for it to dismiss any notifications that it intends to display
4523     * "until the user has seen them," such as a blinking LED.
4524     *
4525     * <p>If an activity is ever started via any non-user-driven events such as
4526     * phone-call receipt or an alarm handler, this flag should be passed to {@link
4527     * Context#startActivity Context.startActivity}, ensuring that the pausing
4528     * activity does not think the user has acknowledged its notification.
4529     */
4530    public static final int FLAG_ACTIVITY_NO_USER_ACTION = 0x00040000;
4531    /**
4532     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
4533     * this flag will cause the launched activity to be brought to the front of its
4534     * task's history stack if it is already running.
4535     *
4536     * <p>For example, consider a task consisting of four activities: A, B, C, D.
4537     * If D calls startActivity() with an Intent that resolves to the component
4538     * of activity B, then B will be brought to the front of the history stack,
4539     * with this resulting order:  A, C, D, B.
4540     *
4541     * This flag will be ignored if {@link #FLAG_ACTIVITY_CLEAR_TOP} is also
4542     * specified.
4543     */
4544    public static final int FLAG_ACTIVITY_REORDER_TO_FRONT = 0X00020000;
4545    /**
4546     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
4547     * this flag will prevent the system from applying an activity transition
4548     * animation to go to the next activity state.  This doesn't mean an
4549     * animation will never run -- if another activity change happens that doesn't
4550     * specify this flag before the activity started here is displayed, then
4551     * that transition will be used.  This flag can be put to good use
4552     * when you are going to do a series of activity operations but the
4553     * animation seen by the user shouldn't be driven by the first activity
4554     * change but rather a later one.
4555     */
4556    public static final int FLAG_ACTIVITY_NO_ANIMATION = 0X00010000;
4557    /**
4558     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
4559     * this flag will cause any existing task that would be associated with the
4560     * activity to be cleared before the activity is started.  That is, the activity
4561     * becomes the new root of an otherwise empty task, and any old activities
4562     * are finished.  This can only be used in conjunction with {@link #FLAG_ACTIVITY_NEW_TASK}.
4563     */
4564    public static final int FLAG_ACTIVITY_CLEAR_TASK = 0X00008000;
4565    /**
4566     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
4567     * this flag will cause a newly launching task to be placed on top of the current
4568     * home activity task (if there is one).  That is, pressing back from the task
4569     * will always return the user to home even if that was not the last activity they
4570     * saw.   This can only be used in conjunction with {@link #FLAG_ACTIVITY_NEW_TASK}.
4571     */
4572    public static final int FLAG_ACTIVITY_TASK_ON_HOME = 0X00004000;
4573    /**
4574     * By default a document created by {@link #FLAG_ACTIVITY_NEW_DOCUMENT} will
4575     * have its entry in recent tasks removed when the user closes it (with back
4576     * or however else it may finish()). If you would like to instead allow the
4577     * document to be kept in recents so that it can be re-launched, you can use
4578     * this flag. When set and the task's activity is finished, the recents
4579     * entry will remain in the interface for the user to re-launch it, like a
4580     * recents entry for a top-level application.
4581     * <p>
4582     * The receiving activity can override this request with
4583     * {@link android.R.attr#autoRemoveFromRecents} or by explcitly calling
4584     * {@link android.app.Activity#finishAndRemoveTask()
4585     * Activity.finishAndRemoveTask()}.
4586     */
4587    public static final int FLAG_ACTIVITY_RETAIN_IN_RECENTS = 0x00002000;
4588
4589    /**
4590     * This flag is only used in split-screen multi-window mode. The new activity will be displayed
4591     * adjacent to the one launching it. This can only be used in conjunction with
4592     * {@link #FLAG_ACTIVITY_NEW_TASK}. Also, setting {@link #FLAG_ACTIVITY_MULTIPLE_TASK} is
4593     * required if you want a new instance of an existing activity to be created.
4594     */
4595    public static final int FLAG_ACTIVITY_LAUNCH_ADJACENT = 0x00001000;
4596
4597    /**
4598     * If set, when sending a broadcast only registered receivers will be
4599     * called -- no BroadcastReceiver components will be launched.
4600     */
4601    public static final int FLAG_RECEIVER_REGISTERED_ONLY = 0x40000000;
4602    /**
4603     * If set, when sending a broadcast the new broadcast will replace
4604     * any existing pending broadcast that matches it.  Matching is defined
4605     * by {@link Intent#filterEquals(Intent) Intent.filterEquals} returning
4606     * true for the intents of the two broadcasts.  When a match is found,
4607     * the new broadcast (and receivers associated with it) will replace the
4608     * existing one in the pending broadcast list, remaining at the same
4609     * position in the list.
4610     *
4611     * <p>This flag is most typically used with sticky broadcasts, which
4612     * only care about delivering the most recent values of the broadcast
4613     * to their receivers.
4614     */
4615    public static final int FLAG_RECEIVER_REPLACE_PENDING = 0x20000000;
4616    /**
4617     * If set, when sending a broadcast the recipient is allowed to run at
4618     * foreground priority, with a shorter timeout interval.  During normal
4619     * broadcasts the receivers are not automatically hoisted out of the
4620     * background priority class.
4621     */
4622    public static final int FLAG_RECEIVER_FOREGROUND = 0x10000000;
4623    /**
4624     * If this is an ordered broadcast, don't allow receivers to abort the broadcast.
4625     * They can still propagate results through to later receivers, but they can not prevent
4626     * later receivers from seeing the broadcast.
4627     */
4628    public static final int FLAG_RECEIVER_NO_ABORT = 0x08000000;
4629    /**
4630     * If set, when sending a broadcast <i>before boot has completed</i> only
4631     * registered receivers will be called -- no BroadcastReceiver components
4632     * will be launched.  Sticky intent state will be recorded properly even
4633     * if no receivers wind up being called.  If {@link #FLAG_RECEIVER_REGISTERED_ONLY}
4634     * is specified in the broadcast intent, this flag is unnecessary.
4635     *
4636     * <p>This flag is only for use by system sevices as a convenience to
4637     * avoid having to implement a more complex mechanism around detection
4638     * of boot completion.
4639     *
4640     * @hide
4641     */
4642    public static final int FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT = 0x04000000;
4643    /**
4644     * Set when this broadcast is for a boot upgrade, a special mode that
4645     * allows the broadcast to be sent before the system is ready and launches
4646     * the app process with no providers running in it.
4647     * @hide
4648     */
4649    public static final int FLAG_RECEIVER_BOOT_UPGRADE = 0x02000000;
4650    /**
4651     * If set, the broadcast will always go to manifest receivers in background (cached
4652     * or not running) apps, regardless of whether that would be done by default.  By
4653     * default they will only receive broadcasts if the broadcast has specified an
4654     * explicit component or package name.
4655     * @hide
4656     */
4657    public static final int FLAG_RECEIVER_INCLUDE_BACKGROUND = 0x01000000;
4658    /**
4659     * If set, the broadcast will never go to manifest receivers in background (cached
4660     * or not running) apps, regardless of whether that would be done by default.  By
4661     * default they will receive broadcasts if the broadcast has specified an
4662     * explicit component or package name.
4663     * @hide
4664     */
4665    public static final int FLAG_RECEIVER_EXCLUDE_BACKGROUND = 0x00800000;
4666
4667    /**
4668     * @hide Flags that can't be changed with PendingIntent.
4669     */
4670    public static final int IMMUTABLE_FLAGS = FLAG_GRANT_READ_URI_PERMISSION
4671            | FLAG_GRANT_WRITE_URI_PERMISSION | FLAG_GRANT_PERSISTABLE_URI_PERMISSION
4672            | FLAG_GRANT_PREFIX_URI_PERMISSION;
4673
4674    // ---------------------------------------------------------------------
4675    // ---------------------------------------------------------------------
4676    // toUri() and parseUri() options.
4677
4678    /**
4679     * Flag for use with {@link #toUri} and {@link #parseUri}: the URI string
4680     * always has the "intent:" scheme.  This syntax can be used when you want
4681     * to later disambiguate between URIs that are intended to describe an
4682     * Intent vs. all others that should be treated as raw URIs.  When used
4683     * with {@link #parseUri}, any other scheme will result in a generic
4684     * VIEW action for that raw URI.
4685     */
4686    public static final int URI_INTENT_SCHEME = 1<<0;
4687
4688    /**
4689     * Flag for use with {@link #toUri} and {@link #parseUri}: the URI string
4690     * always has the "android-app:" scheme.  This is a variation of
4691     * {@link #URI_INTENT_SCHEME} whose format is simpler for the case of an
4692     * http/https URI being delivered to a specific package name.  The format
4693     * is:
4694     *
4695     * <pre class="prettyprint">
4696     * android-app://{package_id}[/{scheme}[/{host}[/{path}]]][#Intent;{...}]</pre>
4697     *
4698     * <p>In this scheme, only the <code>package_id</code> is required.  If you include a host,
4699     * you must also include a scheme; including a path also requires both a host and a scheme.
4700     * The final #Intent; fragment can be used without a scheme, host, or path.
4701     * Note that this can not be
4702     * used with intents that have a {@link #setSelector}, since the base intent
4703     * will always have an explicit package name.</p>
4704     *
4705     * <p>Some examples of how this scheme maps to Intent objects:</p>
4706     * <table border="2" width="85%" align="center" frame="hsides" rules="rows">
4707     *     <colgroup align="left" />
4708     *     <colgroup align="left" />
4709     *     <thead>
4710     *     <tr><th>URI</th> <th>Intent</th></tr>
4711     *     </thead>
4712     *
4713     *     <tbody>
4714     *     <tr><td><code>android-app://com.example.app</code></td>
4715     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
4716     *             <tr><td>Action: </td><td>{@link #ACTION_MAIN}</td></tr>
4717     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
4718     *         </table></td>
4719     *     </tr>
4720     *     <tr><td><code>android-app://com.example.app/http/example.com</code></td>
4721     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
4722     *             <tr><td>Action: </td><td>{@link #ACTION_VIEW}</td></tr>
4723     *             <tr><td>Data: </td><td><code>http://example.com/</code></td></tr>
4724     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
4725     *         </table></td>
4726     *     </tr>
4727     *     <tr><td><code>android-app://com.example.app/http/example.com/foo?1234</code></td>
4728     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
4729     *             <tr><td>Action: </td><td>{@link #ACTION_VIEW}</td></tr>
4730     *             <tr><td>Data: </td><td><code>http://example.com/foo?1234</code></td></tr>
4731     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
4732     *         </table></td>
4733     *     </tr>
4734     *     <tr><td><code>android-app://com.example.app/<br />#Intent;action=com.example.MY_ACTION;end</code></td>
4735     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
4736     *             <tr><td>Action: </td><td><code>com.example.MY_ACTION</code></td></tr>
4737     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
4738     *         </table></td>
4739     *     </tr>
4740     *     <tr><td><code>android-app://com.example.app/http/example.com/foo?1234<br />#Intent;action=com.example.MY_ACTION;end</code></td>
4741     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
4742     *             <tr><td>Action: </td><td><code>com.example.MY_ACTION</code></td></tr>
4743     *             <tr><td>Data: </td><td><code>http://example.com/foo?1234</code></td></tr>
4744     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
4745     *         </table></td>
4746     *     </tr>
4747     *     <tr><td><code>android-app://com.example.app/<br />#Intent;action=com.example.MY_ACTION;<br />i.some_int=100;S.some_str=hello;end</code></td>
4748     *         <td><table border="" style="margin:0" >
4749     *             <tr><td>Action: </td><td><code>com.example.MY_ACTION</code></td></tr>
4750     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
4751     *             <tr><td>Extras: </td><td><code>some_int=(int)100<br />some_str=(String)hello</code></td></tr>
4752     *         </table></td>
4753     *     </tr>
4754     *     </tbody>
4755     * </table>
4756     */
4757    public static final int URI_ANDROID_APP_SCHEME = 1<<1;
4758
4759    /**
4760     * Flag for use with {@link #toUri} and {@link #parseUri}: allow parsing
4761     * of unsafe information.  In particular, the flags {@link #FLAG_GRANT_READ_URI_PERMISSION},
4762     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, {@link #FLAG_GRANT_PERSISTABLE_URI_PERMISSION},
4763     * and {@link #FLAG_GRANT_PREFIX_URI_PERMISSION} flags can not be set, so that the
4764     * generated Intent can not cause unexpected data access to happen.
4765     *
4766     * <p>If you do not trust the source of the URI being parsed, you should still do further
4767     * processing to protect yourself from it.  In particular, when using it to start an
4768     * activity you should usually add in {@link #CATEGORY_BROWSABLE} to limit the activities
4769     * that can handle it.</p>
4770     */
4771    public static final int URI_ALLOW_UNSAFE = 1<<2;
4772
4773    // ---------------------------------------------------------------------
4774
4775    private String mAction;
4776    private Uri mData;
4777    private String mType;
4778    private String mPackage;
4779    private ComponentName mComponent;
4780    private int mFlags;
4781    private ArraySet<String> mCategories;
4782    private Bundle mExtras;
4783    private Rect mSourceBounds;
4784    private Intent mSelector;
4785    private ClipData mClipData;
4786    private int mContentUserHint = UserHandle.USER_CURRENT;
4787
4788    // ---------------------------------------------------------------------
4789
4790    /**
4791     * Create an empty intent.
4792     */
4793    public Intent() {
4794    }
4795
4796    /**
4797     * Copy constructor.
4798     */
4799    public Intent(Intent o) {
4800        this.mAction = o.mAction;
4801        this.mData = o.mData;
4802        this.mType = o.mType;
4803        this.mPackage = o.mPackage;
4804        this.mComponent = o.mComponent;
4805        this.mFlags = o.mFlags;
4806        this.mContentUserHint = o.mContentUserHint;
4807        if (o.mCategories != null) {
4808            this.mCategories = new ArraySet<String>(o.mCategories);
4809        }
4810        if (o.mExtras != null) {
4811            this.mExtras = new Bundle(o.mExtras);
4812        }
4813        if (o.mSourceBounds != null) {
4814            this.mSourceBounds = new Rect(o.mSourceBounds);
4815        }
4816        if (o.mSelector != null) {
4817            this.mSelector = new Intent(o.mSelector);
4818        }
4819        if (o.mClipData != null) {
4820            this.mClipData = new ClipData(o.mClipData);
4821        }
4822    }
4823
4824    @Override
4825    public Object clone() {
4826        return new Intent(this);
4827    }
4828
4829    private Intent(Intent o, boolean all) {
4830        this.mAction = o.mAction;
4831        this.mData = o.mData;
4832        this.mType = o.mType;
4833        this.mPackage = o.mPackage;
4834        this.mComponent = o.mComponent;
4835        if (o.mCategories != null) {
4836            this.mCategories = new ArraySet<String>(o.mCategories);
4837        }
4838    }
4839
4840    /**
4841     * Make a clone of only the parts of the Intent that are relevant for
4842     * filter matching: the action, data, type, component, and categories.
4843     */
4844    public Intent cloneFilter() {
4845        return new Intent(this, false);
4846    }
4847
4848    /**
4849     * Create an intent with a given action.  All other fields (data, type,
4850     * class) are null.  Note that the action <em>must</em> be in a
4851     * namespace because Intents are used globally in the system -- for
4852     * example the system VIEW action is android.intent.action.VIEW; an
4853     * application's custom action would be something like
4854     * com.google.app.myapp.CUSTOM_ACTION.
4855     *
4856     * @param action The Intent action, such as ACTION_VIEW.
4857     */
4858    public Intent(String action) {
4859        setAction(action);
4860    }
4861
4862    /**
4863     * Create an intent with a given action and for a given data url.  Note
4864     * that the action <em>must</em> be in a namespace because Intents are
4865     * used globally in the system -- for example the system VIEW action is
4866     * android.intent.action.VIEW; an application's custom action would be
4867     * something like com.google.app.myapp.CUSTOM_ACTION.
4868     *
4869     * <p><em>Note: scheme and host name matching in the Android framework is
4870     * case-sensitive, unlike the formal RFC.  As a result,
4871     * you should always ensure that you write your Uri with these elements
4872     * using lower case letters, and normalize any Uris you receive from
4873     * outside of Android to ensure the scheme and host is lower case.</em></p>
4874     *
4875     * @param action The Intent action, such as ACTION_VIEW.
4876     * @param uri The Intent data URI.
4877     */
4878    public Intent(String action, Uri uri) {
4879        setAction(action);
4880        mData = uri;
4881    }
4882
4883    /**
4884     * Create an intent for a specific component.  All other fields (action, data,
4885     * type, class) are null, though they can be modified later with explicit
4886     * calls.  This provides a convenient way to create an intent that is
4887     * intended to execute a hard-coded class name, rather than relying on the
4888     * system to find an appropriate class for you; see {@link #setComponent}
4889     * for more information on the repercussions of this.
4890     *
4891     * @param packageContext A Context of the application package implementing
4892     * this class.
4893     * @param cls The component class that is to be used for the intent.
4894     *
4895     * @see #setClass
4896     * @see #setComponent
4897     * @see #Intent(String, android.net.Uri , Context, Class)
4898     */
4899    public Intent(Context packageContext, Class<?> cls) {
4900        mComponent = new ComponentName(packageContext, cls);
4901    }
4902
4903    /**
4904     * Create an intent for a specific component with a specified action and data.
4905     * This is equivalent to using {@link #Intent(String, android.net.Uri)} to
4906     * construct the Intent and then calling {@link #setClass} to set its
4907     * class.
4908     *
4909     * <p><em>Note: scheme and host name matching in the Android framework is
4910     * case-sensitive, unlike the formal RFC.  As a result,
4911     * you should always ensure that you write your Uri with these elements
4912     * using lower case letters, and normalize any Uris you receive from
4913     * outside of Android to ensure the scheme and host is lower case.</em></p>
4914     *
4915     * @param action The Intent action, such as ACTION_VIEW.
4916     * @param uri The Intent data URI.
4917     * @param packageContext A Context of the application package implementing
4918     * this class.
4919     * @param cls The component class that is to be used for the intent.
4920     *
4921     * @see #Intent(String, android.net.Uri)
4922     * @see #Intent(Context, Class)
4923     * @see #setClass
4924     * @see #setComponent
4925     */
4926    public Intent(String action, Uri uri,
4927            Context packageContext, Class<?> cls) {
4928        setAction(action);
4929        mData = uri;
4930        mComponent = new ComponentName(packageContext, cls);
4931    }
4932
4933    /**
4934     * Create an intent to launch the main (root) activity of a task.  This
4935     * is the Intent that is started when the application's is launched from
4936     * Home.  For anything else that wants to launch an application in the
4937     * same way, it is important that they use an Intent structured the same
4938     * way, and can use this function to ensure this is the case.
4939     *
4940     * <p>The returned Intent has the given Activity component as its explicit
4941     * component, {@link #ACTION_MAIN} as its action, and includes the
4942     * category {@link #CATEGORY_LAUNCHER}.  This does <em>not</em> have
4943     * {@link #FLAG_ACTIVITY_NEW_TASK} set, though typically you will want
4944     * to do that through {@link #addFlags(int)} on the returned Intent.
4945     *
4946     * @param mainActivity The main activity component that this Intent will
4947     * launch.
4948     * @return Returns a newly created Intent that can be used to launch the
4949     * activity as a main application entry.
4950     *
4951     * @see #setClass
4952     * @see #setComponent
4953     */
4954    public static Intent makeMainActivity(ComponentName mainActivity) {
4955        Intent intent = new Intent(ACTION_MAIN);
4956        intent.setComponent(mainActivity);
4957        intent.addCategory(CATEGORY_LAUNCHER);
4958        return intent;
4959    }
4960
4961    /**
4962     * Make an Intent for the main activity of an application, without
4963     * specifying a specific activity to run but giving a selector to find
4964     * the activity.  This results in a final Intent that is structured
4965     * the same as when the application is launched from
4966     * Home.  For anything else that wants to launch an application in the
4967     * same way, it is important that they use an Intent structured the same
4968     * way, and can use this function to ensure this is the case.
4969     *
4970     * <p>The returned Intent has {@link #ACTION_MAIN} as its action, and includes the
4971     * category {@link #CATEGORY_LAUNCHER}.  This does <em>not</em> have
4972     * {@link #FLAG_ACTIVITY_NEW_TASK} set, though typically you will want
4973     * to do that through {@link #addFlags(int)} on the returned Intent.
4974     *
4975     * @param selectorAction The action name of the Intent's selector.
4976     * @param selectorCategory The name of a category to add to the Intent's
4977     * selector.
4978     * @return Returns a newly created Intent that can be used to launch the
4979     * activity as a main application entry.
4980     *
4981     * @see #setSelector(Intent)
4982     */
4983    public static Intent makeMainSelectorActivity(String selectorAction,
4984            String selectorCategory) {
4985        Intent intent = new Intent(ACTION_MAIN);
4986        intent.addCategory(CATEGORY_LAUNCHER);
4987        Intent selector = new Intent();
4988        selector.setAction(selectorAction);
4989        selector.addCategory(selectorCategory);
4990        intent.setSelector(selector);
4991        return intent;
4992    }
4993
4994    /**
4995     * Make an Intent that can be used to re-launch an application's task
4996     * in its base state.  This is like {@link #makeMainActivity(ComponentName)},
4997     * but also sets the flags {@link #FLAG_ACTIVITY_NEW_TASK} and
4998     * {@link #FLAG_ACTIVITY_CLEAR_TASK}.
4999     *
5000     * @param mainActivity The activity component that is the root of the
5001     * task; this is the activity that has been published in the application's
5002     * manifest as the main launcher icon.
5003     *
5004     * @return Returns a newly created Intent that can be used to relaunch the
5005     * activity's task in its root state.
5006     */
5007    public static Intent makeRestartActivityTask(ComponentName mainActivity) {
5008        Intent intent = makeMainActivity(mainActivity);
5009        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
5010                | Intent.FLAG_ACTIVITY_CLEAR_TASK);
5011        return intent;
5012    }
5013
5014    /**
5015     * Call {@link #parseUri} with 0 flags.
5016     * @deprecated Use {@link #parseUri} instead.
5017     */
5018    @Deprecated
5019    public static Intent getIntent(String uri) throws URISyntaxException {
5020        return parseUri(uri, 0);
5021    }
5022
5023    /**
5024     * Create an intent from a URI.  This URI may encode the action,
5025     * category, and other intent fields, if it was returned by
5026     * {@link #toUri}.  If the Intent was not generate by toUri(), its data
5027     * will be the entire URI and its action will be ACTION_VIEW.
5028     *
5029     * <p>The URI given here must not be relative -- that is, it must include
5030     * the scheme and full path.
5031     *
5032     * @param uri The URI to turn into an Intent.
5033     * @param flags Additional processing flags.  Either 0,
5034     * {@link #URI_INTENT_SCHEME}, or {@link #URI_ANDROID_APP_SCHEME}.
5035     *
5036     * @return Intent The newly created Intent object.
5037     *
5038     * @throws URISyntaxException Throws URISyntaxError if the basic URI syntax
5039     * it bad (as parsed by the Uri class) or the Intent data within the
5040     * URI is invalid.
5041     *
5042     * @see #toUri
5043     */
5044    public static Intent parseUri(String uri, int flags) throws URISyntaxException {
5045        int i = 0;
5046        try {
5047            final boolean androidApp = uri.startsWith("android-app:");
5048
5049            // Validate intent scheme if requested.
5050            if ((flags&(URI_INTENT_SCHEME|URI_ANDROID_APP_SCHEME)) != 0) {
5051                if (!uri.startsWith("intent:") && !androidApp) {
5052                    Intent intent = new Intent(ACTION_VIEW);
5053                    try {
5054                        intent.setData(Uri.parse(uri));
5055                    } catch (IllegalArgumentException e) {
5056                        throw new URISyntaxException(uri, e.getMessage());
5057                    }
5058                    return intent;
5059                }
5060            }
5061
5062            i = uri.lastIndexOf("#");
5063            // simple case
5064            if (i == -1) {
5065                if (!androidApp) {
5066                    return new Intent(ACTION_VIEW, Uri.parse(uri));
5067                }
5068
5069            // old format Intent URI
5070            } else if (!uri.startsWith("#Intent;", i)) {
5071                if (!androidApp) {
5072                    return getIntentOld(uri, flags);
5073                } else {
5074                    i = -1;
5075                }
5076            }
5077
5078            // new format
5079            Intent intent = new Intent(ACTION_VIEW);
5080            Intent baseIntent = intent;
5081            boolean explicitAction = false;
5082            boolean inSelector = false;
5083
5084            // fetch data part, if present
5085            String scheme = null;
5086            String data;
5087            if (i >= 0) {
5088                data = uri.substring(0, i);
5089                i += 8; // length of "#Intent;"
5090            } else {
5091                data = uri;
5092            }
5093
5094            // loop over contents of Intent, all name=value;
5095            while (i >= 0 && !uri.startsWith("end", i)) {
5096                int eq = uri.indexOf('=', i);
5097                if (eq < 0) eq = i-1;
5098                int semi = uri.indexOf(';', i);
5099                String value = eq < semi ? Uri.decode(uri.substring(eq + 1, semi)) : "";
5100
5101                // action
5102                if (uri.startsWith("action=", i)) {
5103                    intent.setAction(value);
5104                    if (!inSelector) {
5105                        explicitAction = true;
5106                    }
5107                }
5108
5109                // categories
5110                else if (uri.startsWith("category=", i)) {
5111                    intent.addCategory(value);
5112                }
5113
5114                // type
5115                else if (uri.startsWith("type=", i)) {
5116                    intent.mType = value;
5117                }
5118
5119                // launch flags
5120                else if (uri.startsWith("launchFlags=", i)) {
5121                    intent.mFlags = Integer.decode(value).intValue();
5122                    if ((flags& URI_ALLOW_UNSAFE) == 0) {
5123                        intent.mFlags &= ~IMMUTABLE_FLAGS;
5124                    }
5125                }
5126
5127                // package
5128                else if (uri.startsWith("package=", i)) {
5129                    intent.mPackage = value;
5130                }
5131
5132                // component
5133                else if (uri.startsWith("component=", i)) {
5134                    intent.mComponent = ComponentName.unflattenFromString(value);
5135                }
5136
5137                // scheme
5138                else if (uri.startsWith("scheme=", i)) {
5139                    if (inSelector) {
5140                        intent.mData = Uri.parse(value + ":");
5141                    } else {
5142                        scheme = value;
5143                    }
5144                }
5145
5146                // source bounds
5147                else if (uri.startsWith("sourceBounds=", i)) {
5148                    intent.mSourceBounds = Rect.unflattenFromString(value);
5149                }
5150
5151                // selector
5152                else if (semi == (i+3) && uri.startsWith("SEL", i)) {
5153                    intent = new Intent();
5154                    inSelector = true;
5155                }
5156
5157                // extra
5158                else {
5159                    String key = Uri.decode(uri.substring(i + 2, eq));
5160                    // create Bundle if it doesn't already exist
5161                    if (intent.mExtras == null) intent.mExtras = new Bundle();
5162                    Bundle b = intent.mExtras;
5163                    // add EXTRA
5164                    if      (uri.startsWith("S.", i)) b.putString(key, value);
5165                    else if (uri.startsWith("B.", i)) b.putBoolean(key, Boolean.parseBoolean(value));
5166                    else if (uri.startsWith("b.", i)) b.putByte(key, Byte.parseByte(value));
5167                    else if (uri.startsWith("c.", i)) b.putChar(key, value.charAt(0));
5168                    else if (uri.startsWith("d.", i)) b.putDouble(key, Double.parseDouble(value));
5169                    else if (uri.startsWith("f.", i)) b.putFloat(key, Float.parseFloat(value));
5170                    else if (uri.startsWith("i.", i)) b.putInt(key, Integer.parseInt(value));
5171                    else if (uri.startsWith("l.", i)) b.putLong(key, Long.parseLong(value));
5172                    else if (uri.startsWith("s.", i)) b.putShort(key, Short.parseShort(value));
5173                    else throw new URISyntaxException(uri, "unknown EXTRA type", i);
5174                }
5175
5176                // move to the next item
5177                i = semi + 1;
5178            }
5179
5180            if (inSelector) {
5181                // The Intent had a selector; fix it up.
5182                if (baseIntent.mPackage == null) {
5183                    baseIntent.setSelector(intent);
5184                }
5185                intent = baseIntent;
5186            }
5187
5188            if (data != null) {
5189                if (data.startsWith("intent:")) {
5190                    data = data.substring(7);
5191                    if (scheme != null) {
5192                        data = scheme + ':' + data;
5193                    }
5194                } else if (data.startsWith("android-app:")) {
5195                    if (data.charAt(12) == '/' && data.charAt(13) == '/') {
5196                        // Correctly formed android-app, first part is package name.
5197                        int end = data.indexOf('/', 14);
5198                        if (end < 0) {
5199                            // All we have is a package name.
5200                            intent.mPackage = data.substring(14);
5201                            if (!explicitAction) {
5202                                intent.setAction(ACTION_MAIN);
5203                            }
5204                            data = "";
5205                        } else {
5206                            // Target the Intent at the given package name always.
5207                            String authority = null;
5208                            intent.mPackage = data.substring(14, end);
5209                            int newEnd;
5210                            if ((end+1) < data.length()) {
5211                                if ((newEnd=data.indexOf('/', end+1)) >= 0) {
5212                                    // Found a scheme, remember it.
5213                                    scheme = data.substring(end+1, newEnd);
5214                                    end = newEnd;
5215                                    if (end < data.length() && (newEnd=data.indexOf('/', end+1)) >= 0) {
5216                                        // Found a authority, remember it.
5217                                        authority = data.substring(end+1, newEnd);
5218                                        end = newEnd;
5219                                    }
5220                                } else {
5221                                    // All we have is a scheme.
5222                                    scheme = data.substring(end+1);
5223                                }
5224                            }
5225                            if (scheme == null) {
5226                                // If there was no scheme, then this just targets the package.
5227                                if (!explicitAction) {
5228                                    intent.setAction(ACTION_MAIN);
5229                                }
5230                                data = "";
5231                            } else if (authority == null) {
5232                                data = scheme + ":";
5233                            } else {
5234                                data = scheme + "://" + authority + data.substring(end);
5235                            }
5236                        }
5237                    } else {
5238                        data = "";
5239                    }
5240                }
5241
5242                if (data.length() > 0) {
5243                    try {
5244                        intent.mData = Uri.parse(data);
5245                    } catch (IllegalArgumentException e) {
5246                        throw new URISyntaxException(uri, e.getMessage());
5247                    }
5248                }
5249            }
5250
5251            return intent;
5252
5253        } catch (IndexOutOfBoundsException e) {
5254            throw new URISyntaxException(uri, "illegal Intent URI format", i);
5255        }
5256    }
5257
5258    public static Intent getIntentOld(String uri) throws URISyntaxException {
5259        return getIntentOld(uri, 0);
5260    }
5261
5262    private static Intent getIntentOld(String uri, int flags) throws URISyntaxException {
5263        Intent intent;
5264
5265        int i = uri.lastIndexOf('#');
5266        if (i >= 0) {
5267            String action = null;
5268            final int intentFragmentStart = i;
5269            boolean isIntentFragment = false;
5270
5271            i++;
5272
5273            if (uri.regionMatches(i, "action(", 0, 7)) {
5274                isIntentFragment = true;
5275                i += 7;
5276                int j = uri.indexOf(')', i);
5277                action = uri.substring(i, j);
5278                i = j + 1;
5279            }
5280
5281            intent = new Intent(action);
5282
5283            if (uri.regionMatches(i, "categories(", 0, 11)) {
5284                isIntentFragment = true;
5285                i += 11;
5286                int j = uri.indexOf(')', i);
5287                while (i < j) {
5288                    int sep = uri.indexOf('!', i);
5289                    if (sep < 0 || sep > j) sep = j;
5290                    if (i < sep) {
5291                        intent.addCategory(uri.substring(i, sep));
5292                    }
5293                    i = sep + 1;
5294                }
5295                i = j + 1;
5296            }
5297
5298            if (uri.regionMatches(i, "type(", 0, 5)) {
5299                isIntentFragment = true;
5300                i += 5;
5301                int j = uri.indexOf(')', i);
5302                intent.mType = uri.substring(i, j);
5303                i = j + 1;
5304            }
5305
5306            if (uri.regionMatches(i, "launchFlags(", 0, 12)) {
5307                isIntentFragment = true;
5308                i += 12;
5309                int j = uri.indexOf(')', i);
5310                intent.mFlags = Integer.decode(uri.substring(i, j)).intValue();
5311                if ((flags& URI_ALLOW_UNSAFE) == 0) {
5312                    intent.mFlags &= ~IMMUTABLE_FLAGS;
5313                }
5314                i = j + 1;
5315            }
5316
5317            if (uri.regionMatches(i, "component(", 0, 10)) {
5318                isIntentFragment = true;
5319                i += 10;
5320                int j = uri.indexOf(')', i);
5321                int sep = uri.indexOf('!', i);
5322                if (sep >= 0 && sep < j) {
5323                    String pkg = uri.substring(i, sep);
5324                    String cls = uri.substring(sep + 1, j);
5325                    intent.mComponent = new ComponentName(pkg, cls);
5326                }
5327                i = j + 1;
5328            }
5329
5330            if (uri.regionMatches(i, "extras(", 0, 7)) {
5331                isIntentFragment = true;
5332                i += 7;
5333
5334                final int closeParen = uri.indexOf(')', i);
5335                if (closeParen == -1) throw new URISyntaxException(uri,
5336                        "EXTRA missing trailing ')'", i);
5337
5338                while (i < closeParen) {
5339                    // fetch the key value
5340                    int j = uri.indexOf('=', i);
5341                    if (j <= i + 1 || i >= closeParen) {
5342                        throw new URISyntaxException(uri, "EXTRA missing '='", i);
5343                    }
5344                    char type = uri.charAt(i);
5345                    i++;
5346                    String key = uri.substring(i, j);
5347                    i = j + 1;
5348
5349                    // get type-value
5350                    j = uri.indexOf('!', i);
5351                    if (j == -1 || j >= closeParen) j = closeParen;
5352                    if (i >= j) throw new URISyntaxException(uri, "EXTRA missing '!'", i);
5353                    String value = uri.substring(i, j);
5354                    i = j;
5355
5356                    // create Bundle if it doesn't already exist
5357                    if (intent.mExtras == null) intent.mExtras = new Bundle();
5358
5359                    // add item to bundle
5360                    try {
5361                        switch (type) {
5362                            case 'S':
5363                                intent.mExtras.putString(key, Uri.decode(value));
5364                                break;
5365                            case 'B':
5366                                intent.mExtras.putBoolean(key, Boolean.parseBoolean(value));
5367                                break;
5368                            case 'b':
5369                                intent.mExtras.putByte(key, Byte.parseByte(value));
5370                                break;
5371                            case 'c':
5372                                intent.mExtras.putChar(key, Uri.decode(value).charAt(0));
5373                                break;
5374                            case 'd':
5375                                intent.mExtras.putDouble(key, Double.parseDouble(value));
5376                                break;
5377                            case 'f':
5378                                intent.mExtras.putFloat(key, Float.parseFloat(value));
5379                                break;
5380                            case 'i':
5381                                intent.mExtras.putInt(key, Integer.parseInt(value));
5382                                break;
5383                            case 'l':
5384                                intent.mExtras.putLong(key, Long.parseLong(value));
5385                                break;
5386                            case 's':
5387                                intent.mExtras.putShort(key, Short.parseShort(value));
5388                                break;
5389                            default:
5390                                throw new URISyntaxException(uri, "EXTRA has unknown type", i);
5391                        }
5392                    } catch (NumberFormatException e) {
5393                        throw new URISyntaxException(uri, "EXTRA value can't be parsed", i);
5394                    }
5395
5396                    char ch = uri.charAt(i);
5397                    if (ch == ')') break;
5398                    if (ch != '!') throw new URISyntaxException(uri, "EXTRA missing '!'", i);
5399                    i++;
5400                }
5401            }
5402
5403            if (isIntentFragment) {
5404                intent.mData = Uri.parse(uri.substring(0, intentFragmentStart));
5405            } else {
5406                intent.mData = Uri.parse(uri);
5407            }
5408
5409            if (intent.mAction == null) {
5410                // By default, if no action is specified, then use VIEW.
5411                intent.mAction = ACTION_VIEW;
5412            }
5413
5414        } else {
5415            intent = new Intent(ACTION_VIEW, Uri.parse(uri));
5416        }
5417
5418        return intent;
5419    }
5420
5421    /** @hide */
5422    public interface CommandOptionHandler {
5423        boolean handleOption(String opt, ShellCommand cmd);
5424    }
5425
5426    /** @hide */
5427    public static Intent parseCommandArgs(ShellCommand cmd, CommandOptionHandler optionHandler)
5428            throws URISyntaxException {
5429        Intent intent = new Intent();
5430        Intent baseIntent = intent;
5431        boolean hasIntentInfo = false;
5432
5433        Uri data = null;
5434        String type = null;
5435
5436        String opt;
5437        while ((opt=cmd.getNextOption()) != null) {
5438            switch (opt) {
5439                case "-a":
5440                    intent.setAction(cmd.getNextArgRequired());
5441                    if (intent == baseIntent) {
5442                        hasIntentInfo = true;
5443                    }
5444                    break;
5445                case "-d":
5446                    data = Uri.parse(cmd.getNextArgRequired());
5447                    if (intent == baseIntent) {
5448                        hasIntentInfo = true;
5449                    }
5450                    break;
5451                case "-t":
5452                    type = cmd.getNextArgRequired();
5453                    if (intent == baseIntent) {
5454                        hasIntentInfo = true;
5455                    }
5456                    break;
5457                case "-c":
5458                    intent.addCategory(cmd.getNextArgRequired());
5459                    if (intent == baseIntent) {
5460                        hasIntentInfo = true;
5461                    }
5462                    break;
5463                case "-e":
5464                case "--es": {
5465                    String key = cmd.getNextArgRequired();
5466                    String value = cmd.getNextArgRequired();
5467                    intent.putExtra(key, value);
5468                }
5469                break;
5470                case "--esn": {
5471                    String key = cmd.getNextArgRequired();
5472                    intent.putExtra(key, (String) null);
5473                }
5474                break;
5475                case "--ei": {
5476                    String key = cmd.getNextArgRequired();
5477                    String value = cmd.getNextArgRequired();
5478                    intent.putExtra(key, Integer.decode(value));
5479                }
5480                break;
5481                case "--eu": {
5482                    String key = cmd.getNextArgRequired();
5483                    String value = cmd.getNextArgRequired();
5484                    intent.putExtra(key, Uri.parse(value));
5485                }
5486                break;
5487                case "--ecn": {
5488                    String key = cmd.getNextArgRequired();
5489                    String value = cmd.getNextArgRequired();
5490                    ComponentName cn = ComponentName.unflattenFromString(value);
5491                    if (cn == null)
5492                        throw new IllegalArgumentException("Bad component name: " + value);
5493                    intent.putExtra(key, cn);
5494                }
5495                break;
5496                case "--eia": {
5497                    String key = cmd.getNextArgRequired();
5498                    String value = cmd.getNextArgRequired();
5499                    String[] strings = value.split(",");
5500                    int[] list = new int[strings.length];
5501                    for (int i = 0; i < strings.length; i++) {
5502                        list[i] = Integer.decode(strings[i]);
5503                    }
5504                    intent.putExtra(key, list);
5505                }
5506                break;
5507                case "--eial": {
5508                    String key = cmd.getNextArgRequired();
5509                    String value = cmd.getNextArgRequired();
5510                    String[] strings = value.split(",");
5511                    ArrayList<Integer> list = new ArrayList<>(strings.length);
5512                    for (int i = 0; i < strings.length; i++) {
5513                        list.add(Integer.decode(strings[i]));
5514                    }
5515                    intent.putExtra(key, list);
5516                }
5517                break;
5518                case "--el": {
5519                    String key = cmd.getNextArgRequired();
5520                    String value = cmd.getNextArgRequired();
5521                    intent.putExtra(key, Long.valueOf(value));
5522                }
5523                break;
5524                case "--ela": {
5525                    String key = cmd.getNextArgRequired();
5526                    String value = cmd.getNextArgRequired();
5527                    String[] strings = value.split(",");
5528                    long[] list = new long[strings.length];
5529                    for (int i = 0; i < strings.length; i++) {
5530                        list[i] = Long.valueOf(strings[i]);
5531                    }
5532                    intent.putExtra(key, list);
5533                    hasIntentInfo = true;
5534                }
5535                break;
5536                case "--elal": {
5537                    String key = cmd.getNextArgRequired();
5538                    String value = cmd.getNextArgRequired();
5539                    String[] strings = value.split(",");
5540                    ArrayList<Long> list = new ArrayList<>(strings.length);
5541                    for (int i = 0; i < strings.length; i++) {
5542                        list.add(Long.valueOf(strings[i]));
5543                    }
5544                    intent.putExtra(key, list);
5545                    hasIntentInfo = true;
5546                }
5547                break;
5548                case "--ef": {
5549                    String key = cmd.getNextArgRequired();
5550                    String value = cmd.getNextArgRequired();
5551                    intent.putExtra(key, Float.valueOf(value));
5552                    hasIntentInfo = true;
5553                }
5554                break;
5555                case "--efa": {
5556                    String key = cmd.getNextArgRequired();
5557                    String value = cmd.getNextArgRequired();
5558                    String[] strings = value.split(",");
5559                    float[] list = new float[strings.length];
5560                    for (int i = 0; i < strings.length; i++) {
5561                        list[i] = Float.valueOf(strings[i]);
5562                    }
5563                    intent.putExtra(key, list);
5564                    hasIntentInfo = true;
5565                }
5566                break;
5567                case "--efal": {
5568                    String key = cmd.getNextArgRequired();
5569                    String value = cmd.getNextArgRequired();
5570                    String[] strings = value.split(",");
5571                    ArrayList<Float> list = new ArrayList<>(strings.length);
5572                    for (int i = 0; i < strings.length; i++) {
5573                        list.add(Float.valueOf(strings[i]));
5574                    }
5575                    intent.putExtra(key, list);
5576                    hasIntentInfo = true;
5577                }
5578                break;
5579                case "--esa": {
5580                    String key = cmd.getNextArgRequired();
5581                    String value = cmd.getNextArgRequired();
5582                    // Split on commas unless they are preceeded by an escape.
5583                    // The escape character must be escaped for the string and
5584                    // again for the regex, thus four escape characters become one.
5585                    String[] strings = value.split("(?<!\\\\),");
5586                    intent.putExtra(key, strings);
5587                    hasIntentInfo = true;
5588                }
5589                break;
5590                case "--esal": {
5591                    String key = cmd.getNextArgRequired();
5592                    String value = cmd.getNextArgRequired();
5593                    // Split on commas unless they are preceeded by an escape.
5594                    // The escape character must be escaped for the string and
5595                    // again for the regex, thus four escape characters become one.
5596                    String[] strings = value.split("(?<!\\\\),");
5597                    ArrayList<String> list = new ArrayList<>(strings.length);
5598                    for (int i = 0; i < strings.length; i++) {
5599                        list.add(strings[i]);
5600                    }
5601                    intent.putExtra(key, list);
5602                    hasIntentInfo = true;
5603                }
5604                break;
5605                case "--ez": {
5606                    String key = cmd.getNextArgRequired();
5607                    String value = cmd.getNextArgRequired().toLowerCase();
5608                    // Boolean.valueOf() results in false for anything that is not "true", which is
5609                    // error-prone in shell commands
5610                    boolean arg;
5611                    if ("true".equals(value) || "t".equals(value)) {
5612                        arg = true;
5613                    } else if ("false".equals(value) || "f".equals(value)) {
5614                        arg = false;
5615                    } else {
5616                        try {
5617                            arg = Integer.decode(value) != 0;
5618                        } catch (NumberFormatException ex) {
5619                            throw new IllegalArgumentException("Invalid boolean value: " + value);
5620                        }
5621                    }
5622
5623                    intent.putExtra(key, arg);
5624                }
5625                break;
5626                case "-n": {
5627                    String str = cmd.getNextArgRequired();
5628                    ComponentName cn = ComponentName.unflattenFromString(str);
5629                    if (cn == null)
5630                        throw new IllegalArgumentException("Bad component name: " + str);
5631                    intent.setComponent(cn);
5632                    if (intent == baseIntent) {
5633                        hasIntentInfo = true;
5634                    }
5635                }
5636                break;
5637                case "-p": {
5638                    String str = cmd.getNextArgRequired();
5639                    intent.setPackage(str);
5640                    if (intent == baseIntent) {
5641                        hasIntentInfo = true;
5642                    }
5643                }
5644                break;
5645                case "-f":
5646                    String str = cmd.getNextArgRequired();
5647                    intent.setFlags(Integer.decode(str).intValue());
5648                    break;
5649                case "--grant-read-uri-permission":
5650                    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
5651                    break;
5652                case "--grant-write-uri-permission":
5653                    intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
5654                    break;
5655                case "--grant-persistable-uri-permission":
5656                    intent.addFlags(Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION);
5657                    break;
5658                case "--grant-prefix-uri-permission":
5659                    intent.addFlags(Intent.FLAG_GRANT_PREFIX_URI_PERMISSION);
5660                    break;
5661                case "--exclude-stopped-packages":
5662                    intent.addFlags(Intent.FLAG_EXCLUDE_STOPPED_PACKAGES);
5663                    break;
5664                case "--include-stopped-packages":
5665                    intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
5666                    break;
5667                case "--debug-log-resolution":
5668                    intent.addFlags(Intent.FLAG_DEBUG_LOG_RESOLUTION);
5669                    break;
5670                case "--activity-brought-to-front":
5671                    intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
5672                    break;
5673                case "--activity-clear-top":
5674                    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
5675                    break;
5676                case "--activity-clear-when-task-reset":
5677                    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
5678                    break;
5679                case "--activity-exclude-from-recents":
5680                    intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
5681                    break;
5682                case "--activity-launched-from-history":
5683                    intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY);
5684                    break;
5685                case "--activity-multiple-task":
5686                    intent.addFlags(Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
5687                    break;
5688                case "--activity-no-animation":
5689                    intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
5690                    break;
5691                case "--activity-no-history":
5692                    intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
5693                    break;
5694                case "--activity-no-user-action":
5695                    intent.addFlags(Intent.FLAG_ACTIVITY_NO_USER_ACTION);
5696                    break;
5697                case "--activity-previous-is-top":
5698                    intent.addFlags(Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP);
5699                    break;
5700                case "--activity-reorder-to-front":
5701                    intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
5702                    break;
5703                case "--activity-reset-task-if-needed":
5704                    intent.addFlags(Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
5705                    break;
5706                case "--activity-single-top":
5707                    intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
5708                    break;
5709                case "--activity-clear-task":
5710                    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
5711                    break;
5712                case "--activity-task-on-home":
5713                    intent.addFlags(Intent.FLAG_ACTIVITY_TASK_ON_HOME);
5714                    break;
5715                case "--receiver-registered-only":
5716                    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
5717                    break;
5718                case "--receiver-replace-pending":
5719                    intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
5720                    break;
5721                case "--receiver-foreground":
5722                    intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
5723                    break;
5724                case "--selector":
5725                    intent.setDataAndType(data, type);
5726                    intent = new Intent();
5727                    break;
5728                default:
5729                    if (optionHandler != null && optionHandler.handleOption(opt, cmd)) {
5730                        // Okay, caller handled this option.
5731                    } else {
5732                        throw new IllegalArgumentException("Unknown option: " + opt);
5733                    }
5734                    break;
5735            }
5736        }
5737        intent.setDataAndType(data, type);
5738
5739        final boolean hasSelector = intent != baseIntent;
5740        if (hasSelector) {
5741            // A selector was specified; fix up.
5742            baseIntent.setSelector(intent);
5743            intent = baseIntent;
5744        }
5745
5746        String arg = cmd.getNextArg();
5747        baseIntent = null;
5748        if (arg == null) {
5749            if (hasSelector) {
5750                // If a selector has been specified, and no arguments
5751                // have been supplied for the main Intent, then we can
5752                // assume it is ACTION_MAIN CATEGORY_LAUNCHER; we don't
5753                // need to have a component name specified yet, the
5754                // selector will take care of that.
5755                baseIntent = new Intent(Intent.ACTION_MAIN);
5756                baseIntent.addCategory(Intent.CATEGORY_LAUNCHER);
5757            }
5758        } else if (arg.indexOf(':') >= 0) {
5759            // The argument is a URI.  Fully parse it, and use that result
5760            // to fill in any data not specified so far.
5761            baseIntent = Intent.parseUri(arg, Intent.URI_INTENT_SCHEME
5762                    | Intent.URI_ANDROID_APP_SCHEME | Intent.URI_ALLOW_UNSAFE);
5763        } else if (arg.indexOf('/') >= 0) {
5764            // The argument is a component name.  Build an Intent to launch
5765            // it.
5766            baseIntent = new Intent(Intent.ACTION_MAIN);
5767            baseIntent.addCategory(Intent.CATEGORY_LAUNCHER);
5768            baseIntent.setComponent(ComponentName.unflattenFromString(arg));
5769        } else {
5770            // Assume the argument is a package name.
5771            baseIntent = new Intent(Intent.ACTION_MAIN);
5772            baseIntent.addCategory(Intent.CATEGORY_LAUNCHER);
5773            baseIntent.setPackage(arg);
5774        }
5775        if (baseIntent != null) {
5776            Bundle extras = intent.getExtras();
5777            intent.replaceExtras((Bundle)null);
5778            Bundle uriExtras = baseIntent.getExtras();
5779            baseIntent.replaceExtras((Bundle)null);
5780            if (intent.getAction() != null && baseIntent.getCategories() != null) {
5781                HashSet<String> cats = new HashSet<String>(baseIntent.getCategories());
5782                for (String c : cats) {
5783                    baseIntent.removeCategory(c);
5784                }
5785            }
5786            intent.fillIn(baseIntent, Intent.FILL_IN_COMPONENT | Intent.FILL_IN_SELECTOR);
5787            if (extras == null) {
5788                extras = uriExtras;
5789            } else if (uriExtras != null) {
5790                uriExtras.putAll(extras);
5791                extras = uriExtras;
5792            }
5793            intent.replaceExtras(extras);
5794            hasIntentInfo = true;
5795        }
5796
5797        if (!hasIntentInfo) throw new IllegalArgumentException("No intent supplied");
5798        return intent;
5799    }
5800
5801    /** @hide */
5802    public static void printIntentArgsHelp(PrintWriter pw, String prefix) {
5803        final String[] lines = new String[] {
5804                "<INTENT> specifications include these flags and arguments:",
5805                "    [-a <ACTION>] [-d <DATA_URI>] [-t <MIME_TYPE>]",
5806                "    [-c <CATEGORY> [-c <CATEGORY>] ...]",
5807                "    [-e|--es <EXTRA_KEY> <EXTRA_STRING_VALUE> ...]",
5808                "    [--esn <EXTRA_KEY> ...]",
5809                "    [--ez <EXTRA_KEY> <EXTRA_BOOLEAN_VALUE> ...]",
5810                "    [--ei <EXTRA_KEY> <EXTRA_INT_VALUE> ...]",
5811                "    [--el <EXTRA_KEY> <EXTRA_LONG_VALUE> ...]",
5812                "    [--ef <EXTRA_KEY> <EXTRA_FLOAT_VALUE> ...]",
5813                "    [--eu <EXTRA_KEY> <EXTRA_URI_VALUE> ...]",
5814                "    [--ecn <EXTRA_KEY> <EXTRA_COMPONENT_NAME_VALUE>]",
5815                "    [--eia <EXTRA_KEY> <EXTRA_INT_VALUE>[,<EXTRA_INT_VALUE...]]",
5816                "        (mutiple extras passed as Integer[])",
5817                "    [--eial <EXTRA_KEY> <EXTRA_INT_VALUE>[,<EXTRA_INT_VALUE...]]",
5818                "        (mutiple extras passed as List<Integer>)",
5819                "    [--ela <EXTRA_KEY> <EXTRA_LONG_VALUE>[,<EXTRA_LONG_VALUE...]]",
5820                "        (mutiple extras passed as Long[])",
5821                "    [--elal <EXTRA_KEY> <EXTRA_LONG_VALUE>[,<EXTRA_LONG_VALUE...]]",
5822                "        (mutiple extras passed as List<Long>)",
5823                "    [--efa <EXTRA_KEY> <EXTRA_FLOAT_VALUE>[,<EXTRA_FLOAT_VALUE...]]",
5824                "        (mutiple extras passed as Float[])",
5825                "    [--efal <EXTRA_KEY> <EXTRA_FLOAT_VALUE>[,<EXTRA_FLOAT_VALUE...]]",
5826                "        (mutiple extras passed as List<Float>)",
5827                "    [--esa <EXTRA_KEY> <EXTRA_STRING_VALUE>[,<EXTRA_STRING_VALUE...]]",
5828                "        (mutiple extras passed as String[]; to embed a comma into a string,",
5829                "         escape it using \"\\,\")",
5830                "    [--esal <EXTRA_KEY> <EXTRA_STRING_VALUE>[,<EXTRA_STRING_VALUE...]]",
5831                "        (mutiple extras passed as List<String>; to embed a comma into a string,",
5832                "         escape it using \"\\,\")",
5833                "    [--f <FLAG>]",
5834                "    [--grant-read-uri-permission] [--grant-write-uri-permission]",
5835                "    [--grant-persistable-uri-permission] [--grant-prefix-uri-permission]",
5836                "    [--debug-log-resolution] [--exclude-stopped-packages]",
5837                "    [--include-stopped-packages]",
5838                "    [--activity-brought-to-front] [--activity-clear-top]",
5839                "    [--activity-clear-when-task-reset] [--activity-exclude-from-recents]",
5840                "    [--activity-launched-from-history] [--activity-multiple-task]",
5841                "    [--activity-no-animation] [--activity-no-history]",
5842                "    [--activity-no-user-action] [--activity-previous-is-top]",
5843                "    [--activity-reorder-to-front] [--activity-reset-task-if-needed]",
5844                "    [--activity-single-top] [--activity-clear-task]",
5845                "    [--activity-task-on-home]",
5846                "    [--receiver-registered-only] [--receiver-replace-pending]",
5847                "    [--receiver-foreground]",
5848                "    [--selector]",
5849                "    [<URI> | <PACKAGE> | <COMPONENT>]"
5850        };
5851        for (String line : lines) {
5852            pw.print(prefix);
5853            pw.println(line);
5854        }
5855    }
5856
5857    /**
5858     * Retrieve the general action to be performed, such as
5859     * {@link #ACTION_VIEW}.  The action describes the general way the rest of
5860     * the information in the intent should be interpreted -- most importantly,
5861     * what to do with the data returned by {@link #getData}.
5862     *
5863     * @return The action of this intent or null if none is specified.
5864     *
5865     * @see #setAction
5866     */
5867    public String getAction() {
5868        return mAction;
5869    }
5870
5871    /**
5872     * Retrieve data this intent is operating on.  This URI specifies the name
5873     * of the data; often it uses the content: scheme, specifying data in a
5874     * content provider.  Other schemes may be handled by specific activities,
5875     * such as http: by the web browser.
5876     *
5877     * @return The URI of the data this intent is targeting or null.
5878     *
5879     * @see #getScheme
5880     * @see #setData
5881     */
5882    public Uri getData() {
5883        return mData;
5884    }
5885
5886    /**
5887     * The same as {@link #getData()}, but returns the URI as an encoded
5888     * String.
5889     */
5890    public String getDataString() {
5891        return mData != null ? mData.toString() : null;
5892    }
5893
5894    /**
5895     * Return the scheme portion of the intent's data.  If the data is null or
5896     * does not include a scheme, null is returned.  Otherwise, the scheme
5897     * prefix without the final ':' is returned, i.e. "http".
5898     *
5899     * <p>This is the same as calling getData().getScheme() (and checking for
5900     * null data).
5901     *
5902     * @return The scheme of this intent.
5903     *
5904     * @see #getData
5905     */
5906    public String getScheme() {
5907        return mData != null ? mData.getScheme() : null;
5908    }
5909
5910    /**
5911     * Retrieve any explicit MIME type included in the intent.  This is usually
5912     * null, as the type is determined by the intent data.
5913     *
5914     * @return If a type was manually set, it is returned; else null is
5915     *         returned.
5916     *
5917     * @see #resolveType(ContentResolver)
5918     * @see #setType
5919     */
5920    public String getType() {
5921        return mType;
5922    }
5923
5924    /**
5925     * Return the MIME data type of this intent.  If the type field is
5926     * explicitly set, that is simply returned.  Otherwise, if the data is set,
5927     * the type of that data is returned.  If neither fields are set, a null is
5928     * returned.
5929     *
5930     * @return The MIME type of this intent.
5931     *
5932     * @see #getType
5933     * @see #resolveType(ContentResolver)
5934     */
5935    public String resolveType(Context context) {
5936        return resolveType(context.getContentResolver());
5937    }
5938
5939    /**
5940     * Return the MIME data type of this intent.  If the type field is
5941     * explicitly set, that is simply returned.  Otherwise, if the data is set,
5942     * the type of that data is returned.  If neither fields are set, a null is
5943     * returned.
5944     *
5945     * @param resolver A ContentResolver that can be used to determine the MIME
5946     *                 type of the intent's data.
5947     *
5948     * @return The MIME type of this intent.
5949     *
5950     * @see #getType
5951     * @see #resolveType(Context)
5952     */
5953    public String resolveType(ContentResolver resolver) {
5954        if (mType != null) {
5955            return mType;
5956        }
5957        if (mData != null) {
5958            if ("content".equals(mData.getScheme())) {
5959                return resolver.getType(mData);
5960            }
5961        }
5962        return null;
5963    }
5964
5965    /**
5966     * Return the MIME data type of this intent, only if it will be needed for
5967     * intent resolution.  This is not generally useful for application code;
5968     * it is used by the frameworks for communicating with back-end system
5969     * services.
5970     *
5971     * @param resolver A ContentResolver that can be used to determine the MIME
5972     *                 type of the intent's data.
5973     *
5974     * @return The MIME type of this intent, or null if it is unknown or not
5975     *         needed.
5976     */
5977    public String resolveTypeIfNeeded(ContentResolver resolver) {
5978        if (mComponent != null) {
5979            return mType;
5980        }
5981        return resolveType(resolver);
5982    }
5983
5984    /**
5985     * Check if a category exists in the intent.
5986     *
5987     * @param category The category to check.
5988     *
5989     * @return boolean True if the intent contains the category, else false.
5990     *
5991     * @see #getCategories
5992     * @see #addCategory
5993     */
5994    public boolean hasCategory(String category) {
5995        return mCategories != null && mCategories.contains(category);
5996    }
5997
5998    /**
5999     * Return the set of all categories in the intent.  If there are no categories,
6000     * returns NULL.
6001     *
6002     * @return The set of categories you can examine.  Do not modify!
6003     *
6004     * @see #hasCategory
6005     * @see #addCategory
6006     */
6007    public Set<String> getCategories() {
6008        return mCategories;
6009    }
6010
6011    /**
6012     * Return the specific selector associated with this Intent.  If there is
6013     * none, returns null.  See {@link #setSelector} for more information.
6014     *
6015     * @see #setSelector
6016     */
6017    public Intent getSelector() {
6018        return mSelector;
6019    }
6020
6021    /**
6022     * Return the {@link ClipData} associated with this Intent.  If there is
6023     * none, returns null.  See {@link #setClipData} for more information.
6024     *
6025     * @see #setClipData
6026     */
6027    public ClipData getClipData() {
6028        return mClipData;
6029    }
6030
6031    /** @hide */
6032    public int getContentUserHint() {
6033        return mContentUserHint;
6034    }
6035
6036    /**
6037     * Sets the ClassLoader that will be used when unmarshalling
6038     * any Parcelable values from the extras of this Intent.
6039     *
6040     * @param loader a ClassLoader, or null to use the default loader
6041     * at the time of unmarshalling.
6042     */
6043    public void setExtrasClassLoader(ClassLoader loader) {
6044        if (mExtras != null) {
6045            mExtras.setClassLoader(loader);
6046        }
6047    }
6048
6049    /**
6050     * Returns true if an extra value is associated with the given name.
6051     * @param name the extra's name
6052     * @return true if the given extra is present.
6053     */
6054    public boolean hasExtra(String name) {
6055        return mExtras != null && mExtras.containsKey(name);
6056    }
6057
6058    /**
6059     * Returns true if the Intent's extras contain a parcelled file descriptor.
6060     * @return true if the Intent contains a parcelled file descriptor.
6061     */
6062    public boolean hasFileDescriptors() {
6063        return mExtras != null && mExtras.hasFileDescriptors();
6064    }
6065
6066    /** {@hide} */
6067    public void setAllowFds(boolean allowFds) {
6068        if (mExtras != null) {
6069            mExtras.setAllowFds(allowFds);
6070        }
6071    }
6072
6073    /** {@hide} */
6074    public void setDefusable(boolean defusable) {
6075        if (mExtras != null) {
6076            mExtras.setDefusable(defusable);
6077        }
6078    }
6079
6080    /**
6081     * Retrieve extended data from the intent.
6082     *
6083     * @param name The name of the desired item.
6084     *
6085     * @return the value of an item that previously added with putExtra()
6086     * or null if none was found.
6087     *
6088     * @deprecated
6089     * @hide
6090     */
6091    @Deprecated
6092    public Object getExtra(String name) {
6093        return getExtra(name, null);
6094    }
6095
6096    /**
6097     * Retrieve extended data from the intent.
6098     *
6099     * @param name The name of the desired item.
6100     * @param defaultValue the value to be returned if no value of the desired
6101     * type is stored with the given name.
6102     *
6103     * @return the value of an item that previously added with putExtra()
6104     * or the default value if none was found.
6105     *
6106     * @see #putExtra(String, boolean)
6107     */
6108    public boolean getBooleanExtra(String name, boolean defaultValue) {
6109        return mExtras == null ? defaultValue :
6110            mExtras.getBoolean(name, defaultValue);
6111    }
6112
6113    /**
6114     * Retrieve extended data from the intent.
6115     *
6116     * @param name The name of the desired item.
6117     * @param defaultValue the value to be returned if no value of the desired
6118     * type is stored with the given name.
6119     *
6120     * @return the value of an item that previously added with putExtra()
6121     * or the default value if none was found.
6122     *
6123     * @see #putExtra(String, byte)
6124     */
6125    public byte getByteExtra(String name, byte defaultValue) {
6126        return mExtras == null ? defaultValue :
6127            mExtras.getByte(name, defaultValue);
6128    }
6129
6130    /**
6131     * Retrieve extended data from the intent.
6132     *
6133     * @param name The name of the desired item.
6134     * @param defaultValue the value to be returned if no value of the desired
6135     * type is stored with the given name.
6136     *
6137     * @return the value of an item that previously added with putExtra()
6138     * or the default value if none was found.
6139     *
6140     * @see #putExtra(String, short)
6141     */
6142    public short getShortExtra(String name, short defaultValue) {
6143        return mExtras == null ? defaultValue :
6144            mExtras.getShort(name, defaultValue);
6145    }
6146
6147    /**
6148     * Retrieve extended data from the intent.
6149     *
6150     * @param name The name of the desired item.
6151     * @param defaultValue the value to be returned if no value of the desired
6152     * type is stored with the given name.
6153     *
6154     * @return the value of an item that previously added with putExtra()
6155     * or the default value if none was found.
6156     *
6157     * @see #putExtra(String, char)
6158     */
6159    public char getCharExtra(String name, char defaultValue) {
6160        return mExtras == null ? defaultValue :
6161            mExtras.getChar(name, defaultValue);
6162    }
6163
6164    /**
6165     * Retrieve extended data from the intent.
6166     *
6167     * @param name The name of the desired item.
6168     * @param defaultValue the value to be returned if no value of the desired
6169     * type is stored with the given name.
6170     *
6171     * @return the value of an item that previously added with putExtra()
6172     * or the default value if none was found.
6173     *
6174     * @see #putExtra(String, int)
6175     */
6176    public int getIntExtra(String name, int defaultValue) {
6177        return mExtras == null ? defaultValue :
6178            mExtras.getInt(name, defaultValue);
6179    }
6180
6181    /**
6182     * Retrieve extended data from the intent.
6183     *
6184     * @param name The name of the desired item.
6185     * @param defaultValue the value to be returned if no value of the desired
6186     * type is stored with the given name.
6187     *
6188     * @return the value of an item that previously added with putExtra()
6189     * or the default value if none was found.
6190     *
6191     * @see #putExtra(String, long)
6192     */
6193    public long getLongExtra(String name, long defaultValue) {
6194        return mExtras == null ? defaultValue :
6195            mExtras.getLong(name, defaultValue);
6196    }
6197
6198    /**
6199     * Retrieve extended data from the intent.
6200     *
6201     * @param name The name of the desired item.
6202     * @param defaultValue the value to be returned if no value of the desired
6203     * type is stored with the given name.
6204     *
6205     * @return the value of an item that previously added with putExtra(),
6206     * or the default value if no such item is present
6207     *
6208     * @see #putExtra(String, float)
6209     */
6210    public float getFloatExtra(String name, float defaultValue) {
6211        return mExtras == null ? defaultValue :
6212            mExtras.getFloat(name, defaultValue);
6213    }
6214
6215    /**
6216     * Retrieve extended data from the intent.
6217     *
6218     * @param name The name of the desired item.
6219     * @param defaultValue the value to be returned if no value of the desired
6220     * type is stored with the given name.
6221     *
6222     * @return the value of an item that previously added with putExtra()
6223     * or the default value if none was found.
6224     *
6225     * @see #putExtra(String, double)
6226     */
6227    public double getDoubleExtra(String name, double defaultValue) {
6228        return mExtras == null ? defaultValue :
6229            mExtras.getDouble(name, defaultValue);
6230    }
6231
6232    /**
6233     * Retrieve extended data from the intent.
6234     *
6235     * @param name The name of the desired item.
6236     *
6237     * @return the value of an item that previously added with putExtra()
6238     * or null if no String value was found.
6239     *
6240     * @see #putExtra(String, String)
6241     */
6242    public String getStringExtra(String name) {
6243        return mExtras == null ? null : mExtras.getString(name);
6244    }
6245
6246    /**
6247     * Retrieve extended data from the intent.
6248     *
6249     * @param name The name of the desired item.
6250     *
6251     * @return the value of an item that previously added with putExtra()
6252     * or null if no CharSequence value was found.
6253     *
6254     * @see #putExtra(String, CharSequence)
6255     */
6256    public CharSequence getCharSequenceExtra(String name) {
6257        return mExtras == null ? null : mExtras.getCharSequence(name);
6258    }
6259
6260    /**
6261     * Retrieve extended data from the intent.
6262     *
6263     * @param name The name of the desired item.
6264     *
6265     * @return the value of an item that previously added with putExtra()
6266     * or null if no Parcelable value was found.
6267     *
6268     * @see #putExtra(String, Parcelable)
6269     */
6270    public <T extends Parcelable> T getParcelableExtra(String name) {
6271        return mExtras == null ? null : mExtras.<T>getParcelable(name);
6272    }
6273
6274    /**
6275     * Retrieve extended data from the intent.
6276     *
6277     * @param name The name of the desired item.
6278     *
6279     * @return the value of an item that previously added with putExtra()
6280     * or null if no Parcelable[] value was found.
6281     *
6282     * @see #putExtra(String, Parcelable[])
6283     */
6284    public Parcelable[] getParcelableArrayExtra(String name) {
6285        return mExtras == null ? null : mExtras.getParcelableArray(name);
6286    }
6287
6288    /**
6289     * Retrieve extended data from the intent.
6290     *
6291     * @param name The name of the desired item.
6292     *
6293     * @return the value of an item that previously added with putExtra()
6294     * or null if no ArrayList<Parcelable> value was found.
6295     *
6296     * @see #putParcelableArrayListExtra(String, ArrayList)
6297     */
6298    public <T extends Parcelable> ArrayList<T> getParcelableArrayListExtra(String name) {
6299        return mExtras == null ? null : mExtras.<T>getParcelableArrayList(name);
6300    }
6301
6302    /**
6303     * Retrieve extended data from the intent.
6304     *
6305     * @param name The name of the desired item.
6306     *
6307     * @return the value of an item that previously added with putExtra()
6308     * or null if no Serializable value was found.
6309     *
6310     * @see #putExtra(String, Serializable)
6311     */
6312    public Serializable getSerializableExtra(String name) {
6313        return mExtras == null ? null : mExtras.getSerializable(name);
6314    }
6315
6316    /**
6317     * Retrieve extended data from the intent.
6318     *
6319     * @param name The name of the desired item.
6320     *
6321     * @return the value of an item that previously added with putExtra()
6322     * or null if no ArrayList<Integer> value was found.
6323     *
6324     * @see #putIntegerArrayListExtra(String, ArrayList)
6325     */
6326    public ArrayList<Integer> getIntegerArrayListExtra(String name) {
6327        return mExtras == null ? null : mExtras.getIntegerArrayList(name);
6328    }
6329
6330    /**
6331     * Retrieve extended data from the intent.
6332     *
6333     * @param name The name of the desired item.
6334     *
6335     * @return the value of an item that previously added with putExtra()
6336     * or null if no ArrayList<String> value was found.
6337     *
6338     * @see #putStringArrayListExtra(String, ArrayList)
6339     */
6340    public ArrayList<String> getStringArrayListExtra(String name) {
6341        return mExtras == null ? null : mExtras.getStringArrayList(name);
6342    }
6343
6344    /**
6345     * Retrieve extended data from the intent.
6346     *
6347     * @param name The name of the desired item.
6348     *
6349     * @return the value of an item that previously added with putExtra()
6350     * or null if no ArrayList<CharSequence> value was found.
6351     *
6352     * @see #putCharSequenceArrayListExtra(String, ArrayList)
6353     */
6354    public ArrayList<CharSequence> getCharSequenceArrayListExtra(String name) {
6355        return mExtras == null ? null : mExtras.getCharSequenceArrayList(name);
6356    }
6357
6358    /**
6359     * Retrieve extended data from the intent.
6360     *
6361     * @param name The name of the desired item.
6362     *
6363     * @return the value of an item that previously added with putExtra()
6364     * or null if no boolean array value was found.
6365     *
6366     * @see #putExtra(String, boolean[])
6367     */
6368    public boolean[] getBooleanArrayExtra(String name) {
6369        return mExtras == null ? null : mExtras.getBooleanArray(name);
6370    }
6371
6372    /**
6373     * Retrieve extended data from the intent.
6374     *
6375     * @param name The name of the desired item.
6376     *
6377     * @return the value of an item that previously added with putExtra()
6378     * or null if no byte array value was found.
6379     *
6380     * @see #putExtra(String, byte[])
6381     */
6382    public byte[] getByteArrayExtra(String name) {
6383        return mExtras == null ? null : mExtras.getByteArray(name);
6384    }
6385
6386    /**
6387     * Retrieve extended data from the intent.
6388     *
6389     * @param name The name of the desired item.
6390     *
6391     * @return the value of an item that previously added with putExtra()
6392     * or null if no short array value was found.
6393     *
6394     * @see #putExtra(String, short[])
6395     */
6396    public short[] getShortArrayExtra(String name) {
6397        return mExtras == null ? null : mExtras.getShortArray(name);
6398    }
6399
6400    /**
6401     * Retrieve extended data from the intent.
6402     *
6403     * @param name The name of the desired item.
6404     *
6405     * @return the value of an item that previously added with putExtra()
6406     * or null if no char array value was found.
6407     *
6408     * @see #putExtra(String, char[])
6409     */
6410    public char[] getCharArrayExtra(String name) {
6411        return mExtras == null ? null : mExtras.getCharArray(name);
6412    }
6413
6414    /**
6415     * Retrieve extended data from the intent.
6416     *
6417     * @param name The name of the desired item.
6418     *
6419     * @return the value of an item that previously added with putExtra()
6420     * or null if no int array value was found.
6421     *
6422     * @see #putExtra(String, int[])
6423     */
6424    public int[] getIntArrayExtra(String name) {
6425        return mExtras == null ? null : mExtras.getIntArray(name);
6426    }
6427
6428    /**
6429     * Retrieve extended data from the intent.
6430     *
6431     * @param name The name of the desired item.
6432     *
6433     * @return the value of an item that previously added with putExtra()
6434     * or null if no long array value was found.
6435     *
6436     * @see #putExtra(String, long[])
6437     */
6438    public long[] getLongArrayExtra(String name) {
6439        return mExtras == null ? null : mExtras.getLongArray(name);
6440    }
6441
6442    /**
6443     * Retrieve extended data from the intent.
6444     *
6445     * @param name The name of the desired item.
6446     *
6447     * @return the value of an item that previously added with putExtra()
6448     * or null if no float array value was found.
6449     *
6450     * @see #putExtra(String, float[])
6451     */
6452    public float[] getFloatArrayExtra(String name) {
6453        return mExtras == null ? null : mExtras.getFloatArray(name);
6454    }
6455
6456    /**
6457     * Retrieve extended data from the intent.
6458     *
6459     * @param name The name of the desired item.
6460     *
6461     * @return the value of an item that previously added with putExtra()
6462     * or null if no double array value was found.
6463     *
6464     * @see #putExtra(String, double[])
6465     */
6466    public double[] getDoubleArrayExtra(String name) {
6467        return mExtras == null ? null : mExtras.getDoubleArray(name);
6468    }
6469
6470    /**
6471     * Retrieve extended data from the intent.
6472     *
6473     * @param name The name of the desired item.
6474     *
6475     * @return the value of an item that previously added with putExtra()
6476     * or null if no String array value was found.
6477     *
6478     * @see #putExtra(String, String[])
6479     */
6480    public String[] getStringArrayExtra(String name) {
6481        return mExtras == null ? null : mExtras.getStringArray(name);
6482    }
6483
6484    /**
6485     * Retrieve extended data from the intent.
6486     *
6487     * @param name The name of the desired item.
6488     *
6489     * @return the value of an item that previously added with putExtra()
6490     * or null if no CharSequence array value was found.
6491     *
6492     * @see #putExtra(String, CharSequence[])
6493     */
6494    public CharSequence[] getCharSequenceArrayExtra(String name) {
6495        return mExtras == null ? null : mExtras.getCharSequenceArray(name);
6496    }
6497
6498    /**
6499     * Retrieve extended data from the intent.
6500     *
6501     * @param name The name of the desired item.
6502     *
6503     * @return the value of an item that previously added with putExtra()
6504     * or null if no Bundle value was found.
6505     *
6506     * @see #putExtra(String, Bundle)
6507     */
6508    public Bundle getBundleExtra(String name) {
6509        return mExtras == null ? null : mExtras.getBundle(name);
6510    }
6511
6512    /**
6513     * Retrieve extended data from the intent.
6514     *
6515     * @param name The name of the desired item.
6516     *
6517     * @return the value of an item that previously added with putExtra()
6518     * or null if no IBinder value was found.
6519     *
6520     * @see #putExtra(String, IBinder)
6521     *
6522     * @deprecated
6523     * @hide
6524     */
6525    @Deprecated
6526    public IBinder getIBinderExtra(String name) {
6527        return mExtras == null ? null : mExtras.getIBinder(name);
6528    }
6529
6530    /**
6531     * Retrieve extended data from the intent.
6532     *
6533     * @param name The name of the desired item.
6534     * @param defaultValue The default value to return in case no item is
6535     * associated with the key 'name'
6536     *
6537     * @return the value of an item that previously added with putExtra()
6538     * or defaultValue if none was found.
6539     *
6540     * @see #putExtra
6541     *
6542     * @deprecated
6543     * @hide
6544     */
6545    @Deprecated
6546    public Object getExtra(String name, Object defaultValue) {
6547        Object result = defaultValue;
6548        if (mExtras != null) {
6549            Object result2 = mExtras.get(name);
6550            if (result2 != null) {
6551                result = result2;
6552            }
6553        }
6554
6555        return result;
6556    }
6557
6558    /**
6559     * Retrieves a map of extended data from the intent.
6560     *
6561     * @return the map of all extras previously added with putExtra(),
6562     * or null if none have been added.
6563     */
6564    public Bundle getExtras() {
6565        return (mExtras != null)
6566                ? new Bundle(mExtras)
6567                : null;
6568    }
6569
6570    /**
6571     * Filter extras to only basic types.
6572     * @hide
6573     */
6574    public void removeUnsafeExtras() {
6575        if (mExtras != null) {
6576            mExtras = mExtras.filterValues();
6577        }
6578    }
6579
6580    /**
6581     * Retrieve any special flags associated with this intent.  You will
6582     * normally just set them with {@link #setFlags} and let the system
6583     * take the appropriate action with them.
6584     *
6585     * @return int The currently set flags.
6586     *
6587     * @see #setFlags
6588     */
6589    public int getFlags() {
6590        return mFlags;
6591    }
6592
6593    /** @hide */
6594    public boolean isExcludingStopped() {
6595        return (mFlags&(FLAG_EXCLUDE_STOPPED_PACKAGES|FLAG_INCLUDE_STOPPED_PACKAGES))
6596                == FLAG_EXCLUDE_STOPPED_PACKAGES;
6597    }
6598
6599    /**
6600     * Retrieve the application package name this Intent is limited to.  When
6601     * resolving an Intent, if non-null this limits the resolution to only
6602     * components in the given application package.
6603     *
6604     * @return The name of the application package for the Intent.
6605     *
6606     * @see #resolveActivity
6607     * @see #setPackage
6608     */
6609    public String getPackage() {
6610        return mPackage;
6611    }
6612
6613    /**
6614     * Retrieve the concrete component associated with the intent.  When receiving
6615     * an intent, this is the component that was found to best handle it (that is,
6616     * yourself) and will always be non-null; in all other cases it will be
6617     * null unless explicitly set.
6618     *
6619     * @return The name of the application component to handle the intent.
6620     *
6621     * @see #resolveActivity
6622     * @see #setComponent
6623     */
6624    public ComponentName getComponent() {
6625        return mComponent;
6626    }
6627
6628    /**
6629     * Get the bounds of the sender of this intent, in screen coordinates.  This can be
6630     * used as a hint to the receiver for animations and the like.  Null means that there
6631     * is no source bounds.
6632     */
6633    public Rect getSourceBounds() {
6634        return mSourceBounds;
6635    }
6636
6637    /**
6638     * Return the Activity component that should be used to handle this intent.
6639     * The appropriate component is determined based on the information in the
6640     * intent, evaluated as follows:
6641     *
6642     * <p>If {@link #getComponent} returns an explicit class, that is returned
6643     * without any further consideration.
6644     *
6645     * <p>The activity must handle the {@link Intent#CATEGORY_DEFAULT} Intent
6646     * category to be considered.
6647     *
6648     * <p>If {@link #getAction} is non-NULL, the activity must handle this
6649     * action.
6650     *
6651     * <p>If {@link #resolveType} returns non-NULL, the activity must handle
6652     * this type.
6653     *
6654     * <p>If {@link #addCategory} has added any categories, the activity must
6655     * handle ALL of the categories specified.
6656     *
6657     * <p>If {@link #getPackage} is non-NULL, only activity components in
6658     * that application package will be considered.
6659     *
6660     * <p>If there are no activities that satisfy all of these conditions, a
6661     * null string is returned.
6662     *
6663     * <p>If multiple activities are found to satisfy the intent, the one with
6664     * the highest priority will be used.  If there are multiple activities
6665     * with the same priority, the system will either pick the best activity
6666     * based on user preference, or resolve to a system class that will allow
6667     * the user to pick an activity and forward from there.
6668     *
6669     * <p>This method is implemented simply by calling
6670     * {@link PackageManager#resolveActivity} with the "defaultOnly" parameter
6671     * true.</p>
6672     * <p> This API is called for you as part of starting an activity from an
6673     * intent.  You do not normally need to call it yourself.</p>
6674     *
6675     * @param pm The package manager with which to resolve the Intent.
6676     *
6677     * @return Name of the component implementing an activity that can
6678     *         display the intent.
6679     *
6680     * @see #setComponent
6681     * @see #getComponent
6682     * @see #resolveActivityInfo
6683     */
6684    public ComponentName resolveActivity(PackageManager pm) {
6685        if (mComponent != null) {
6686            return mComponent;
6687        }
6688
6689        ResolveInfo info = pm.resolveActivity(
6690            this, PackageManager.MATCH_DEFAULT_ONLY);
6691        if (info != null) {
6692            return new ComponentName(
6693                    info.activityInfo.applicationInfo.packageName,
6694                    info.activityInfo.name);
6695        }
6696
6697        return null;
6698    }
6699
6700    /**
6701     * Resolve the Intent into an {@link ActivityInfo}
6702     * describing the activity that should execute the intent.  Resolution
6703     * follows the same rules as described for {@link #resolveActivity}, but
6704     * you get back the completely information about the resolved activity
6705     * instead of just its class name.
6706     *
6707     * @param pm The package manager with which to resolve the Intent.
6708     * @param flags Addition information to retrieve as per
6709     * {@link PackageManager#getActivityInfo(ComponentName, int)
6710     * PackageManager.getActivityInfo()}.
6711     *
6712     * @return PackageManager.ActivityInfo
6713     *
6714     * @see #resolveActivity
6715     */
6716    public ActivityInfo resolveActivityInfo(PackageManager pm, int flags) {
6717        ActivityInfo ai = null;
6718        if (mComponent != null) {
6719            try {
6720                ai = pm.getActivityInfo(mComponent, flags);
6721            } catch (PackageManager.NameNotFoundException e) {
6722                // ignore
6723            }
6724        } else {
6725            ResolveInfo info = pm.resolveActivity(
6726                this, PackageManager.MATCH_DEFAULT_ONLY | flags);
6727            if (info != null) {
6728                ai = info.activityInfo;
6729            }
6730        }
6731
6732        return ai;
6733    }
6734
6735    /**
6736     * Special function for use by the system to resolve service
6737     * intents to system apps.  Throws an exception if there are
6738     * multiple potential matches to the Intent.  Returns null if
6739     * there are no matches.
6740     * @hide
6741     */
6742    public ComponentName resolveSystemService(PackageManager pm, int flags) {
6743        if (mComponent != null) {
6744            return mComponent;
6745        }
6746
6747        List<ResolveInfo> results = pm.queryIntentServices(this, flags);
6748        if (results == null) {
6749            return null;
6750        }
6751        ComponentName comp = null;
6752        for (int i=0; i<results.size(); i++) {
6753            ResolveInfo ri = results.get(i);
6754            if ((ri.serviceInfo.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) == 0) {
6755                continue;
6756            }
6757            ComponentName foundComp = new ComponentName(ri.serviceInfo.applicationInfo.packageName,
6758                    ri.serviceInfo.name);
6759            if (comp != null) {
6760                throw new IllegalStateException("Multiple system services handle " + this
6761                        + ": " + comp + ", " + foundComp);
6762            }
6763            comp = foundComp;
6764        }
6765        return comp;
6766    }
6767
6768    /**
6769     * Set the general action to be performed.
6770     *
6771     * @param action An action name, such as ACTION_VIEW.  Application-specific
6772     *               actions should be prefixed with the vendor's package name.
6773     *
6774     * @return Returns the same Intent object, for chaining multiple calls
6775     * into a single statement.
6776     *
6777     * @see #getAction
6778     */
6779    public Intent setAction(String action) {
6780        mAction = action != null ? action.intern() : null;
6781        return this;
6782    }
6783
6784    /**
6785     * Set the data this intent is operating on.  This method automatically
6786     * clears any type that was previously set by {@link #setType} or
6787     * {@link #setTypeAndNormalize}.
6788     *
6789     * <p><em>Note: scheme matching in the Android framework is
6790     * case-sensitive, unlike the formal RFC. As a result,
6791     * you should always write your Uri with a lower case scheme,
6792     * or use {@link Uri#normalizeScheme} or
6793     * {@link #setDataAndNormalize}
6794     * to ensure that the scheme is converted to lower case.</em>
6795     *
6796     * @param data The Uri of the data this intent is now targeting.
6797     *
6798     * @return Returns the same Intent object, for chaining multiple calls
6799     * into a single statement.
6800     *
6801     * @see #getData
6802     * @see #setDataAndNormalize
6803     * @see android.net.Uri#normalizeScheme()
6804     */
6805    public Intent setData(Uri data) {
6806        mData = data;
6807        mType = null;
6808        return this;
6809    }
6810
6811    /**
6812     * Normalize and set the data this intent is operating on.
6813     *
6814     * <p>This method automatically clears any type that was
6815     * previously set (for example, by {@link #setType}).
6816     *
6817     * <p>The data Uri is normalized using
6818     * {@link android.net.Uri#normalizeScheme} before it is set,
6819     * so really this is just a convenience method for
6820     * <pre>
6821     * setData(data.normalize())
6822     * </pre>
6823     *
6824     * @param data The Uri of the data this intent is now targeting.
6825     *
6826     * @return Returns the same Intent object, for chaining multiple calls
6827     * into a single statement.
6828     *
6829     * @see #getData
6830     * @see #setType
6831     * @see android.net.Uri#normalizeScheme
6832     */
6833    public Intent setDataAndNormalize(Uri data) {
6834        return setData(data.normalizeScheme());
6835    }
6836
6837    /**
6838     * Set an explicit MIME data type.
6839     *
6840     * <p>This is used to create intents that only specify a type and not data,
6841     * for example to indicate the type of data to return.
6842     *
6843     * <p>This method automatically clears any data that was
6844     * previously set (for example by {@link #setData}).
6845     *
6846     * <p><em>Note: MIME type matching in the Android framework is
6847     * case-sensitive, unlike formal RFC MIME types.  As a result,
6848     * you should always write your MIME types with lower case letters,
6849     * or use {@link #normalizeMimeType} or {@link #setTypeAndNormalize}
6850     * to ensure that it is converted to lower case.</em>
6851     *
6852     * @param type The MIME type of the data being handled by this intent.
6853     *
6854     * @return Returns the same Intent object, for chaining multiple calls
6855     * into a single statement.
6856     *
6857     * @see #getType
6858     * @see #setTypeAndNormalize
6859     * @see #setDataAndType
6860     * @see #normalizeMimeType
6861     */
6862    public Intent setType(String type) {
6863        mData = null;
6864        mType = type;
6865        return this;
6866    }
6867
6868    /**
6869     * Normalize and set an explicit MIME data type.
6870     *
6871     * <p>This is used to create intents that only specify a type and not data,
6872     * for example to indicate the type of data to return.
6873     *
6874     * <p>This method automatically clears any data that was
6875     * previously set (for example by {@link #setData}).
6876     *
6877     * <p>The MIME type is normalized using
6878     * {@link #normalizeMimeType} before it is set,
6879     * so really this is just a convenience method for
6880     * <pre>
6881     * setType(Intent.normalizeMimeType(type))
6882     * </pre>
6883     *
6884     * @param type The MIME type of the data being handled by this intent.
6885     *
6886     * @return Returns the same Intent object, for chaining multiple calls
6887     * into a single statement.
6888     *
6889     * @see #getType
6890     * @see #setData
6891     * @see #normalizeMimeType
6892     */
6893    public Intent setTypeAndNormalize(String type) {
6894        return setType(normalizeMimeType(type));
6895    }
6896
6897    /**
6898     * (Usually optional) Set the data for the intent along with an explicit
6899     * MIME data type.  This method should very rarely be used -- it allows you
6900     * to override the MIME type that would ordinarily be inferred from the
6901     * data with your own type given here.
6902     *
6903     * <p><em>Note: MIME type and Uri scheme matching in the
6904     * Android framework is case-sensitive, unlike the formal RFC definitions.
6905     * As a result, you should always write these elements with lower case letters,
6906     * or use {@link #normalizeMimeType} or {@link android.net.Uri#normalizeScheme} or
6907     * {@link #setDataAndTypeAndNormalize}
6908     * to ensure that they are converted to lower case.</em>
6909     *
6910     * @param data The Uri of the data this intent is now targeting.
6911     * @param type The MIME type of the data being handled by this intent.
6912     *
6913     * @return Returns the same Intent object, for chaining multiple calls
6914     * into a single statement.
6915     *
6916     * @see #setType
6917     * @see #setData
6918     * @see #normalizeMimeType
6919     * @see android.net.Uri#normalizeScheme
6920     * @see #setDataAndTypeAndNormalize
6921     */
6922    public Intent setDataAndType(Uri data, String type) {
6923        mData = data;
6924        mType = type;
6925        return this;
6926    }
6927
6928    /**
6929     * (Usually optional) Normalize and set both the data Uri and an explicit
6930     * MIME data type.  This method should very rarely be used -- it allows you
6931     * to override the MIME type that would ordinarily be inferred from the
6932     * data with your own type given here.
6933     *
6934     * <p>The data Uri and the MIME type are normalize using
6935     * {@link android.net.Uri#normalizeScheme} and {@link #normalizeMimeType}
6936     * before they are set, so really this is just a convenience method for
6937     * <pre>
6938     * setDataAndType(data.normalize(), Intent.normalizeMimeType(type))
6939     * </pre>
6940     *
6941     * @param data The Uri of the data this intent is now targeting.
6942     * @param type The MIME type of the data being handled by this intent.
6943     *
6944     * @return Returns the same Intent object, for chaining multiple calls
6945     * into a single statement.
6946     *
6947     * @see #setType
6948     * @see #setData
6949     * @see #setDataAndType
6950     * @see #normalizeMimeType
6951     * @see android.net.Uri#normalizeScheme
6952     */
6953    public Intent setDataAndTypeAndNormalize(Uri data, String type) {
6954        return setDataAndType(data.normalizeScheme(), normalizeMimeType(type));
6955    }
6956
6957    /**
6958     * Add a new category to the intent.  Categories provide additional detail
6959     * about the action the intent performs.  When resolving an intent, only
6960     * activities that provide <em>all</em> of the requested categories will be
6961     * used.
6962     *
6963     * @param category The desired category.  This can be either one of the
6964     *               predefined Intent categories, or a custom category in your own
6965     *               namespace.
6966     *
6967     * @return Returns the same Intent object, for chaining multiple calls
6968     * into a single statement.
6969     *
6970     * @see #hasCategory
6971     * @see #removeCategory
6972     */
6973    public Intent addCategory(String category) {
6974        if (mCategories == null) {
6975            mCategories = new ArraySet<String>();
6976        }
6977        mCategories.add(category.intern());
6978        return this;
6979    }
6980
6981    /**
6982     * Remove a category from an intent.
6983     *
6984     * @param category The category to remove.
6985     *
6986     * @see #addCategory
6987     */
6988    public void removeCategory(String category) {
6989        if (mCategories != null) {
6990            mCategories.remove(category);
6991            if (mCategories.size() == 0) {
6992                mCategories = null;
6993            }
6994        }
6995    }
6996
6997    /**
6998     * Set a selector for this Intent.  This is a modification to the kinds of
6999     * things the Intent will match.  If the selector is set, it will be used
7000     * when trying to find entities that can handle the Intent, instead of the
7001     * main contents of the Intent.  This allows you build an Intent containing
7002     * a generic protocol while targeting it more specifically.
7003     *
7004     * <p>An example of where this may be used is with things like
7005     * {@link #CATEGORY_APP_BROWSER}.  This category allows you to build an
7006     * Intent that will launch the Browser application.  However, the correct
7007     * main entry point of an application is actually {@link #ACTION_MAIN}
7008     * {@link #CATEGORY_LAUNCHER} with {@link #setComponent(ComponentName)}
7009     * used to specify the actual Activity to launch.  If you launch the browser
7010     * with something different, undesired behavior may happen if the user has
7011     * previously or later launches it the normal way, since they do not match.
7012     * Instead, you can build an Intent with the MAIN action (but no ComponentName
7013     * yet specified) and set a selector with {@link #ACTION_MAIN} and
7014     * {@link #CATEGORY_APP_BROWSER} to point it specifically to the browser activity.
7015     *
7016     * <p>Setting a selector does not impact the behavior of
7017     * {@link #filterEquals(Intent)} and {@link #filterHashCode()}.  This is part of the
7018     * desired behavior of a selector -- it does not impact the base meaning
7019     * of the Intent, just what kinds of things will be matched against it
7020     * when determining who can handle it.</p>
7021     *
7022     * <p>You can not use both a selector and {@link #setPackage(String)} on
7023     * the same base Intent.</p>
7024     *
7025     * @param selector The desired selector Intent; set to null to not use
7026     * a special selector.
7027     */
7028    public void setSelector(Intent selector) {
7029        if (selector == this) {
7030            throw new IllegalArgumentException(
7031                    "Intent being set as a selector of itself");
7032        }
7033        if (selector != null && mPackage != null) {
7034            throw new IllegalArgumentException(
7035                    "Can't set selector when package name is already set");
7036        }
7037        mSelector = selector;
7038    }
7039
7040    /**
7041     * Set a {@link ClipData} associated with this Intent.  This replaces any
7042     * previously set ClipData.
7043     *
7044     * <p>The ClipData in an intent is not used for Intent matching or other
7045     * such operations.  Semantically it is like extras, used to transmit
7046     * additional data with the Intent.  The main feature of using this over
7047     * the extras for data is that {@link #FLAG_GRANT_READ_URI_PERMISSION}
7048     * and {@link #FLAG_GRANT_WRITE_URI_PERMISSION} will operate on any URI
7049     * items included in the clip data.  This is useful, in particular, if
7050     * you want to transmit an Intent containing multiple <code>content:</code>
7051     * URIs for which the recipient may not have global permission to access the
7052     * content provider.
7053     *
7054     * <p>If the ClipData contains items that are themselves Intents, any
7055     * grant flags in those Intents will be ignored.  Only the top-level flags
7056     * of the main Intent are respected, and will be applied to all Uri or
7057     * Intent items in the clip (or sub-items of the clip).
7058     *
7059     * <p>The MIME type, label, and icon in the ClipData object are not
7060     * directly used by Intent.  Applications should generally rely on the
7061     * MIME type of the Intent itself, not what it may find in the ClipData.
7062     * A common practice is to construct a ClipData for use with an Intent
7063     * with a MIME type of "*&#47;*".
7064     *
7065     * @param clip The new clip to set.  May be null to clear the current clip.
7066     */
7067    public void setClipData(ClipData clip) {
7068        mClipData = clip;
7069    }
7070
7071    /**
7072     * This is NOT a secure mechanism to identify the user who sent the intent.
7073     * When the intent is sent to a different user, it is used to fix uris by adding the userId
7074     * who sent the intent.
7075     * @hide
7076     */
7077    public void prepareToLeaveUser(int userId) {
7078        // If mContentUserHint is not UserHandle.USER_CURRENT, the intent has already left a user.
7079        // We want mContentUserHint to refer to the original user, so don't do anything.
7080        if (mContentUserHint == UserHandle.USER_CURRENT) {
7081            mContentUserHint = userId;
7082        }
7083    }
7084
7085    /**
7086     * Add extended data to the intent.  The name must include a package
7087     * prefix, for example the app com.android.contacts would use names
7088     * like "com.android.contacts.ShowAll".
7089     *
7090     * @param name The name of the extra data, with package prefix.
7091     * @param value The boolean data value.
7092     *
7093     * @return Returns the same Intent object, for chaining multiple calls
7094     * into a single statement.
7095     *
7096     * @see #putExtras
7097     * @see #removeExtra
7098     * @see #getBooleanExtra(String, boolean)
7099     */
7100    public Intent putExtra(String name, boolean value) {
7101        if (mExtras == null) {
7102            mExtras = new Bundle();
7103        }
7104        mExtras.putBoolean(name, value);
7105        return this;
7106    }
7107
7108    /**
7109     * Add extended data to the intent.  The name must include a package
7110     * prefix, for example the app com.android.contacts would use names
7111     * like "com.android.contacts.ShowAll".
7112     *
7113     * @param name The name of the extra data, with package prefix.
7114     * @param value The byte data value.
7115     *
7116     * @return Returns the same Intent object, for chaining multiple calls
7117     * into a single statement.
7118     *
7119     * @see #putExtras
7120     * @see #removeExtra
7121     * @see #getByteExtra(String, byte)
7122     */
7123    public Intent putExtra(String name, byte value) {
7124        if (mExtras == null) {
7125            mExtras = new Bundle();
7126        }
7127        mExtras.putByte(name, value);
7128        return this;
7129    }
7130
7131    /**
7132     * Add extended data to the intent.  The name must include a package
7133     * prefix, for example the app com.android.contacts would use names
7134     * like "com.android.contacts.ShowAll".
7135     *
7136     * @param name The name of the extra data, with package prefix.
7137     * @param value The char data value.
7138     *
7139     * @return Returns the same Intent object, for chaining multiple calls
7140     * into a single statement.
7141     *
7142     * @see #putExtras
7143     * @see #removeExtra
7144     * @see #getCharExtra(String, char)
7145     */
7146    public Intent putExtra(String name, char value) {
7147        if (mExtras == null) {
7148            mExtras = new Bundle();
7149        }
7150        mExtras.putChar(name, value);
7151        return this;
7152    }
7153
7154    /**
7155     * Add extended data to the intent.  The name must include a package
7156     * prefix, for example the app com.android.contacts would use names
7157     * like "com.android.contacts.ShowAll".
7158     *
7159     * @param name The name of the extra data, with package prefix.
7160     * @param value The short data value.
7161     *
7162     * @return Returns the same Intent object, for chaining multiple calls
7163     * into a single statement.
7164     *
7165     * @see #putExtras
7166     * @see #removeExtra
7167     * @see #getShortExtra(String, short)
7168     */
7169    public Intent putExtra(String name, short value) {
7170        if (mExtras == null) {
7171            mExtras = new Bundle();
7172        }
7173        mExtras.putShort(name, value);
7174        return this;
7175    }
7176
7177    /**
7178     * Add extended data to the intent.  The name must include a package
7179     * prefix, for example the app com.android.contacts would use names
7180     * like "com.android.contacts.ShowAll".
7181     *
7182     * @param name The name of the extra data, with package prefix.
7183     * @param value The integer data value.
7184     *
7185     * @return Returns the same Intent object, for chaining multiple calls
7186     * into a single statement.
7187     *
7188     * @see #putExtras
7189     * @see #removeExtra
7190     * @see #getIntExtra(String, int)
7191     */
7192    public Intent putExtra(String name, int value) {
7193        if (mExtras == null) {
7194            mExtras = new Bundle();
7195        }
7196        mExtras.putInt(name, value);
7197        return this;
7198    }
7199
7200    /**
7201     * Add extended data to the intent.  The name must include a package
7202     * prefix, for example the app com.android.contacts would use names
7203     * like "com.android.contacts.ShowAll".
7204     *
7205     * @param name The name of the extra data, with package prefix.
7206     * @param value The long data value.
7207     *
7208     * @return Returns the same Intent object, for chaining multiple calls
7209     * into a single statement.
7210     *
7211     * @see #putExtras
7212     * @see #removeExtra
7213     * @see #getLongExtra(String, long)
7214     */
7215    public Intent putExtra(String name, long value) {
7216        if (mExtras == null) {
7217            mExtras = new Bundle();
7218        }
7219        mExtras.putLong(name, value);
7220        return this;
7221    }
7222
7223    /**
7224     * Add extended data to the intent.  The name must include a package
7225     * prefix, for example the app com.android.contacts would use names
7226     * like "com.android.contacts.ShowAll".
7227     *
7228     * @param name The name of the extra data, with package prefix.
7229     * @param value The float data value.
7230     *
7231     * @return Returns the same Intent object, for chaining multiple calls
7232     * into a single statement.
7233     *
7234     * @see #putExtras
7235     * @see #removeExtra
7236     * @see #getFloatExtra(String, float)
7237     */
7238    public Intent putExtra(String name, float value) {
7239        if (mExtras == null) {
7240            mExtras = new Bundle();
7241        }
7242        mExtras.putFloat(name, value);
7243        return this;
7244    }
7245
7246    /**
7247     * Add extended data to the intent.  The name must include a package
7248     * prefix, for example the app com.android.contacts would use names
7249     * like "com.android.contacts.ShowAll".
7250     *
7251     * @param name The name of the extra data, with package prefix.
7252     * @param value The double data value.
7253     *
7254     * @return Returns the same Intent object, for chaining multiple calls
7255     * into a single statement.
7256     *
7257     * @see #putExtras
7258     * @see #removeExtra
7259     * @see #getDoubleExtra(String, double)
7260     */
7261    public Intent putExtra(String name, double value) {
7262        if (mExtras == null) {
7263            mExtras = new Bundle();
7264        }
7265        mExtras.putDouble(name, value);
7266        return this;
7267    }
7268
7269    /**
7270     * Add extended data to the intent.  The name must include a package
7271     * prefix, for example the app com.android.contacts would use names
7272     * like "com.android.contacts.ShowAll".
7273     *
7274     * @param name The name of the extra data, with package prefix.
7275     * @param value The String data value.
7276     *
7277     * @return Returns the same Intent object, for chaining multiple calls
7278     * into a single statement.
7279     *
7280     * @see #putExtras
7281     * @see #removeExtra
7282     * @see #getStringExtra(String)
7283     */
7284    public Intent putExtra(String name, String value) {
7285        if (mExtras == null) {
7286            mExtras = new Bundle();
7287        }
7288        mExtras.putString(name, value);
7289        return this;
7290    }
7291
7292    /**
7293     * Add extended data to the intent.  The name must include a package
7294     * prefix, for example the app com.android.contacts would use names
7295     * like "com.android.contacts.ShowAll".
7296     *
7297     * @param name The name of the extra data, with package prefix.
7298     * @param value The CharSequence data value.
7299     *
7300     * @return Returns the same Intent object, for chaining multiple calls
7301     * into a single statement.
7302     *
7303     * @see #putExtras
7304     * @see #removeExtra
7305     * @see #getCharSequenceExtra(String)
7306     */
7307    public Intent putExtra(String name, CharSequence value) {
7308        if (mExtras == null) {
7309            mExtras = new Bundle();
7310        }
7311        mExtras.putCharSequence(name, value);
7312        return this;
7313    }
7314
7315    /**
7316     * Add extended data to the intent.  The name must include a package
7317     * prefix, for example the app com.android.contacts would use names
7318     * like "com.android.contacts.ShowAll".
7319     *
7320     * @param name The name of the extra data, with package prefix.
7321     * @param value The Parcelable data value.
7322     *
7323     * @return Returns the same Intent object, for chaining multiple calls
7324     * into a single statement.
7325     *
7326     * @see #putExtras
7327     * @see #removeExtra
7328     * @see #getParcelableExtra(String)
7329     */
7330    public Intent putExtra(String name, Parcelable value) {
7331        if (mExtras == null) {
7332            mExtras = new Bundle();
7333        }
7334        mExtras.putParcelable(name, value);
7335        return this;
7336    }
7337
7338    /**
7339     * Add extended data to the intent.  The name must include a package
7340     * prefix, for example the app com.android.contacts would use names
7341     * like "com.android.contacts.ShowAll".
7342     *
7343     * @param name The name of the extra data, with package prefix.
7344     * @param value The Parcelable[] data value.
7345     *
7346     * @return Returns the same Intent object, for chaining multiple calls
7347     * into a single statement.
7348     *
7349     * @see #putExtras
7350     * @see #removeExtra
7351     * @see #getParcelableArrayExtra(String)
7352     */
7353    public Intent putExtra(String name, Parcelable[] value) {
7354        if (mExtras == null) {
7355            mExtras = new Bundle();
7356        }
7357        mExtras.putParcelableArray(name, value);
7358        return this;
7359    }
7360
7361    /**
7362     * Add extended data to the intent.  The name must include a package
7363     * prefix, for example the app com.android.contacts would use names
7364     * like "com.android.contacts.ShowAll".
7365     *
7366     * @param name The name of the extra data, with package prefix.
7367     * @param value The ArrayList<Parcelable> data value.
7368     *
7369     * @return Returns the same Intent object, for chaining multiple calls
7370     * into a single statement.
7371     *
7372     * @see #putExtras
7373     * @see #removeExtra
7374     * @see #getParcelableArrayListExtra(String)
7375     */
7376    public Intent putParcelableArrayListExtra(String name, ArrayList<? extends Parcelable> value) {
7377        if (mExtras == null) {
7378            mExtras = new Bundle();
7379        }
7380        mExtras.putParcelableArrayList(name, value);
7381        return this;
7382    }
7383
7384    /**
7385     * Add extended data to the intent.  The name must include a package
7386     * prefix, for example the app com.android.contacts would use names
7387     * like "com.android.contacts.ShowAll".
7388     *
7389     * @param name The name of the extra data, with package prefix.
7390     * @param value The ArrayList<Integer> data value.
7391     *
7392     * @return Returns the same Intent object, for chaining multiple calls
7393     * into a single statement.
7394     *
7395     * @see #putExtras
7396     * @see #removeExtra
7397     * @see #getIntegerArrayListExtra(String)
7398     */
7399    public Intent putIntegerArrayListExtra(String name, ArrayList<Integer> value) {
7400        if (mExtras == null) {
7401            mExtras = new Bundle();
7402        }
7403        mExtras.putIntegerArrayList(name, value);
7404        return this;
7405    }
7406
7407    /**
7408     * Add extended data to the intent.  The name must include a package
7409     * prefix, for example the app com.android.contacts would use names
7410     * like "com.android.contacts.ShowAll".
7411     *
7412     * @param name The name of the extra data, with package prefix.
7413     * @param value The ArrayList<String> data value.
7414     *
7415     * @return Returns the same Intent object, for chaining multiple calls
7416     * into a single statement.
7417     *
7418     * @see #putExtras
7419     * @see #removeExtra
7420     * @see #getStringArrayListExtra(String)
7421     */
7422    public Intent putStringArrayListExtra(String name, ArrayList<String> value) {
7423        if (mExtras == null) {
7424            mExtras = new Bundle();
7425        }
7426        mExtras.putStringArrayList(name, value);
7427        return this;
7428    }
7429
7430    /**
7431     * Add extended data to the intent.  The name must include a package
7432     * prefix, for example the app com.android.contacts would use names
7433     * like "com.android.contacts.ShowAll".
7434     *
7435     * @param name The name of the extra data, with package prefix.
7436     * @param value The ArrayList<CharSequence> data value.
7437     *
7438     * @return Returns the same Intent object, for chaining multiple calls
7439     * into a single statement.
7440     *
7441     * @see #putExtras
7442     * @see #removeExtra
7443     * @see #getCharSequenceArrayListExtra(String)
7444     */
7445    public Intent putCharSequenceArrayListExtra(String name, ArrayList<CharSequence> value) {
7446        if (mExtras == null) {
7447            mExtras = new Bundle();
7448        }
7449        mExtras.putCharSequenceArrayList(name, value);
7450        return this;
7451    }
7452
7453    /**
7454     * Add extended data to the intent.  The name must include a package
7455     * prefix, for example the app com.android.contacts would use names
7456     * like "com.android.contacts.ShowAll".
7457     *
7458     * @param name The name of the extra data, with package prefix.
7459     * @param value The Serializable data value.
7460     *
7461     * @return Returns the same Intent object, for chaining multiple calls
7462     * into a single statement.
7463     *
7464     * @see #putExtras
7465     * @see #removeExtra
7466     * @see #getSerializableExtra(String)
7467     */
7468    public Intent putExtra(String name, Serializable value) {
7469        if (mExtras == null) {
7470            mExtras = new Bundle();
7471        }
7472        mExtras.putSerializable(name, value);
7473        return this;
7474    }
7475
7476    /**
7477     * Add extended data to the intent.  The name must include a package
7478     * prefix, for example the app com.android.contacts would use names
7479     * like "com.android.contacts.ShowAll".
7480     *
7481     * @param name The name of the extra data, with package prefix.
7482     * @param value The boolean array data value.
7483     *
7484     * @return Returns the same Intent object, for chaining multiple calls
7485     * into a single statement.
7486     *
7487     * @see #putExtras
7488     * @see #removeExtra
7489     * @see #getBooleanArrayExtra(String)
7490     */
7491    public Intent putExtra(String name, boolean[] value) {
7492        if (mExtras == null) {
7493            mExtras = new Bundle();
7494        }
7495        mExtras.putBooleanArray(name, value);
7496        return this;
7497    }
7498
7499    /**
7500     * Add extended data to the intent.  The name must include a package
7501     * prefix, for example the app com.android.contacts would use names
7502     * like "com.android.contacts.ShowAll".
7503     *
7504     * @param name The name of the extra data, with package prefix.
7505     * @param value The byte array data value.
7506     *
7507     * @return Returns the same Intent object, for chaining multiple calls
7508     * into a single statement.
7509     *
7510     * @see #putExtras
7511     * @see #removeExtra
7512     * @see #getByteArrayExtra(String)
7513     */
7514    public Intent putExtra(String name, byte[] value) {
7515        if (mExtras == null) {
7516            mExtras = new Bundle();
7517        }
7518        mExtras.putByteArray(name, value);
7519        return this;
7520    }
7521
7522    /**
7523     * Add extended data to the intent.  The name must include a package
7524     * prefix, for example the app com.android.contacts would use names
7525     * like "com.android.contacts.ShowAll".
7526     *
7527     * @param name The name of the extra data, with package prefix.
7528     * @param value The short array data value.
7529     *
7530     * @return Returns the same Intent object, for chaining multiple calls
7531     * into a single statement.
7532     *
7533     * @see #putExtras
7534     * @see #removeExtra
7535     * @see #getShortArrayExtra(String)
7536     */
7537    public Intent putExtra(String name, short[] value) {
7538        if (mExtras == null) {
7539            mExtras = new Bundle();
7540        }
7541        mExtras.putShortArray(name, value);
7542        return this;
7543    }
7544
7545    /**
7546     * Add extended data to the intent.  The name must include a package
7547     * prefix, for example the app com.android.contacts would use names
7548     * like "com.android.contacts.ShowAll".
7549     *
7550     * @param name The name of the extra data, with package prefix.
7551     * @param value The char array data value.
7552     *
7553     * @return Returns the same Intent object, for chaining multiple calls
7554     * into a single statement.
7555     *
7556     * @see #putExtras
7557     * @see #removeExtra
7558     * @see #getCharArrayExtra(String)
7559     */
7560    public Intent putExtra(String name, char[] value) {
7561        if (mExtras == null) {
7562            mExtras = new Bundle();
7563        }
7564        mExtras.putCharArray(name, value);
7565        return this;
7566    }
7567
7568    /**
7569     * Add extended data to the intent.  The name must include a package
7570     * prefix, for example the app com.android.contacts would use names
7571     * like "com.android.contacts.ShowAll".
7572     *
7573     * @param name The name of the extra data, with package prefix.
7574     * @param value The int array data value.
7575     *
7576     * @return Returns the same Intent object, for chaining multiple calls
7577     * into a single statement.
7578     *
7579     * @see #putExtras
7580     * @see #removeExtra
7581     * @see #getIntArrayExtra(String)
7582     */
7583    public Intent putExtra(String name, int[] value) {
7584        if (mExtras == null) {
7585            mExtras = new Bundle();
7586        }
7587        mExtras.putIntArray(name, value);
7588        return this;
7589    }
7590
7591    /**
7592     * Add extended data to the intent.  The name must include a package
7593     * prefix, for example the app com.android.contacts would use names
7594     * like "com.android.contacts.ShowAll".
7595     *
7596     * @param name The name of the extra data, with package prefix.
7597     * @param value The byte array data value.
7598     *
7599     * @return Returns the same Intent object, for chaining multiple calls
7600     * into a single statement.
7601     *
7602     * @see #putExtras
7603     * @see #removeExtra
7604     * @see #getLongArrayExtra(String)
7605     */
7606    public Intent putExtra(String name, long[] value) {
7607        if (mExtras == null) {
7608            mExtras = new Bundle();
7609        }
7610        mExtras.putLongArray(name, value);
7611        return this;
7612    }
7613
7614    /**
7615     * Add extended data to the intent.  The name must include a package
7616     * prefix, for example the app com.android.contacts would use names
7617     * like "com.android.contacts.ShowAll".
7618     *
7619     * @param name The name of the extra data, with package prefix.
7620     * @param value The float array data value.
7621     *
7622     * @return Returns the same Intent object, for chaining multiple calls
7623     * into a single statement.
7624     *
7625     * @see #putExtras
7626     * @see #removeExtra
7627     * @see #getFloatArrayExtra(String)
7628     */
7629    public Intent putExtra(String name, float[] value) {
7630        if (mExtras == null) {
7631            mExtras = new Bundle();
7632        }
7633        mExtras.putFloatArray(name, value);
7634        return this;
7635    }
7636
7637    /**
7638     * Add extended data to the intent.  The name must include a package
7639     * prefix, for example the app com.android.contacts would use names
7640     * like "com.android.contacts.ShowAll".
7641     *
7642     * @param name The name of the extra data, with package prefix.
7643     * @param value The double array data value.
7644     *
7645     * @return Returns the same Intent object, for chaining multiple calls
7646     * into a single statement.
7647     *
7648     * @see #putExtras
7649     * @see #removeExtra
7650     * @see #getDoubleArrayExtra(String)
7651     */
7652    public Intent putExtra(String name, double[] value) {
7653        if (mExtras == null) {
7654            mExtras = new Bundle();
7655        }
7656        mExtras.putDoubleArray(name, value);
7657        return this;
7658    }
7659
7660    /**
7661     * Add extended data to the intent.  The name must include a package
7662     * prefix, for example the app com.android.contacts would use names
7663     * like "com.android.contacts.ShowAll".
7664     *
7665     * @param name The name of the extra data, with package prefix.
7666     * @param value The String array data value.
7667     *
7668     * @return Returns the same Intent object, for chaining multiple calls
7669     * into a single statement.
7670     *
7671     *