1/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.content;
18
19import android.content.pm.ApplicationInfo;
20import android.provider.MediaStore;
21import android.util.ArraySet;
22
23import org.xmlpull.v1.XmlPullParser;
24import org.xmlpull.v1.XmlPullParserException;
25
26import android.annotation.IntDef;
27import android.annotation.SdkConstant;
28import android.annotation.SystemApi;
29import android.annotation.SdkConstant.SdkConstantType;
30import android.content.pm.ActivityInfo;
31
32import static android.content.ContentProvider.maybeAddUserId;
33
34import android.content.pm.PackageManager;
35import android.content.pm.ResolveInfo;
36import android.content.res.Resources;
37import android.content.res.TypedArray;
38import android.graphics.Rect;
39import android.net.Uri;
40import android.os.Bundle;
41import android.os.IBinder;
42import android.os.Parcel;
43import android.os.Parcelable;
44import android.os.Process;
45import android.os.StrictMode;
46import android.os.UserHandle;
47import android.provider.DocumentsContract;
48import android.provider.DocumentsProvider;
49import android.provider.OpenableColumns;
50import android.util.AttributeSet;
51import android.util.Log;
52
53import com.android.internal.util.XmlUtils;
54
55import org.xmlpull.v1.XmlSerializer;
56
57import java.io.IOException;
58import java.io.Serializable;
59import java.lang.annotation.Retention;
60import java.lang.annotation.RetentionPolicy;
61import java.net.URISyntaxException;
62import java.util.ArrayList;
63import java.util.List;
64import java.util.Locale;
65import java.util.Objects;
66import java.util.Set;
67
68/**
69 * An intent is an abstract description of an operation to be performed.  It
70 * can be used with {@link Context#startActivity(Intent) startActivity} to
71 * launch an {@link android.app.Activity},
72 * {@link android.content.Context#sendBroadcast(Intent) broadcastIntent} to
73 * send it to any interested {@link BroadcastReceiver BroadcastReceiver} components,
74 * and {@link android.content.Context#startService} or
75 * {@link android.content.Context#bindService} to communicate with a
76 * background {@link android.app.Service}.
77 *
78 * <p>An Intent provides a facility for performing late runtime binding between the code in
79 * different applications. Its most significant use is in the launching of activities, where it
80 * can be thought of as the glue between activities. It is basically a passive data structure
81 * holding an abstract description of an action to be performed.</p>
82 *
83 * <div class="special reference">
84 * <h3>Developer Guides</h3>
85 * <p>For information about how to create and resolve intents, read the
86 * <a href="{@docRoot}guide/topics/intents/intents-filters.html">Intents and Intent Filters</a>
87 * developer guide.</p>
88 * </div>
89 *
90 * <a name="IntentStructure"></a>
91 * <h3>Intent Structure</h3>
92 * <p>The primary pieces of information in an intent are:</p>
93 *
94 * <ul>
95 *   <li> <p><b>action</b> -- The general action to be performed, such as
96 *     {@link #ACTION_VIEW}, {@link #ACTION_EDIT}, {@link #ACTION_MAIN},
97 *     etc.</p>
98 *   </li>
99 *   <li> <p><b>data</b> -- The data to operate on, such as a person record
100 *     in the contacts database, expressed as a {@link android.net.Uri}.</p>
101 *   </li>
102 * </ul>
103 *
104 *
105 * <p>Some examples of action/data pairs are:</p>
106 *
107 * <ul>
108 *   <li> <p><b>{@link #ACTION_VIEW} <i>content://contacts/people/1</i></b> -- Display
109 *     information about the person whose identifier is "1".</p>
110 *   </li>
111 *   <li> <p><b>{@link #ACTION_DIAL} <i>content://contacts/people/1</i></b> -- Display
112 *     the phone dialer with the person filled in.</p>
113 *   </li>
114 *   <li> <p><b>{@link #ACTION_VIEW} <i>tel:123</i></b> -- Display
115 *     the phone dialer with the given number filled in.  Note how the
116 *     VIEW action does what what is considered the most reasonable thing for
117 *     a particular URI.</p>
118 *   </li>
119 *   <li> <p><b>{@link #ACTION_DIAL} <i>tel:123</i></b> -- Display
120 *     the phone dialer with the given number filled in.</p>
121 *   </li>
122 *   <li> <p><b>{@link #ACTION_EDIT} <i>content://contacts/people/1</i></b> -- Edit
123 *     information about the person whose identifier is "1".</p>
124 *   </li>
125 *   <li> <p><b>{@link #ACTION_VIEW} <i>content://contacts/people/</i></b> -- Display
126 *     a list of people, which the user can browse through.  This example is a
127 *     typical top-level entry into the Contacts application, showing you the
128 *     list of people. Selecting a particular person to view would result in a
129 *     new intent { <b>{@link #ACTION_VIEW} <i>content://contacts/N</i></b> }
130 *     being used to start an activity to display that person.</p>
131 *   </li>
132 * </ul>
133 *
134 * <p>In addition to these primary attributes, there are a number of secondary
135 * attributes that you can also include with an intent:</p>
136 *
137 * <ul>
138 *     <li> <p><b>category</b> -- Gives additional information about the action
139 *         to execute.  For example, {@link #CATEGORY_LAUNCHER} means it should
140 *         appear in the Launcher as a top-level application, while
141 *         {@link #CATEGORY_ALTERNATIVE} means it should be included in a list
142 *         of alternative actions the user can perform on a piece of data.</p>
143 *     <li> <p><b>type</b> -- Specifies an explicit type (a MIME type) of the
144 *         intent data.  Normally the type is inferred from the data itself.
145 *         By setting this attribute, you disable that evaluation and force
146 *         an explicit type.</p>
147 *     <li> <p><b>component</b> -- Specifies an explicit name of a component
148 *         class to use for the intent.  Normally this is determined by looking
149 *         at the other information in the intent (the action, data/type, and
150 *         categories) and matching that with a component that can handle it.
151 *         If this attribute is set then none of the evaluation is performed,
152 *         and this component is used exactly as is.  By specifying this attribute,
153 *         all of the other Intent attributes become optional.</p>
154 *     <li> <p><b>extras</b> -- This is a {@link Bundle} of any additional information.
155 *         This can be used to provide extended information to the component.
156 *         For example, if we have a action to send an e-mail message, we could
157 *         also include extra pieces of data here to supply a subject, body,
158 *         etc.</p>
159 * </ul>
160 *
161 * <p>Here are some examples of other operations you can specify as intents
162 * using these additional parameters:</p>
163 *
164 * <ul>
165 *   <li> <p><b>{@link #ACTION_MAIN} with category {@link #CATEGORY_HOME}</b> --
166 *     Launch the home screen.</p>
167 *   </li>
168 *   <li> <p><b>{@link #ACTION_GET_CONTENT} with MIME type
169 *     <i>{@link android.provider.Contacts.Phones#CONTENT_URI
170 *     vnd.android.cursor.item/phone}</i></b>
171 *     -- Display the list of people's phone numbers, allowing the user to
172 *     browse through them and pick one and return it to the parent activity.</p>
173 *   </li>
174 *   <li> <p><b>{@link #ACTION_GET_CONTENT} with MIME type
175 *     <i>*{@literal /}*</i> and category {@link #CATEGORY_OPENABLE}</b>
176 *     -- Display all pickers for data that can be opened with
177 *     {@link ContentResolver#openInputStream(Uri) ContentResolver.openInputStream()},
178 *     allowing the user to pick one of them and then some data inside of it
179 *     and returning the resulting URI to the caller.  This can be used,
180 *     for example, in an e-mail application to allow the user to pick some
181 *     data to include as an attachment.</p>
182 *   </li>
183 * </ul>
184 *
185 * <p>There are a variety of standard Intent action and category constants
186 * defined in the Intent class, but applications can also define their own.
187 * These strings use java style scoping, to ensure they are unique -- for
188 * example, the standard {@link #ACTION_VIEW} is called
189 * "android.intent.action.VIEW".</p>
190 *
191 * <p>Put together, the set of actions, data types, categories, and extra data
192 * defines a language for the system allowing for the expression of phrases
193 * such as "call john smith's cell".  As applications are added to the system,
194 * they can extend this language by adding new actions, types, and categories, or
195 * they can modify the behavior of existing phrases by supplying their own
196 * activities that handle them.</p>
197 *
198 * <a name="IntentResolution"></a>
199 * <h3>Intent Resolution</h3>
200 *
201 * <p>There are two primary forms of intents you will use.
202 *
203 * <ul>
204 *     <li> <p><b>Explicit Intents</b> have specified a component (via
205 *     {@link #setComponent} or {@link #setClass}), which provides the exact
206 *     class to be run.  Often these will not include any other information,
207 *     simply being a way for an application to launch various internal
208 *     activities it has as the user interacts with the application.
209 *
210 *     <li> <p><b>Implicit Intents</b> have not specified a component;
211 *     instead, they must include enough information for the system to
212 *     determine which of the available components is best to run for that
213 *     intent.
214 * </ul>
215 *
216 * <p>When using implicit intents, given such an arbitrary intent we need to
217 * know what to do with it. This is handled by the process of <em>Intent
218 * resolution</em>, which maps an Intent to an {@link android.app.Activity},
219 * {@link BroadcastReceiver}, or {@link android.app.Service} (or sometimes two or
220 * more activities/receivers) that can handle it.</p>
221 *
222 * <p>The intent resolution mechanism basically revolves around matching an
223 * Intent against all of the &lt;intent-filter&gt; descriptions in the
224 * installed application packages.  (Plus, in the case of broadcasts, any {@link BroadcastReceiver}
225 * objects explicitly registered with {@link Context#registerReceiver}.)  More
226 * details on this can be found in the documentation on the {@link
227 * IntentFilter} class.</p>
228 *
229 * <p>There are three pieces of information in the Intent that are used for
230 * resolution: the action, type, and category.  Using this information, a query
231 * is done on the {@link PackageManager} for a component that can handle the
232 * intent. The appropriate component is determined based on the intent
233 * information supplied in the <code>AndroidManifest.xml</code> file as
234 * follows:</p>
235 *
236 * <ul>
237 *     <li> <p>The <b>action</b>, if given, must be listed by the component as
238 *         one it handles.</p>
239 *     <li> <p>The <b>type</b> is retrieved from the Intent's data, if not
240 *         already supplied in the Intent.  Like the action, if a type is
241 *         included in the intent (either explicitly or implicitly in its
242 *         data), then this must be listed by the component as one it handles.</p>
243 *     <li> For data that is not a <code>content:</code> URI and where no explicit
244 *         type is included in the Intent, instead the <b>scheme</b> of the
245 *         intent data (such as <code>http:</code> or <code>mailto:</code>) is
246 *         considered. Again like the action, if we are matching a scheme it
247 *         must be listed by the component as one it can handle.
248 *     <li> <p>The <b>categories</b>, if supplied, must <em>all</em> be listed
249 *         by the activity as categories it handles.  That is, if you include
250 *         the categories {@link #CATEGORY_LAUNCHER} and
251 *         {@link #CATEGORY_ALTERNATIVE}, then you will only resolve to components
252 *         with an intent that lists <em>both</em> of those categories.
253 *         Activities will very often need to support the
254 *         {@link #CATEGORY_DEFAULT} so that they can be found by
255 *         {@link Context#startActivity Context.startActivity()}.</p>
256 * </ul>
257 *
258 * <p>For example, consider the Note Pad sample application that
259 * allows user to browse through a list of notes data and view details about
260 * individual items.  Text in italics indicate places were you would replace a
261 * name with one specific to your own package.</p>
262 *
263 * <pre> &lt;manifest xmlns:android="http://schemas.android.com/apk/res/android"
264 *       package="<i>com.android.notepad</i>"&gt;
265 *     &lt;application android:icon="@drawable/app_notes"
266 *             android:label="@string/app_name"&gt;
267 *
268 *         &lt;provider class=".NotePadProvider"
269 *                 android:authorities="<i>com.google.provider.NotePad</i>" /&gt;
270 *
271 *         &lt;activity class=".NotesList" android:label="@string/title_notes_list"&gt;
272 *             &lt;intent-filter&gt;
273 *                 &lt;action android:name="android.intent.action.MAIN" /&gt;
274 *                 &lt;category android:name="android.intent.category.LAUNCHER" /&gt;
275 *             &lt;/intent-filter&gt;
276 *             &lt;intent-filter&gt;
277 *                 &lt;action android:name="android.intent.action.VIEW" /&gt;
278 *                 &lt;action android:name="android.intent.action.EDIT" /&gt;
279 *                 &lt;action android:name="android.intent.action.PICK" /&gt;
280 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
281 *                 &lt;data android:mimeType="vnd.android.cursor.dir/<i>vnd.google.note</i>" /&gt;
282 *             &lt;/intent-filter&gt;
283 *             &lt;intent-filter&gt;
284 *                 &lt;action android:name="android.intent.action.GET_CONTENT" /&gt;
285 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
286 *                 &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
287 *             &lt;/intent-filter&gt;
288 *         &lt;/activity&gt;
289 *
290 *         &lt;activity class=".NoteEditor" android:label="@string/title_note"&gt;
291 *             &lt;intent-filter android:label="@string/resolve_edit"&gt;
292 *                 &lt;action android:name="android.intent.action.VIEW" /&gt;
293 *                 &lt;action android:name="android.intent.action.EDIT" /&gt;
294 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
295 *                 &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
296 *             &lt;/intent-filter&gt;
297 *
298 *             &lt;intent-filter&gt;
299 *                 &lt;action android:name="android.intent.action.INSERT" /&gt;
300 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
301 *                 &lt;data android:mimeType="vnd.android.cursor.dir/<i>vnd.google.note</i>" /&gt;
302 *             &lt;/intent-filter&gt;
303 *
304 *         &lt;/activity&gt;
305 *
306 *         &lt;activity class=".TitleEditor" android:label="@string/title_edit_title"
307 *                 android:theme="@android:style/Theme.Dialog"&gt;
308 *             &lt;intent-filter android:label="@string/resolve_title"&gt;
309 *                 &lt;action android:name="<i>com.android.notepad.action.EDIT_TITLE</i>" /&gt;
310 *                 &lt;category android:name="android.intent.category.DEFAULT" /&gt;
311 *                 &lt;category android:name="android.intent.category.ALTERNATIVE" /&gt;
312 *                 &lt;category android:name="android.intent.category.SELECTED_ALTERNATIVE" /&gt;
313 *                 &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
314 *             &lt;/intent-filter&gt;
315 *         &lt;/activity&gt;
316 *
317 *     &lt;/application&gt;
318 * &lt;/manifest&gt;</pre>
319 *
320 * <p>The first activity,
321 * <code>com.android.notepad.NotesList</code>, serves as our main
322 * entry into the app.  It can do three things as described by its three intent
323 * templates:
324 * <ol>
325 * <li><pre>
326 * &lt;intent-filter&gt;
327 *     &lt;action android:name="{@link #ACTION_MAIN android.intent.action.MAIN}" /&gt;
328 *     &lt;category android:name="{@link #CATEGORY_LAUNCHER android.intent.category.LAUNCHER}" /&gt;
329 * &lt;/intent-filter&gt;</pre>
330 * <p>This provides a top-level entry into the NotePad application: the standard
331 * MAIN action is a main entry point (not requiring any other information in
332 * the Intent), and the LAUNCHER category says that this entry point should be
333 * listed in the application launcher.</p>
334 * <li><pre>
335 * &lt;intent-filter&gt;
336 *     &lt;action android:name="{@link #ACTION_VIEW android.intent.action.VIEW}" /&gt;
337 *     &lt;action android:name="{@link #ACTION_EDIT android.intent.action.EDIT}" /&gt;
338 *     &lt;action android:name="{@link #ACTION_PICK android.intent.action.PICK}" /&gt;
339 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
340 *     &lt;data mimeType:name="vnd.android.cursor.dir/<i>vnd.google.note</i>" /&gt;
341 * &lt;/intent-filter&gt;</pre>
342 * <p>This declares the things that the activity can do on a directory of
343 * notes.  The type being supported is given with the &lt;type&gt; tag, where
344 * <code>vnd.android.cursor.dir/vnd.google.note</code> is a URI from which
345 * a Cursor of zero or more items (<code>vnd.android.cursor.dir</code>) can
346 * be retrieved which holds our note pad data (<code>vnd.google.note</code>).
347 * The activity allows the user to view or edit the directory of data (via
348 * the VIEW and EDIT actions), or to pick a particular note and return it
349 * to the caller (via the PICK action).  Note also the DEFAULT category
350 * supplied here: this is <em>required</em> for the
351 * {@link Context#startActivity Context.startActivity} method to resolve your
352 * activity when its component name is not explicitly specified.</p>
353 * <li><pre>
354 * &lt;intent-filter&gt;
355 *     &lt;action android:name="{@link #ACTION_GET_CONTENT android.intent.action.GET_CONTENT}" /&gt;
356 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
357 *     &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
358 * &lt;/intent-filter&gt;</pre>
359 * <p>This filter describes the ability return to the caller a note selected by
360 * the user without needing to know where it came from.  The data type
361 * <code>vnd.android.cursor.item/vnd.google.note</code> is a URI from which
362 * a Cursor of exactly one (<code>vnd.android.cursor.item</code>) item can
363 * be retrieved which contains our note pad data (<code>vnd.google.note</code>).
364 * The GET_CONTENT action is similar to the PICK action, where the activity
365 * will return to its caller a piece of data selected by the user.  Here,
366 * however, the caller specifies the type of data they desire instead of
367 * the type of data the user will be picking from.</p>
368 * </ol>
369 *
370 * <p>Given these capabilities, the following intents will resolve to the
371 * NotesList activity:</p>
372 *
373 * <ul>
374 *     <li> <p><b>{ action=android.app.action.MAIN }</b> matches all of the
375 *         activities that can be used as top-level entry points into an
376 *         application.</p>
377 *     <li> <p><b>{ action=android.app.action.MAIN,
378 *         category=android.app.category.LAUNCHER }</b> is the actual intent
379 *         used by the Launcher to populate its top-level list.</p>
380 *     <li> <p><b>{ action=android.intent.action.VIEW
381 *          data=content://com.google.provider.NotePad/notes }</b>
382 *         displays a list of all the notes under
383 *         "content://com.google.provider.NotePad/notes", which
384 *         the user can browse through and see the details on.</p>
385 *     <li> <p><b>{ action=android.app.action.PICK
386 *          data=content://com.google.provider.NotePad/notes }</b>
387 *         provides a list of the notes under
388 *         "content://com.google.provider.NotePad/notes", from which
389 *         the user can pick a note whose data URL is returned back to the caller.</p>
390 *     <li> <p><b>{ action=android.app.action.GET_CONTENT
391 *          type=vnd.android.cursor.item/vnd.google.note }</b>
392 *         is similar to the pick action, but allows the caller to specify the
393 *         kind of data they want back so that the system can find the appropriate
394 *         activity to pick something of that data type.</p>
395 * </ul>
396 *
397 * <p>The second activity,
398 * <code>com.android.notepad.NoteEditor</code>, shows the user a single
399 * note entry and allows them to edit it.  It can do two things as described
400 * by its two intent templates:
401 * <ol>
402 * <li><pre>
403 * &lt;intent-filter android:label="@string/resolve_edit"&gt;
404 *     &lt;action android:name="{@link #ACTION_VIEW android.intent.action.VIEW}" /&gt;
405 *     &lt;action android:name="{@link #ACTION_EDIT android.intent.action.EDIT}" /&gt;
406 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
407 *     &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
408 * &lt;/intent-filter&gt;</pre>
409 * <p>The first, primary, purpose of this activity is to let the user interact
410 * with a single note, as decribed by the MIME type
411 * <code>vnd.android.cursor.item/vnd.google.note</code>.  The activity can
412 * either VIEW a note or allow the user to EDIT it.  Again we support the
413 * DEFAULT category to allow the activity to be launched without explicitly
414 * specifying its component.</p>
415 * <li><pre>
416 * &lt;intent-filter&gt;
417 *     &lt;action android:name="{@link #ACTION_INSERT android.intent.action.INSERT}" /&gt;
418 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
419 *     &lt;data android:mimeType="vnd.android.cursor.dir/<i>vnd.google.note</i>" /&gt;
420 * &lt;/intent-filter&gt;</pre>
421 * <p>The secondary use of this activity is to insert a new note entry into
422 * an existing directory of notes.  This is used when the user creates a new
423 * note: the INSERT action is executed on the directory of notes, causing
424 * this activity to run and have the user create the new note data which
425 * it then adds to the content provider.</p>
426 * </ol>
427 *
428 * <p>Given these capabilities, the following intents will resolve to the
429 * NoteEditor activity:</p>
430 *
431 * <ul>
432 *     <li> <p><b>{ action=android.intent.action.VIEW
433 *          data=content://com.google.provider.NotePad/notes/<var>{ID}</var> }</b>
434 *         shows the user the content of note <var>{ID}</var>.</p>
435 *     <li> <p><b>{ action=android.app.action.EDIT
436 *          data=content://com.google.provider.NotePad/notes/<var>{ID}</var> }</b>
437 *         allows the user to edit the content of note <var>{ID}</var>.</p>
438 *     <li> <p><b>{ action=android.app.action.INSERT
439 *          data=content://com.google.provider.NotePad/notes }</b>
440 *         creates a new, empty note in the notes list at
441 *         "content://com.google.provider.NotePad/notes"
442 *         and allows the user to edit it.  If they keep their changes, the URI
443 *         of the newly created note is returned to the caller.</p>
444 * </ul>
445 *
446 * <p>The last activity,
447 * <code>com.android.notepad.TitleEditor</code>, allows the user to
448 * edit the title of a note.  This could be implemented as a class that the
449 * application directly invokes (by explicitly setting its component in
450 * the Intent), but here we show a way you can publish alternative
451 * operations on existing data:</p>
452 *
453 * <pre>
454 * &lt;intent-filter android:label="@string/resolve_title"&gt;
455 *     &lt;action android:name="<i>com.android.notepad.action.EDIT_TITLE</i>" /&gt;
456 *     &lt;category android:name="{@link #CATEGORY_DEFAULT android.intent.category.DEFAULT}" /&gt;
457 *     &lt;category android:name="{@link #CATEGORY_ALTERNATIVE android.intent.category.ALTERNATIVE}" /&gt;
458 *     &lt;category android:name="{@link #CATEGORY_SELECTED_ALTERNATIVE android.intent.category.SELECTED_ALTERNATIVE}" /&gt;
459 *     &lt;data android:mimeType="vnd.android.cursor.item/<i>vnd.google.note</i>" /&gt;
460 * &lt;/intent-filter&gt;</pre>
461 *
462 * <p>In the single intent template here, we
463 * have created our own private action called
464 * <code>com.android.notepad.action.EDIT_TITLE</code> which means to
465 * edit the title of a note.  It must be invoked on a specific note
466 * (data type <code>vnd.android.cursor.item/vnd.google.note</code>) like the previous
467 * view and edit actions, but here displays and edits the title contained
468 * in the note data.
469 *
470 * <p>In addition to supporting the default category as usual, our title editor
471 * also supports two other standard categories: ALTERNATIVE and
472 * SELECTED_ALTERNATIVE.  Implementing
473 * these categories allows others to find the special action it provides
474 * without directly knowing about it, through the
475 * {@link android.content.pm.PackageManager#queryIntentActivityOptions} method, or
476 * more often to build dynamic menu items with
477 * {@link android.view.Menu#addIntentOptions}.  Note that in the intent
478 * template here was also supply an explicit name for the template
479 * (via <code>android:label="@string/resolve_title"</code>) to better control
480 * what the user sees when presented with this activity as an alternative
481 * action to the data they are viewing.
482 *
483 * <p>Given these capabilities, the following intent will resolve to the
484 * TitleEditor activity:</p>
485 *
486 * <ul>
487 *     <li> <p><b>{ action=com.android.notepad.action.EDIT_TITLE
488 *          data=content://com.google.provider.NotePad/notes/<var>{ID}</var> }</b>
489 *         displays and allows the user to edit the title associated
490 *         with note <var>{ID}</var>.</p>
491 * </ul>
492 *
493 * <h3>Standard Activity Actions</h3>
494 *
495 * <p>These are the current standard actions that Intent defines for launching
496 * activities (usually through {@link Context#startActivity}.  The most
497 * important, and by far most frequently used, are {@link #ACTION_MAIN} and
498 * {@link #ACTION_EDIT}.
499 *
500 * <ul>
501 *     <li> {@link #ACTION_MAIN}
502 *     <li> {@link #ACTION_VIEW}
503 *     <li> {@link #ACTION_ATTACH_DATA}
504 *     <li> {@link #ACTION_EDIT}
505 *     <li> {@link #ACTION_PICK}
506 *     <li> {@link #ACTION_CHOOSER}
507 *     <li> {@link #ACTION_GET_CONTENT}
508 *     <li> {@link #ACTION_DIAL}
509 *     <li> {@link #ACTION_CALL}
510 *     <li> {@link #ACTION_SEND}
511 *     <li> {@link #ACTION_SENDTO}
512 *     <li> {@link #ACTION_ANSWER}
513 *     <li> {@link #ACTION_INSERT}
514 *     <li> {@link #ACTION_DELETE}
515 *     <li> {@link #ACTION_RUN}
516 *     <li> {@link #ACTION_SYNC}
517 *     <li> {@link #ACTION_PICK_ACTIVITY}
518 *     <li> {@link #ACTION_SEARCH}
519 *     <li> {@link #ACTION_WEB_SEARCH}
520 *     <li> {@link #ACTION_FACTORY_TEST}
521 * </ul>
522 *
523 * <h3>Standard Broadcast Actions</h3>
524 *
525 * <p>These are the current standard actions that Intent defines for receiving
526 * broadcasts (usually through {@link Context#registerReceiver} or a
527 * &lt;receiver&gt; tag in a manifest).
528 *
529 * <ul>
530 *     <li> {@link #ACTION_TIME_TICK}
531 *     <li> {@link #ACTION_TIME_CHANGED}
532 *     <li> {@link #ACTION_TIMEZONE_CHANGED}
533 *     <li> {@link #ACTION_BOOT_COMPLETED}
534 *     <li> {@link #ACTION_PACKAGE_ADDED}
535 *     <li> {@link #ACTION_PACKAGE_CHANGED}
536 *     <li> {@link #ACTION_PACKAGE_REMOVED}
537 *     <li> {@link #ACTION_PACKAGE_RESTARTED}
538 *     <li> {@link #ACTION_PACKAGE_DATA_CLEARED}
539 *     <li> {@link #ACTION_UID_REMOVED}
540 *     <li> {@link #ACTION_BATTERY_CHANGED}
541 *     <li> {@link #ACTION_POWER_CONNECTED}
542 *     <li> {@link #ACTION_POWER_DISCONNECTED}
543 *     <li> {@link #ACTION_SHUTDOWN}
544 * </ul>
545 *
546 * <h3>Standard Categories</h3>
547 *
548 * <p>These are the current standard categories that can be used to further
549 * clarify an Intent via {@link #addCategory}.
550 *
551 * <ul>
552 *     <li> {@link #CATEGORY_DEFAULT}
553 *     <li> {@link #CATEGORY_BROWSABLE}
554 *     <li> {@link #CATEGORY_TAB}
555 *     <li> {@link #CATEGORY_ALTERNATIVE}
556 *     <li> {@link #CATEGORY_SELECTED_ALTERNATIVE}
557 *     <li> {@link #CATEGORY_LAUNCHER}
558 *     <li> {@link #CATEGORY_INFO}
559 *     <li> {@link #CATEGORY_HOME}
560 *     <li> {@link #CATEGORY_PREFERENCE}
561 *     <li> {@link #CATEGORY_TEST}
562 *     <li> {@link #CATEGORY_CAR_DOCK}
563 *     <li> {@link #CATEGORY_DESK_DOCK}
564 *     <li> {@link #CATEGORY_LE_DESK_DOCK}
565 *     <li> {@link #CATEGORY_HE_DESK_DOCK}
566 *     <li> {@link #CATEGORY_CAR_MODE}
567 *     <li> {@link #CATEGORY_APP_MARKET}
568 * </ul>
569 *
570 * <h3>Standard Extra Data</h3>
571 *
572 * <p>These are the current standard fields that can be used as extra data via
573 * {@link #putExtra}.
574 *
575 * <ul>
576 *     <li> {@link #EXTRA_ALARM_COUNT}
577 *     <li> {@link #EXTRA_BCC}
578 *     <li> {@link #EXTRA_CC}
579 *     <li> {@link #EXTRA_CHANGED_COMPONENT_NAME}
580 *     <li> {@link #EXTRA_DATA_REMOVED}
581 *     <li> {@link #EXTRA_DOCK_STATE}
582 *     <li> {@link #EXTRA_DOCK_STATE_HE_DESK}
583 *     <li> {@link #EXTRA_DOCK_STATE_LE_DESK}
584 *     <li> {@link #EXTRA_DOCK_STATE_CAR}
585 *     <li> {@link #EXTRA_DOCK_STATE_DESK}
586 *     <li> {@link #EXTRA_DOCK_STATE_UNDOCKED}
587 *     <li> {@link #EXTRA_DONT_KILL_APP}
588 *     <li> {@link #EXTRA_EMAIL}
589 *     <li> {@link #EXTRA_INITIAL_INTENTS}
590 *     <li> {@link #EXTRA_INTENT}
591 *     <li> {@link #EXTRA_KEY_EVENT}
592 *     <li> {@link #EXTRA_ORIGINATING_URI}
593 *     <li> {@link #EXTRA_PHONE_NUMBER}
594 *     <li> {@link #EXTRA_REFERRER}
595 *     <li> {@link #EXTRA_REMOTE_INTENT_TOKEN}
596 *     <li> {@link #EXTRA_REPLACING}
597 *     <li> {@link #EXTRA_SHORTCUT_ICON}
598 *     <li> {@link #EXTRA_SHORTCUT_ICON_RESOURCE}
599 *     <li> {@link #EXTRA_SHORTCUT_INTENT}
600 *     <li> {@link #EXTRA_STREAM}
601 *     <li> {@link #EXTRA_SHORTCUT_NAME}
602 *     <li> {@link #EXTRA_SUBJECT}
603 *     <li> {@link #EXTRA_TEMPLATE}
604 *     <li> {@link #EXTRA_TEXT}
605 *     <li> {@link #EXTRA_TITLE}
606 *     <li> {@link #EXTRA_UID}
607 * </ul>
608 *
609 * <h3>Flags</h3>
610 *
611 * <p>These are the possible flags that can be used in the Intent via
612 * {@link #setFlags} and {@link #addFlags}.  See {@link #setFlags} for a list
613 * of all possible flags.
614 */
615public class Intent implements Parcelable, Cloneable {
616    private static final String ATTR_ACTION = "action";
617    private static final String TAG_CATEGORIES = "categories";
618    private static final String ATTR_CATEGORY = "category";
619    private static final String TAG_EXTRA = "extra";
620    private static final String ATTR_TYPE = "type";
621    private static final String ATTR_COMPONENT = "component";
622    private static final String ATTR_DATA = "data";
623    private static final String ATTR_FLAGS = "flags";
624
625    // ---------------------------------------------------------------------
626    // ---------------------------------------------------------------------
627    // Standard intent activity actions (see action variable).
628
629    /**
630     *  Activity Action: Start as a main entry point, does not expect to
631     *  receive data.
632     *  <p>Input: nothing
633     *  <p>Output: nothing
634     */
635    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
636    public static final String ACTION_MAIN = "android.intent.action.MAIN";
637
638    /**
639     * Activity Action: Display the data to the user.  This is the most common
640     * action performed on data -- it is the generic action you can use on
641     * a piece of data to get the most reasonable thing to occur.  For example,
642     * when used on a contacts entry it will view the entry; when used on a
643     * mailto: URI it will bring up a compose window filled with the information
644     * supplied by the URI; when used with a tel: URI it will invoke the
645     * dialer.
646     * <p>Input: {@link #getData} is URI from which to retrieve data.
647     * <p>Output: nothing.
648     */
649    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
650    public static final String ACTION_VIEW = "android.intent.action.VIEW";
651
652    /**
653     * A synonym for {@link #ACTION_VIEW}, the "standard" action that is
654     * performed on a piece of data.
655     */
656    public static final String ACTION_DEFAULT = ACTION_VIEW;
657
658    /**
659     * Used to indicate that some piece of data should be attached to some other
660     * place.  For example, image data could be attached to a contact.  It is up
661     * to the recipient to decide where the data should be attached; the intent
662     * does not specify the ultimate destination.
663     * <p>Input: {@link #getData} is URI of data to be attached.
664     * <p>Output: nothing.
665     */
666    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
667    public static final String ACTION_ATTACH_DATA = "android.intent.action.ATTACH_DATA";
668
669    /**
670     * Activity Action: Provide explicit editable access to the given data.
671     * <p>Input: {@link #getData} is URI of data to be edited.
672     * <p>Output: nothing.
673     */
674    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
675    public static final String ACTION_EDIT = "android.intent.action.EDIT";
676
677    /**
678     * Activity Action: Pick an existing item, or insert a new item, and then edit it.
679     * <p>Input: {@link #getType} is the desired MIME type of the item to create or edit.
680     * The extras can contain type specific data to pass through to the editing/creating
681     * activity.
682     * <p>Output: The URI of the item that was picked.  This must be a content:
683     * URI so that any receiver can access it.
684     */
685    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
686    public static final String ACTION_INSERT_OR_EDIT = "android.intent.action.INSERT_OR_EDIT";
687
688    /**
689     * Activity Action: Pick an item from the data, returning what was selected.
690     * <p>Input: {@link #getData} is URI containing a directory of data
691     * (vnd.android.cursor.dir/*) from which to pick an item.
692     * <p>Output: The URI of the item that was picked.
693     */
694    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
695    public static final String ACTION_PICK = "android.intent.action.PICK";
696
697    /**
698     * Activity Action: Creates a shortcut.
699     * <p>Input: Nothing.</p>
700     * <p>Output: An Intent representing the shortcut. The intent must contain three
701     * extras: SHORTCUT_INTENT (value: Intent), SHORTCUT_NAME (value: String),
702     * and SHORTCUT_ICON (value: Bitmap) or SHORTCUT_ICON_RESOURCE
703     * (value: ShortcutIconResource).</p>
704     *
705     * @see #EXTRA_SHORTCUT_INTENT
706     * @see #EXTRA_SHORTCUT_NAME
707     * @see #EXTRA_SHORTCUT_ICON
708     * @see #EXTRA_SHORTCUT_ICON_RESOURCE
709     * @see android.content.Intent.ShortcutIconResource
710     */
711    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
712    public static final String ACTION_CREATE_SHORTCUT = "android.intent.action.CREATE_SHORTCUT";
713
714    /**
715     * The name of the extra used to define the Intent of a shortcut.
716     *
717     * @see #ACTION_CREATE_SHORTCUT
718     */
719    public static final String EXTRA_SHORTCUT_INTENT = "android.intent.extra.shortcut.INTENT";
720    /**
721     * The name of the extra used to define the name of a shortcut.
722     *
723     * @see #ACTION_CREATE_SHORTCUT
724     */
725    public static final String EXTRA_SHORTCUT_NAME = "android.intent.extra.shortcut.NAME";
726    /**
727     * The name of the extra used to define the icon, as a Bitmap, of a shortcut.
728     *
729     * @see #ACTION_CREATE_SHORTCUT
730     */
731    public static final String EXTRA_SHORTCUT_ICON = "android.intent.extra.shortcut.ICON";
732    /**
733     * The name of the extra used to define the icon, as a ShortcutIconResource, of a shortcut.
734     *
735     * @see #ACTION_CREATE_SHORTCUT
736     * @see android.content.Intent.ShortcutIconResource
737     */
738    public static final String EXTRA_SHORTCUT_ICON_RESOURCE =
739            "android.intent.extra.shortcut.ICON_RESOURCE";
740
741    /**
742     * Represents a shortcut/live folder icon resource.
743     *
744     * @see Intent#ACTION_CREATE_SHORTCUT
745     * @see Intent#EXTRA_SHORTCUT_ICON_RESOURCE
746     * @see android.provider.LiveFolders#ACTION_CREATE_LIVE_FOLDER
747     * @see android.provider.LiveFolders#EXTRA_LIVE_FOLDER_ICON
748     */
749    public static class ShortcutIconResource implements Parcelable {
750        /**
751         * The package name of the application containing the icon.
752         */
753        public String packageName;
754
755        /**
756         * The resource name of the icon, including package, name and type.
757         */
758        public String resourceName;
759
760        /**
761         * Creates a new ShortcutIconResource for the specified context and resource
762         * identifier.
763         *
764         * @param context The context of the application.
765         * @param resourceId The resource idenfitier for the icon.
766         * @return A new ShortcutIconResource with the specified's context package name
767         *         and icon resource idenfitier.
768         */
769        public static ShortcutIconResource fromContext(Context context, int resourceId) {
770            ShortcutIconResource icon = new ShortcutIconResource();
771            icon.packageName = context.getPackageName();
772            icon.resourceName = context.getResources().getResourceName(resourceId);
773            return icon;
774        }
775
776        /**
777         * Used to read a ShortcutIconResource from a Parcel.
778         */
779        public static final Parcelable.Creator<ShortcutIconResource> CREATOR =
780            new Parcelable.Creator<ShortcutIconResource>() {
781
782                public ShortcutIconResource createFromParcel(Parcel source) {
783                    ShortcutIconResource icon = new ShortcutIconResource();
784                    icon.packageName = source.readString();
785                    icon.resourceName = source.readString();
786                    return icon;
787                }
788
789                public ShortcutIconResource[] newArray(int size) {
790                    return new ShortcutIconResource[size];
791                }
792            };
793
794        /**
795         * No special parcel contents.
796         */
797        public int describeContents() {
798            return 0;
799        }
800
801        public void writeToParcel(Parcel dest, int flags) {
802            dest.writeString(packageName);
803            dest.writeString(resourceName);
804        }
805
806        @Override
807        public String toString() {
808            return resourceName;
809        }
810    }
811
812    /**
813     * Activity Action: Display an activity chooser, allowing the user to pick
814     * what they want to before proceeding.  This can be used as an alternative
815     * to the standard activity picker that is displayed by the system when
816     * you try to start an activity with multiple possible matches, with these
817     * differences in behavior:
818     * <ul>
819     * <li>You can specify the title that will appear in the activity chooser.
820     * <li>The user does not have the option to make one of the matching
821     * activities a preferred activity, and all possible activities will
822     * always be shown even if one of them is currently marked as the
823     * preferred activity.
824     * </ul>
825     * <p>
826     * This action should be used when the user will naturally expect to
827     * select an activity in order to proceed.  An example if when not to use
828     * it is when the user clicks on a "mailto:" link.  They would naturally
829     * expect to go directly to their mail app, so startActivity() should be
830     * called directly: it will
831     * either launch the current preferred app, or put up a dialog allowing the
832     * user to pick an app to use and optionally marking that as preferred.
833     * <p>
834     * In contrast, if the user is selecting a menu item to send a picture
835     * they are viewing to someone else, there are many different things they
836     * may want to do at this point: send it through e-mail, upload it to a
837     * web service, etc.  In this case the CHOOSER action should be used, to
838     * always present to the user a list of the things they can do, with a
839     * nice title given by the caller such as "Send this photo with:".
840     * <p>
841     * If you need to grant URI permissions through a chooser, you must specify
842     * the permissions to be granted on the ACTION_CHOOSER Intent
843     * <em>in addition</em> to the EXTRA_INTENT inside.  This means using
844     * {@link #setClipData} to specify the URIs to be granted as well as
845     * {@link #FLAG_GRANT_READ_URI_PERMISSION} and/or
846     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION} as appropriate.
847     * <p>
848     * As a convenience, an Intent of this form can be created with the
849     * {@link #createChooser} function.
850     * <p>
851     * Input: No data should be specified.  get*Extra must have
852     * a {@link #EXTRA_INTENT} field containing the Intent being executed,
853     * and can optionally have a {@link #EXTRA_TITLE} field containing the
854     * title text to display in the chooser.
855     * <p>
856     * Output: Depends on the protocol of {@link #EXTRA_INTENT}.
857     */
858    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
859    public static final String ACTION_CHOOSER = "android.intent.action.CHOOSER";
860
861    /**
862     * Convenience function for creating a {@link #ACTION_CHOOSER} Intent.
863     *
864     * <p>Builds a new {@link #ACTION_CHOOSER} Intent that wraps the given
865     * target intent, also optionally supplying a title.  If the target
866     * intent has specified {@link #FLAG_GRANT_READ_URI_PERMISSION} or
867     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, then these flags will also be
868     * set in the returned chooser intent, with its ClipData set appropriately:
869     * either a direct reflection of {@link #getClipData()} if that is non-null,
870     * or a new ClipData built from {@link #getData()}.
871     *
872     * @param target The Intent that the user will be selecting an activity
873     * to perform.
874     * @param title Optional title that will be displayed in the chooser.
875     * @return Return a new Intent object that you can hand to
876     * {@link Context#startActivity(Intent) Context.startActivity()} and
877     * related methods.
878     */
879    public static Intent createChooser(Intent target, CharSequence title) {
880        return createChooser(target, title, null);
881    }
882
883    /**
884     * Convenience function for creating a {@link #ACTION_CHOOSER} Intent.
885     *
886     * <p>Builds a new {@link #ACTION_CHOOSER} Intent that wraps the given
887     * target intent, also optionally supplying a title.  If the target
888     * intent has specified {@link #FLAG_GRANT_READ_URI_PERMISSION} or
889     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, then these flags will also be
890     * set in the returned chooser intent, with its ClipData set appropriately:
891     * either a direct reflection of {@link #getClipData()} if that is non-null,
892     * or a new ClipData built from {@link #getData()}.</p>
893     *
894     * <p>The caller may optionally supply an {@link IntentSender} to receive a callback
895     * when the user makes a choice. This can be useful if the calling application wants
896     * to remember the last chosen target and surface it as a more prominent or one-touch
897     * affordance elsewhere in the UI for next time.</p>
898     *
899     * @param target The Intent that the user will be selecting an activity
900     * to perform.
901     * @param title Optional title that will be displayed in the chooser.
902     * @param sender Optional IntentSender to be called when a choice is made.
903     * @return Return a new Intent object that you can hand to
904     * {@link Context#startActivity(Intent) Context.startActivity()} and
905     * related methods.
906     */
907    public static Intent createChooser(Intent target, CharSequence title, IntentSender sender) {
908        Intent intent = new Intent(ACTION_CHOOSER);
909        intent.putExtra(EXTRA_INTENT, target);
910        if (title != null) {
911            intent.putExtra(EXTRA_TITLE, title);
912        }
913
914        if (sender != null) {
915            intent.putExtra(EXTRA_CHOSEN_COMPONENT_INTENT_SENDER, sender);
916        }
917
918        // Migrate any clip data and flags from target.
919        int permFlags = target.getFlags() & (FLAG_GRANT_READ_URI_PERMISSION
920                | FLAG_GRANT_WRITE_URI_PERMISSION | FLAG_GRANT_PERSISTABLE_URI_PERMISSION
921                | FLAG_GRANT_PREFIX_URI_PERMISSION);
922        if (permFlags != 0) {
923            ClipData targetClipData = target.getClipData();
924            if (targetClipData == null && target.getData() != null) {
925                ClipData.Item item = new ClipData.Item(target.getData());
926                String[] mimeTypes;
927                if (target.getType() != null) {
928                    mimeTypes = new String[] { target.getType() };
929                } else {
930                    mimeTypes = new String[] { };
931                }
932                targetClipData = new ClipData(null, mimeTypes, item);
933            }
934            if (targetClipData != null) {
935                intent.setClipData(targetClipData);
936                intent.addFlags(permFlags);
937            }
938        }
939
940        return intent;
941    }
942
943    /**
944     * Activity Action: Allow the user to select a particular kind of data and
945     * return it.  This is different than {@link #ACTION_PICK} in that here we
946     * just say what kind of data is desired, not a URI of existing data from
947     * which the user can pick.  An ACTION_GET_CONTENT could allow the user to
948     * create the data as it runs (for example taking a picture or recording a
949     * sound), let them browse over the web and download the desired data,
950     * etc.
951     * <p>
952     * There are two main ways to use this action: if you want a specific kind
953     * of data, such as a person contact, you set the MIME type to the kind of
954     * data you want and launch it with {@link Context#startActivity(Intent)}.
955     * The system will then launch the best application to select that kind
956     * of data for you.
957     * <p>
958     * You may also be interested in any of a set of types of content the user
959     * can pick.  For example, an e-mail application that wants to allow the
960     * user to add an attachment to an e-mail message can use this action to
961     * bring up a list of all of the types of content the user can attach.
962     * <p>
963     * In this case, you should wrap the GET_CONTENT intent with a chooser
964     * (through {@link #createChooser}), which will give the proper interface
965     * for the user to pick how to send your data and allow you to specify
966     * a prompt indicating what they are doing.  You will usually specify a
967     * broad MIME type (such as image/* or {@literal *}/*), resulting in a
968     * broad range of content types the user can select from.
969     * <p>
970     * When using such a broad GET_CONTENT action, it is often desirable to
971     * only pick from data that can be represented as a stream.  This is
972     * accomplished by requiring the {@link #CATEGORY_OPENABLE} in the Intent.
973     * <p>
974     * Callers can optionally specify {@link #EXTRA_LOCAL_ONLY} to request that
975     * the launched content chooser only returns results representing data that
976     * is locally available on the device.  For example, if this extra is set
977     * to true then an image picker should not show any pictures that are available
978     * from a remote server but not already on the local device (thus requiring
979     * they be downloaded when opened).
980     * <p>
981     * If the caller can handle multiple returned items (the user performing
982     * multiple selection), then it can specify {@link #EXTRA_ALLOW_MULTIPLE}
983     * to indicate this.
984     * <p>
985     * Input: {@link #getType} is the desired MIME type to retrieve.  Note
986     * that no URI is supplied in the intent, as there are no constraints on
987     * where the returned data originally comes from.  You may also include the
988     * {@link #CATEGORY_OPENABLE} if you can only accept data that can be
989     * opened as a stream.  You may use {@link #EXTRA_LOCAL_ONLY} to limit content
990     * selection to local data.  You may use {@link #EXTRA_ALLOW_MULTIPLE} to
991     * allow the user to select multiple items.
992     * <p>
993     * Output: The URI of the item that was picked.  This must be a content:
994     * URI so that any receiver can access it.
995     */
996    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
997    public static final String ACTION_GET_CONTENT = "android.intent.action.GET_CONTENT";
998    /**
999     * Activity Action: Dial a number as specified by the data.  This shows a
1000     * UI with the number being dialed, allowing the user to explicitly
1001     * initiate the call.
1002     * <p>Input: If nothing, an empty dialer is started; else {@link #getData}
1003     * is URI of a phone number to be dialed or a tel: URI of an explicit phone
1004     * number.
1005     * <p>Output: nothing.
1006     */
1007    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1008    public static final String ACTION_DIAL = "android.intent.action.DIAL";
1009    /**
1010     * Activity Action: Perform a call to someone specified by the data.
1011     * <p>Input: If nothing, an empty dialer is started; else {@link #getData}
1012     * is URI of a phone number to be dialed or a tel: URI of an explicit phone
1013     * number.
1014     * <p>Output: nothing.
1015     *
1016     * <p>Note: there will be restrictions on which applications can initiate a
1017     * call; most applications should use the {@link #ACTION_DIAL}.
1018     * <p>Note: this Intent <strong>cannot</strong> be used to call emergency
1019     * numbers.  Applications can <strong>dial</strong> emergency numbers using
1020     * {@link #ACTION_DIAL}, however.
1021     */
1022    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1023    public static final String ACTION_CALL = "android.intent.action.CALL";
1024    /**
1025     * Activity Action: Perform a call to an emergency number specified by the
1026     * data.
1027     * <p>Input: {@link #getData} is URI of a phone number to be dialed or a
1028     * tel: URI of an explicit phone number.
1029     * <p>Output: nothing.
1030     * @hide
1031     */
1032    public static final String ACTION_CALL_EMERGENCY = "android.intent.action.CALL_EMERGENCY";
1033    /**
1034     * Activity action: Perform a call to any number (emergency or not)
1035     * specified by the data.
1036     * <p>Input: {@link #getData} is URI of a phone number to be dialed or a
1037     * tel: URI of an explicit phone number.
1038     * <p>Output: nothing.
1039     * @hide
1040     */
1041    public static final String ACTION_CALL_PRIVILEGED = "android.intent.action.CALL_PRIVILEGED";
1042    /**
1043     * Activity Action: Send a message to someone specified by the data.
1044     * <p>Input: {@link #getData} is URI describing the target.
1045     * <p>Output: nothing.
1046     */
1047    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1048    public static final String ACTION_SENDTO = "android.intent.action.SENDTO";
1049    /**
1050     * Activity Action: Deliver some data to someone else.  Who the data is
1051     * being delivered to is not specified; it is up to the receiver of this
1052     * action to ask the user where the data should be sent.
1053     * <p>
1054     * When launching a SEND intent, you should usually wrap it in a chooser
1055     * (through {@link #createChooser}), which will give the proper interface
1056     * for the user to pick how to send your data and allow you to specify
1057     * a prompt indicating what they are doing.
1058     * <p>
1059     * Input: {@link #getType} is the MIME type of the data being sent.
1060     * get*Extra can have either a {@link #EXTRA_TEXT}
1061     * or {@link #EXTRA_STREAM} field, containing the data to be sent.  If
1062     * using EXTRA_TEXT, the MIME type should be "text/plain"; otherwise it
1063     * should be the MIME type of the data in EXTRA_STREAM.  Use {@literal *}/*
1064     * if the MIME type is unknown (this will only allow senders that can
1065     * handle generic data streams).  If using {@link #EXTRA_TEXT}, you can
1066     * also optionally supply {@link #EXTRA_HTML_TEXT} for clients to retrieve
1067     * your text with HTML formatting.
1068     * <p>
1069     * As of {@link android.os.Build.VERSION_CODES#JELLY_BEAN}, the data
1070     * being sent can be supplied through {@link #setClipData(ClipData)}.  This
1071     * allows you to use {@link #FLAG_GRANT_READ_URI_PERMISSION} when sharing
1072     * content: URIs and other advanced features of {@link ClipData}.  If
1073     * using this approach, you still must supply the same data through the
1074     * {@link #EXTRA_TEXT} or {@link #EXTRA_STREAM} fields described below
1075     * for compatibility with old applications.  If you don't set a ClipData,
1076     * it will be copied there for you when calling {@link Context#startActivity(Intent)}.
1077     * <p>
1078     * Optional standard extras, which may be interpreted by some recipients as
1079     * appropriate, are: {@link #EXTRA_EMAIL}, {@link #EXTRA_CC},
1080     * {@link #EXTRA_BCC}, {@link #EXTRA_SUBJECT}.
1081     * <p>
1082     * Output: nothing.
1083     */
1084    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1085    public static final String ACTION_SEND = "android.intent.action.SEND";
1086    /**
1087     * Activity Action: Deliver multiple data to someone else.
1088     * <p>
1089     * Like {@link #ACTION_SEND}, except the data is multiple.
1090     * <p>
1091     * Input: {@link #getType} is the MIME type of the data being sent.
1092     * get*ArrayListExtra can have either a {@link #EXTRA_TEXT} or {@link
1093     * #EXTRA_STREAM} field, containing the data to be sent.  If using
1094     * {@link #EXTRA_TEXT}, you can also optionally supply {@link #EXTRA_HTML_TEXT}
1095     * for clients to retrieve your text with HTML formatting.
1096     * <p>
1097     * Multiple types are supported, and receivers should handle mixed types
1098     * whenever possible. The right way for the receiver to check them is to
1099     * use the content resolver on each URI. The intent sender should try to
1100     * put the most concrete mime type in the intent type, but it can fall
1101     * back to {@literal <type>/*} or {@literal *}/* as needed.
1102     * <p>
1103     * e.g. if you are sending image/jpg and image/jpg, the intent's type can
1104     * be image/jpg, but if you are sending image/jpg and image/png, then the
1105     * intent's type should be image/*.
1106     * <p>
1107     * As of {@link android.os.Build.VERSION_CODES#JELLY_BEAN}, the data
1108     * being sent can be supplied through {@link #setClipData(ClipData)}.  This
1109     * allows you to use {@link #FLAG_GRANT_READ_URI_PERMISSION} when sharing
1110     * content: URIs and other advanced features of {@link ClipData}.  If
1111     * using this approach, you still must supply the same data through the
1112     * {@link #EXTRA_TEXT} or {@link #EXTRA_STREAM} fields described below
1113     * for compatibility with old applications.  If you don't set a ClipData,
1114     * it will be copied there for you when calling {@link Context#startActivity(Intent)}.
1115     * <p>
1116     * Optional standard extras, which may be interpreted by some recipients as
1117     * appropriate, are: {@link #EXTRA_EMAIL}, {@link #EXTRA_CC},
1118     * {@link #EXTRA_BCC}, {@link #EXTRA_SUBJECT}.
1119     * <p>
1120     * Output: nothing.
1121     */
1122    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1123    public static final String ACTION_SEND_MULTIPLE = "android.intent.action.SEND_MULTIPLE";
1124    /**
1125     * Activity Action: Handle an incoming phone call.
1126     * <p>Input: nothing.
1127     * <p>Output: nothing.
1128     */
1129    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1130    public static final String ACTION_ANSWER = "android.intent.action.ANSWER";
1131    /**
1132     * Activity Action: Insert an empty item into the given container.
1133     * <p>Input: {@link #getData} is URI of the directory (vnd.android.cursor.dir/*)
1134     * in which to place the data.
1135     * <p>Output: URI of the new data that was created.
1136     */
1137    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1138    public static final String ACTION_INSERT = "android.intent.action.INSERT";
1139    /**
1140     * Activity Action: Create a new item in the given container, initializing it
1141     * from the current contents of the clipboard.
1142     * <p>Input: {@link #getData} is URI of the directory (vnd.android.cursor.dir/*)
1143     * in which to place the data.
1144     * <p>Output: URI of the new data that was created.
1145     */
1146    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1147    public static final String ACTION_PASTE = "android.intent.action.PASTE";
1148    /**
1149     * Activity Action: Delete the given data from its container.
1150     * <p>Input: {@link #getData} is URI of data to be deleted.
1151     * <p>Output: nothing.
1152     */
1153    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1154    public static final String ACTION_DELETE = "android.intent.action.DELETE";
1155    /**
1156     * Activity Action: Run the data, whatever that means.
1157     * <p>Input: ?  (Note: this is currently specific to the test harness.)
1158     * <p>Output: nothing.
1159     */
1160    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1161    public static final String ACTION_RUN = "android.intent.action.RUN";
1162    /**
1163     * Activity Action: Perform a data synchronization.
1164     * <p>Input: ?
1165     * <p>Output: ?
1166     */
1167    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1168    public static final String ACTION_SYNC = "android.intent.action.SYNC";
1169    /**
1170     * Activity Action: Pick an activity given an intent, returning the class
1171     * selected.
1172     * <p>Input: get*Extra field {@link #EXTRA_INTENT} is an Intent
1173     * used with {@link PackageManager#queryIntentActivities} to determine the
1174     * set of activities from which to pick.
1175     * <p>Output: Class name of the activity that was selected.
1176     */
1177    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1178    public static final String ACTION_PICK_ACTIVITY = "android.intent.action.PICK_ACTIVITY";
1179    /**
1180     * Activity Action: Perform a search.
1181     * <p>Input: {@link android.app.SearchManager#QUERY getStringExtra(SearchManager.QUERY)}
1182     * is the text to search for.  If empty, simply
1183     * enter your search results Activity with the search UI activated.
1184     * <p>Output: nothing.
1185     */
1186    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1187    public static final String ACTION_SEARCH = "android.intent.action.SEARCH";
1188    /**
1189     * Activity Action: Start the platform-defined tutorial
1190     * <p>Input: {@link android.app.SearchManager#QUERY getStringExtra(SearchManager.QUERY)}
1191     * is the text to search for.  If empty, simply
1192     * enter your search results Activity with the search UI activated.
1193     * <p>Output: nothing.
1194     */
1195    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1196    public static final String ACTION_SYSTEM_TUTORIAL = "android.intent.action.SYSTEM_TUTORIAL";
1197    /**
1198     * Activity Action: Perform a web search.
1199     * <p>
1200     * Input: {@link android.app.SearchManager#QUERY
1201     * getStringExtra(SearchManager.QUERY)} is the text to search for. If it is
1202     * a url starts with http or https, the site will be opened. If it is plain
1203     * text, Google search will be applied.
1204     * <p>
1205     * Output: nothing.
1206     */
1207    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1208    public static final String ACTION_WEB_SEARCH = "android.intent.action.WEB_SEARCH";
1209
1210    /**
1211     * Activity Action: Perform assist action.
1212     * <p>
1213     * Input: {@link #EXTRA_ASSIST_PACKAGE}, {@link #EXTRA_ASSIST_CONTEXT}, can provide
1214     * additional optional contextual information about where the user was when they
1215     * requested the assist.
1216     * Output: nothing.
1217     */
1218    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1219    public static final String ACTION_ASSIST = "android.intent.action.ASSIST";
1220
1221    /**
1222     * Activity Action: Perform voice assist action.
1223     * <p>
1224     * Input: {@link #EXTRA_ASSIST_PACKAGE}, {@link #EXTRA_ASSIST_CONTEXT}, can provide
1225     * additional optional contextual information about where the user was when they
1226     * requested the voice assist.
1227     * Output: nothing.
1228     * @hide
1229     */
1230    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1231    public static final String ACTION_VOICE_ASSIST = "android.intent.action.VOICE_ASSIST";
1232
1233    /**
1234     * An optional field on {@link #ACTION_ASSIST} containing the name of the current foreground
1235     * application package at the time the assist was invoked.
1236     */
1237    public static final String EXTRA_ASSIST_PACKAGE
1238            = "android.intent.extra.ASSIST_PACKAGE";
1239
1240    /**
1241     * An optional field on {@link #ACTION_ASSIST} and containing additional contextual
1242     * information supplied by the current foreground app at the time of the assist request.
1243     * This is a {@link Bundle} of additional data.
1244     */
1245    public static final String EXTRA_ASSIST_CONTEXT
1246            = "android.intent.extra.ASSIST_CONTEXT";
1247
1248    /**
1249     * An optional field on {@link #ACTION_ASSIST} suggesting that the user will likely use a
1250     * keyboard as the primary input device for assistance.
1251     */
1252    public static final String EXTRA_ASSIST_INPUT_HINT_KEYBOARD =
1253            "android.intent.extra.ASSIST_INPUT_HINT_KEYBOARD";
1254
1255    /**
1256     * Activity Action: List all available applications
1257     * <p>Input: Nothing.
1258     * <p>Output: nothing.
1259     */
1260    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1261    public static final String ACTION_ALL_APPS = "android.intent.action.ALL_APPS";
1262    /**
1263     * Activity Action: Show settings for choosing wallpaper
1264     * <p>Input: Nothing.
1265     * <p>Output: Nothing.
1266     */
1267    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1268    public static final String ACTION_SET_WALLPAPER = "android.intent.action.SET_WALLPAPER";
1269
1270    /**
1271     * Activity Action: Show activity for reporting a bug.
1272     * <p>Input: Nothing.
1273     * <p>Output: Nothing.
1274     */
1275    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1276    public static final String ACTION_BUG_REPORT = "android.intent.action.BUG_REPORT";
1277
1278    /**
1279     *  Activity Action: Main entry point for factory tests.  Only used when
1280     *  the device is booting in factory test node.  The implementing package
1281     *  must be installed in the system image.
1282     *  <p>Input: nothing
1283     *  <p>Output: nothing
1284     */
1285    public static final String ACTION_FACTORY_TEST = "android.intent.action.FACTORY_TEST";
1286
1287    /**
1288     * Activity Action: The user pressed the "call" button to go to the dialer
1289     * or other appropriate UI for placing a call.
1290     * <p>Input: Nothing.
1291     * <p>Output: Nothing.
1292     */
1293    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1294    public static final String ACTION_CALL_BUTTON = "android.intent.action.CALL_BUTTON";
1295
1296    /**
1297     * Activity Action: Start Voice Command.
1298     * <p>Input: Nothing.
1299     * <p>Output: Nothing.
1300     */
1301    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1302    public static final String ACTION_VOICE_COMMAND = "android.intent.action.VOICE_COMMAND";
1303
1304    /**
1305     * Activity Action: Start action associated with long pressing on the
1306     * search key.
1307     * <p>Input: Nothing.
1308     * <p>Output: Nothing.
1309     */
1310    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1311    public static final String ACTION_SEARCH_LONG_PRESS = "android.intent.action.SEARCH_LONG_PRESS";
1312
1313    /**
1314     * Activity Action: The user pressed the "Report" button in the crash/ANR dialog.
1315     * This intent is delivered to the package which installed the application, usually
1316     * Google Play.
1317     * <p>Input: No data is specified. The bug report is passed in using
1318     * an {@link #EXTRA_BUG_REPORT} field.
1319     * <p>Output: Nothing.
1320     *
1321     * @see #EXTRA_BUG_REPORT
1322     */
1323    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1324    public static final String ACTION_APP_ERROR = "android.intent.action.APP_ERROR";
1325
1326    /**
1327     * Activity Action: Show power usage information to the user.
1328     * <p>Input: Nothing.
1329     * <p>Output: Nothing.
1330     */
1331    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1332    public static final String ACTION_POWER_USAGE_SUMMARY = "android.intent.action.POWER_USAGE_SUMMARY";
1333
1334    /**
1335     * Activity Action: Setup wizard to launch after a platform update.  This
1336     * activity should have a string meta-data field associated with it,
1337     * {@link #METADATA_SETUP_VERSION}, which defines the current version of
1338     * the platform for setup.  The activity will be launched only if
1339     * {@link android.provider.Settings.Secure#LAST_SETUP_SHOWN} is not the
1340     * same value.
1341     * <p>Input: Nothing.
1342     * <p>Output: Nothing.
1343     * @hide
1344     */
1345    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1346    public static final String ACTION_UPGRADE_SETUP = "android.intent.action.UPGRADE_SETUP";
1347
1348    /**
1349     * Activity Action: Show settings for managing network data usage of a
1350     * specific application. Applications should define an activity that offers
1351     * options to control data usage.
1352     */
1353    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1354    public static final String ACTION_MANAGE_NETWORK_USAGE =
1355            "android.intent.action.MANAGE_NETWORK_USAGE";
1356
1357    /**
1358     * Activity Action: Launch application installer.
1359     * <p>
1360     * Input: The data must be a content: or file: URI at which the application
1361     * can be retrieved.  As of {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1},
1362     * you can also use "package:<package-name>" to install an application for the
1363     * current user that is already installed for another user. You can optionally supply
1364     * {@link #EXTRA_INSTALLER_PACKAGE_NAME}, {@link #EXTRA_NOT_UNKNOWN_SOURCE},
1365     * {@link #EXTRA_ALLOW_REPLACE}, and {@link #EXTRA_RETURN_RESULT}.
1366     * <p>
1367     * Output: If {@link #EXTRA_RETURN_RESULT}, returns whether the install
1368     * succeeded.
1369     *
1370     * @see #EXTRA_INSTALLER_PACKAGE_NAME
1371     * @see #EXTRA_NOT_UNKNOWN_SOURCE
1372     * @see #EXTRA_RETURN_RESULT
1373     */
1374    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1375    public static final String ACTION_INSTALL_PACKAGE = "android.intent.action.INSTALL_PACKAGE";
1376
1377    /**
1378     * Used as a string extra field with {@link #ACTION_INSTALL_PACKAGE} to install a
1379     * package.  Specifies the installer package name; this package will receive the
1380     * {@link #ACTION_APP_ERROR} intent.
1381     */
1382    public static final String EXTRA_INSTALLER_PACKAGE_NAME
1383            = "android.intent.extra.INSTALLER_PACKAGE_NAME";
1384
1385    /**
1386     * Used as a boolean extra field with {@link #ACTION_INSTALL_PACKAGE} to install a
1387     * package.  Specifies that the application being installed should not be
1388     * treated as coming from an unknown source, but as coming from the app
1389     * invoking the Intent.  For this to work you must start the installer with
1390     * startActivityForResult().
1391     */
1392    public static final String EXTRA_NOT_UNKNOWN_SOURCE
1393            = "android.intent.extra.NOT_UNKNOWN_SOURCE";
1394
1395    /**
1396     * Used as a URI extra field with {@link #ACTION_INSTALL_PACKAGE} and
1397     * {@link #ACTION_VIEW} to indicate the URI from which the local APK in the Intent
1398     * data field originated from.
1399     */
1400    public static final String EXTRA_ORIGINATING_URI
1401            = "android.intent.extra.ORIGINATING_URI";
1402
1403    /**
1404     * This extra can be used with any Intent used to launch an activity, supplying information
1405     * about who is launching that activity.  This field contains a {@link android.net.Uri}
1406     * object, typically an http: or https: URI of the web site that the referral came from;
1407     * it can also use the {@link #URI_ANDROID_APP_SCHEME android-app:} scheme to identify
1408     * a native application that it came from.
1409     *
1410     * <p>To retrieve this value in a client, use {@link android.app.Activity#getReferrer}
1411     * instead of directly retrieving the extra.  It is also valid for applications to
1412     * instead supply {@link #EXTRA_REFERRER_NAME} for cases where they can only create
1413     * a string, not a Uri; the field here, if supplied, will always take precedence,
1414     * however.</p>
1415     *
1416     * @see #EXTRA_REFERRER_NAME
1417     */
1418    public static final String EXTRA_REFERRER
1419            = "android.intent.extra.REFERRER";
1420
1421    /**
1422     * Alternate version of {@link #EXTRA_REFERRER} that supplies the URI as a String rather
1423     * than a {@link android.net.Uri} object.  Only for use in cases where Uri objects can
1424     * not be created, in particular when Intent extras are supplied through the
1425     * {@link #URI_INTENT_SCHEME intent:} or {@link #URI_ANDROID_APP_SCHEME android-app:}
1426     * schemes.
1427     *
1428     * @see #EXTRA_REFERRER
1429     */
1430    public static final String EXTRA_REFERRER_NAME
1431            = "android.intent.extra.REFERRER_NAME";
1432
1433    /**
1434     * Used as an int extra field with {@link #ACTION_INSTALL_PACKAGE} and
1435     * {@link} #ACTION_VIEW} to indicate the uid of the package that initiated the install
1436     * @hide
1437     */
1438    public static final String EXTRA_ORIGINATING_UID
1439            = "android.intent.extra.ORIGINATING_UID";
1440
1441    /**
1442     * Used as a boolean extra field with {@link #ACTION_INSTALL_PACKAGE} to install a
1443     * package.  Tells the installer UI to skip the confirmation with the user
1444     * if the .apk is replacing an existing one.
1445     * @deprecated As of {@link android.os.Build.VERSION_CODES#JELLY_BEAN}, Android
1446     * will no longer show an interstitial message about updating existing
1447     * applications so this is no longer needed.
1448     */
1449    @Deprecated
1450    public static final String EXTRA_ALLOW_REPLACE
1451            = "android.intent.extra.ALLOW_REPLACE";
1452
1453    /**
1454     * Used as a boolean extra field with {@link #ACTION_INSTALL_PACKAGE} or
1455     * {@link #ACTION_UNINSTALL_PACKAGE}.  Specifies that the installer UI should
1456     * return to the application the result code of the install/uninstall.  The returned result
1457     * code will be {@link android.app.Activity#RESULT_OK} on success or
1458     * {@link android.app.Activity#RESULT_FIRST_USER} on failure.
1459     */
1460    public static final String EXTRA_RETURN_RESULT
1461            = "android.intent.extra.RETURN_RESULT";
1462
1463    /**
1464     * Package manager install result code.  @hide because result codes are not
1465     * yet ready to be exposed.
1466     */
1467    public static final String EXTRA_INSTALL_RESULT
1468            = "android.intent.extra.INSTALL_RESULT";
1469
1470    /**
1471     * Activity Action: Launch application uninstaller.
1472     * <p>
1473     * Input: The data must be a package: URI whose scheme specific part is
1474     * the package name of the current installed package to be uninstalled.
1475     * You can optionally supply {@link #EXTRA_RETURN_RESULT}.
1476     * <p>
1477     * Output: If {@link #EXTRA_RETURN_RESULT}, returns whether the install
1478     * succeeded.
1479     */
1480    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
1481    public static final String ACTION_UNINSTALL_PACKAGE = "android.intent.action.UNINSTALL_PACKAGE";
1482
1483    /**
1484     * Specify whether the package should be uninstalled for all users.
1485     * @hide because these should not be part of normal application flow.
1486     */
1487    public static final String EXTRA_UNINSTALL_ALL_USERS
1488            = "android.intent.extra.UNINSTALL_ALL_USERS";
1489
1490    /**
1491     * A string associated with a {@link #ACTION_UPGRADE_SETUP} activity
1492     * describing the last run version of the platform that was setup.
1493     * @hide
1494     */
1495    public static final String METADATA_SETUP_VERSION = "android.SETUP_VERSION";
1496
1497    // ---------------------------------------------------------------------
1498    // ---------------------------------------------------------------------
1499    // Standard intent broadcast actions (see action variable).
1500
1501    /**
1502     * Broadcast Action: Sent when the device goes to sleep and becomes non-interactive.
1503     * <p>
1504     * For historical reasons, the name of this broadcast action refers to the power
1505     * state of the screen but it is actually sent in response to changes in the
1506     * overall interactive state of the device.
1507     * </p><p>
1508     * This broadcast is sent when the device becomes non-interactive which may have
1509     * nothing to do with the screen turning off.  To determine the
1510     * actual state of the screen, use {@link android.view.Display#getState}.
1511     * </p><p>
1512     * See {@link android.os.PowerManager#isInteractive} for details.
1513     * </p>
1514     *
1515     * <p class="note">This is a protected intent that can only be sent
1516     * by the system.
1517     */
1518    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1519    public static final String ACTION_SCREEN_OFF = "android.intent.action.SCREEN_OFF";
1520
1521    /**
1522     * Broadcast Action: Sent when the device wakes up and becomes interactive.
1523     * <p>
1524     * For historical reasons, the name of this broadcast action refers to the power
1525     * state of the screen but it is actually sent in response to changes in the
1526     * overall interactive state of the device.
1527     * </p><p>
1528     * This broadcast is sent when the device becomes interactive which may have
1529     * nothing to do with the screen turning on.  To determine the
1530     * actual state of the screen, use {@link android.view.Display#getState}.
1531     * </p><p>
1532     * See {@link android.os.PowerManager#isInteractive} for details.
1533     * </p>
1534     *
1535     * <p class="note">This is a protected intent that can only be sent
1536     * by the system.
1537     */
1538    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1539    public static final String ACTION_SCREEN_ON = "android.intent.action.SCREEN_ON";
1540
1541    /**
1542     * Broadcast Action: Sent after the system stops dreaming.
1543     *
1544     * <p class="note">This is a protected intent that can only be sent by the system.
1545     * It is only sent to registered receivers.</p>
1546     */
1547    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1548    public static final String ACTION_DREAMING_STOPPED = "android.intent.action.DREAMING_STOPPED";
1549
1550    /**
1551     * Broadcast Action: Sent after the system starts dreaming.
1552     *
1553     * <p class="note">This is a protected intent that can only be sent by the system.
1554     * It is only sent to registered receivers.</p>
1555     */
1556    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1557    public static final String ACTION_DREAMING_STARTED = "android.intent.action.DREAMING_STARTED";
1558
1559    /**
1560     * Broadcast Action: Sent when the user is present after device wakes up (e.g when the
1561     * keyguard is gone).
1562     *
1563     * <p class="note">This is a protected intent that can only be sent
1564     * by the system.
1565     */
1566    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1567    public static final String ACTION_USER_PRESENT = "android.intent.action.USER_PRESENT";
1568
1569    /**
1570     * Broadcast Action: The current time has changed.  Sent every
1571     * minute.  You can <em>not</em> receive this through components declared
1572     * in manifests, only by explicitly registering for it with
1573     * {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
1574     * Context.registerReceiver()}.
1575     *
1576     * <p class="note">This is a protected intent that can only be sent
1577     * by the system.
1578     */
1579    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1580    public static final String ACTION_TIME_TICK = "android.intent.action.TIME_TICK";
1581    /**
1582     * Broadcast Action: The time was set.
1583     */
1584    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1585    public static final String ACTION_TIME_CHANGED = "android.intent.action.TIME_SET";
1586    /**
1587     * Broadcast Action: The date has changed.
1588     */
1589    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1590    public static final String ACTION_DATE_CHANGED = "android.intent.action.DATE_CHANGED";
1591    /**
1592     * Broadcast Action: The timezone has changed. The intent will have the following extra values:</p>
1593     * <ul>
1594     *   <li><em>time-zone</em> - The java.util.TimeZone.getID() value identifying the new time zone.</li>
1595     * </ul>
1596     *
1597     * <p class="note">This is a protected intent that can only be sent
1598     * by the system.
1599     */
1600    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1601    public static final String ACTION_TIMEZONE_CHANGED = "android.intent.action.TIMEZONE_CHANGED";
1602    /**
1603     * Clear DNS Cache Action: This is broadcast when networks have changed and old
1604     * DNS entries should be tossed.
1605     * @hide
1606     */
1607    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1608    public static final String ACTION_CLEAR_DNS_CACHE = "android.intent.action.CLEAR_DNS_CACHE";
1609    /**
1610     * Alarm Changed Action: This is broadcast when the AlarmClock
1611     * application's alarm is set or unset.  It is used by the
1612     * AlarmClock application and the StatusBar service.
1613     * @hide
1614     */
1615    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1616    public static final String ACTION_ALARM_CHANGED = "android.intent.action.ALARM_CHANGED";
1617    /**
1618     * Sync State Changed Action: This is broadcast when the sync starts or stops or when one has
1619     * been failing for a long time.  It is used by the SyncManager and the StatusBar service.
1620     * @hide
1621     */
1622    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1623    public static final String ACTION_SYNC_STATE_CHANGED
1624            = "android.intent.action.SYNC_STATE_CHANGED";
1625    /**
1626     * Broadcast Action: This is broadcast once, after the system has finished
1627     * booting.  It can be used to perform application-specific initialization,
1628     * such as installing alarms.  You must hold the
1629     * {@link android.Manifest.permission#RECEIVE_BOOT_COMPLETED} permission
1630     * in order to receive this broadcast.
1631     *
1632     * <p class="note">This is a protected intent that can only be sent
1633     * by the system.
1634     */
1635    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1636    public static final String ACTION_BOOT_COMPLETED = "android.intent.action.BOOT_COMPLETED";
1637    /**
1638     * Broadcast Action: This is broadcast when a user action should request a
1639     * temporary system dialog to dismiss.  Some examples of temporary system
1640     * dialogs are the notification window-shade and the recent tasks dialog.
1641     */
1642    public static final String ACTION_CLOSE_SYSTEM_DIALOGS = "android.intent.action.CLOSE_SYSTEM_DIALOGS";
1643    /**
1644     * Broadcast Action: Trigger the download and eventual installation
1645     * of a package.
1646     * <p>Input: {@link #getData} is the URI of the package file to download.
1647     *
1648     * <p class="note">This is a protected intent that can only be sent
1649     * by the system.
1650     *
1651     * @deprecated This constant has never been used.
1652     */
1653    @Deprecated
1654    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1655    public static final String ACTION_PACKAGE_INSTALL = "android.intent.action.PACKAGE_INSTALL";
1656    /**
1657     * Broadcast Action: A new application package has been installed on the
1658     * device. The data contains the name of the package.  Note that the
1659     * newly installed package does <em>not</em> receive this broadcast.
1660     * <p>May include the following extras:
1661     * <ul>
1662     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the new package.
1663     * <li> {@link #EXTRA_REPLACING} is set to true if this is following
1664     * an {@link #ACTION_PACKAGE_REMOVED} broadcast for the same package.
1665     * </ul>
1666     *
1667     * <p class="note">This is a protected intent that can only be sent
1668     * by the system.
1669     */
1670    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1671    public static final String ACTION_PACKAGE_ADDED = "android.intent.action.PACKAGE_ADDED";
1672    /**
1673     * Broadcast Action: A new version of an application package has been
1674     * installed, replacing an existing version that was previously installed.
1675     * The data contains the name of the package.
1676     * <p>May include the following extras:
1677     * <ul>
1678     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the new package.
1679     * </ul>
1680     *
1681     * <p class="note">This is a protected intent that can only be sent
1682     * by the system.
1683     */
1684    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1685    public static final String ACTION_PACKAGE_REPLACED = "android.intent.action.PACKAGE_REPLACED";
1686    /**
1687     * Broadcast Action: A new version of your application has been installed
1688     * over an existing one.  This is only sent to the application that was
1689     * replaced.  It does not contain any additional data; to receive it, just
1690     * use an intent filter for this action.
1691     *
1692     * <p class="note">This is a protected intent that can only be sent
1693     * by the system.
1694     */
1695    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1696    public static final String ACTION_MY_PACKAGE_REPLACED = "android.intent.action.MY_PACKAGE_REPLACED";
1697    /**
1698     * Broadcast Action: An existing application package has been removed from
1699     * the device.  The data contains the name of the package.  The package
1700     * that is being installed does <em>not</em> receive this Intent.
1701     * <ul>
1702     * <li> {@link #EXTRA_UID} containing the integer uid previously assigned
1703     * to the package.
1704     * <li> {@link #EXTRA_DATA_REMOVED} is set to true if the entire
1705     * application -- data and code -- is being removed.
1706     * <li> {@link #EXTRA_REPLACING} is set to true if this will be followed
1707     * by an {@link #ACTION_PACKAGE_ADDED} broadcast for the same package.
1708     * </ul>
1709     *
1710     * <p class="note">This is a protected intent that can only be sent
1711     * by the system.
1712     */
1713    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1714    public static final String ACTION_PACKAGE_REMOVED = "android.intent.action.PACKAGE_REMOVED";
1715    /**
1716     * Broadcast Action: An existing application package has been completely
1717     * removed from the device.  The data contains the name of the package.
1718     * This is like {@link #ACTION_PACKAGE_REMOVED}, but only set when
1719     * {@link #EXTRA_DATA_REMOVED} is true and
1720     * {@link #EXTRA_REPLACING} is false of that broadcast.
1721     *
1722     * <ul>
1723     * <li> {@link #EXTRA_UID} containing the integer uid previously assigned
1724     * to the package.
1725     * </ul>
1726     *
1727     * <p class="note">This is a protected intent that can only be sent
1728     * by the system.
1729     */
1730    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1731    public static final String ACTION_PACKAGE_FULLY_REMOVED
1732            = "android.intent.action.PACKAGE_FULLY_REMOVED";
1733    /**
1734     * Broadcast Action: An existing application package has been changed (e.g.
1735     * a component has been enabled or disabled).  The data contains the name of
1736     * the package.
1737     * <ul>
1738     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the package.
1739     * <li> {@link #EXTRA_CHANGED_COMPONENT_NAME_LIST} containing the class name
1740     * of the changed components (or the package name itself).
1741     * <li> {@link #EXTRA_DONT_KILL_APP} containing boolean field to override the
1742     * default action of restarting the application.
1743     * </ul>
1744     *
1745     * <p class="note">This is a protected intent that can only be sent
1746     * by the system.
1747     */
1748    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1749    public static final String ACTION_PACKAGE_CHANGED = "android.intent.action.PACKAGE_CHANGED";
1750    /**
1751     * @hide
1752     * Broadcast Action: Ask system services if there is any reason to
1753     * restart the given package.  The data contains the name of the
1754     * package.
1755     * <ul>
1756     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the package.
1757     * <li> {@link #EXTRA_PACKAGES} String array of all packages to check.
1758     * </ul>
1759     *
1760     * <p class="note">This is a protected intent that can only be sent
1761     * by the system.
1762     */
1763    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1764    public static final String ACTION_QUERY_PACKAGE_RESTART = "android.intent.action.QUERY_PACKAGE_RESTART";
1765    /**
1766     * Broadcast Action: The user has restarted a package, and all of its
1767     * processes have been killed.  All runtime state
1768     * associated with it (processes, alarms, notifications, etc) should
1769     * be removed.  Note that the restarted package does <em>not</em>
1770     * receive this broadcast.
1771     * The data contains the name of the package.
1772     * <ul>
1773     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the package.
1774     * </ul>
1775     *
1776     * <p class="note">This is a protected intent that can only be sent
1777     * by the system.
1778     */
1779    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1780    public static final String ACTION_PACKAGE_RESTARTED = "android.intent.action.PACKAGE_RESTARTED";
1781    /**
1782     * Broadcast Action: The user has cleared the data of a package.  This should
1783     * be preceded by {@link #ACTION_PACKAGE_RESTARTED}, after which all of
1784     * its persistent data is erased and this broadcast sent.
1785     * Note that the cleared package does <em>not</em>
1786     * receive this broadcast. The data contains the name of the package.
1787     * <ul>
1788     * <li> {@link #EXTRA_UID} containing the integer uid assigned to the package.
1789     * </ul>
1790     *
1791     * <p class="note">This is a protected intent that can only be sent
1792     * by the system.
1793     */
1794    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1795    public static final String ACTION_PACKAGE_DATA_CLEARED = "android.intent.action.PACKAGE_DATA_CLEARED";
1796    /**
1797     * Broadcast Action: A user ID has been removed from the system.  The user
1798     * ID number is stored in the extra data under {@link #EXTRA_UID}.
1799     *
1800     * <p class="note">This is a protected intent that can only be sent
1801     * by the system.
1802     */
1803    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1804    public static final String ACTION_UID_REMOVED = "android.intent.action.UID_REMOVED";
1805
1806    /**
1807     * Broadcast Action: Sent to the installer package of an application
1808     * when that application is first launched (that is the first time it
1809     * is moved out of the stopped state).  The data contains the name of the package.
1810     *
1811     * <p class="note">This is a protected intent that can only be sent
1812     * by the system.
1813     */
1814    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1815    public static final String ACTION_PACKAGE_FIRST_LAUNCH = "android.intent.action.PACKAGE_FIRST_LAUNCH";
1816
1817    /**
1818     * Broadcast Action: Sent to the system package verifier when a package
1819     * needs to be verified. The data contains the package URI.
1820     * <p class="note">
1821     * This is a protected intent that can only be sent by the system.
1822     * </p>
1823     */
1824    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1825    public static final String ACTION_PACKAGE_NEEDS_VERIFICATION = "android.intent.action.PACKAGE_NEEDS_VERIFICATION";
1826
1827    /**
1828     * Broadcast Action: Sent to the system package verifier when a package is
1829     * verified. The data contains the package URI.
1830     * <p class="note">
1831     * This is a protected intent that can only be sent by the system.
1832     */
1833    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1834    public static final String ACTION_PACKAGE_VERIFIED = "android.intent.action.PACKAGE_VERIFIED";
1835
1836    /**
1837     * Broadcast Action: Resources for a set of packages (which were
1838     * previously unavailable) are currently
1839     * available since the media on which they exist is available.
1840     * The extra data {@link #EXTRA_CHANGED_PACKAGE_LIST} contains a
1841     * list of packages whose availability changed.
1842     * The extra data {@link #EXTRA_CHANGED_UID_LIST} contains a
1843     * list of uids of packages whose availability changed.
1844     * Note that the
1845     * packages in this list do <em>not</em> receive this broadcast.
1846     * The specified set of packages are now available on the system.
1847     * <p>Includes the following extras:
1848     * <ul>
1849     * <li> {@link #EXTRA_CHANGED_PACKAGE_LIST} is the set of packages
1850     * whose resources(were previously unavailable) are currently available.
1851     * {@link #EXTRA_CHANGED_UID_LIST} is the set of uids of the
1852     * packages whose resources(were previously unavailable)
1853     * are  currently available.
1854     * </ul>
1855     *
1856     * <p class="note">This is a protected intent that can only be sent
1857     * by the system.
1858     */
1859    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1860    public static final String ACTION_EXTERNAL_APPLICATIONS_AVAILABLE =
1861        "android.intent.action.EXTERNAL_APPLICATIONS_AVAILABLE";
1862
1863    /**
1864     * Broadcast Action: Resources for a set of packages are currently
1865     * unavailable since the media on which they exist is unavailable.
1866     * The extra data {@link #EXTRA_CHANGED_PACKAGE_LIST} contains a
1867     * list of packages whose availability changed.
1868     * The extra data {@link #EXTRA_CHANGED_UID_LIST} contains a
1869     * list of uids of packages whose availability changed.
1870     * The specified set of packages can no longer be
1871     * launched and are practically unavailable on the system.
1872     * <p>Inclues the following extras:
1873     * <ul>
1874     * <li> {@link #EXTRA_CHANGED_PACKAGE_LIST} is the set of packages
1875     * whose resources are no longer available.
1876     * {@link #EXTRA_CHANGED_UID_LIST} is the set of packages
1877     * whose resources are no longer available.
1878     * </ul>
1879     *
1880     * <p class="note">This is a protected intent that can only be sent
1881     * by the system.
1882     */
1883    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1884    public static final String ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE =
1885        "android.intent.action.EXTERNAL_APPLICATIONS_UNAVAILABLE";
1886
1887    /**
1888     * Broadcast Action:  The current system wallpaper has changed.  See
1889     * {@link android.app.WallpaperManager} for retrieving the new wallpaper.
1890     * This should <em>only</em> be used to determine when the wallpaper
1891     * has changed to show the new wallpaper to the user.  You should certainly
1892     * never, in response to this, change the wallpaper or other attributes of
1893     * it such as the suggested size.  That would be crazy, right?  You'd cause
1894     * all kinds of loops, especially if other apps are doing similar things,
1895     * right?  Of course.  So please don't do this.
1896     *
1897     * @deprecated Modern applications should use
1898     * {@link android.view.WindowManager.LayoutParams#FLAG_SHOW_WALLPAPER
1899     * WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER} to have the wallpaper
1900     * shown behind their UI, rather than watching for this broadcast and
1901     * rendering the wallpaper on their own.
1902     */
1903    @Deprecated @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1904    public static final String ACTION_WALLPAPER_CHANGED = "android.intent.action.WALLPAPER_CHANGED";
1905    /**
1906     * Broadcast Action: The current device {@link android.content.res.Configuration}
1907     * (orientation, locale, etc) has changed.  When such a change happens, the
1908     * UIs (view hierarchy) will need to be rebuilt based on this new
1909     * information; for the most part, applications don't need to worry about
1910     * this, because the system will take care of stopping and restarting the
1911     * application to make sure it sees the new changes.  Some system code that
1912     * can not be restarted will need to watch for this action and handle it
1913     * appropriately.
1914     *
1915     * <p class="note">
1916     * You can <em>not</em> receive this through components declared
1917     * in manifests, only by explicitly registering for it with
1918     * {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
1919     * Context.registerReceiver()}.
1920     *
1921     * <p class="note">This is a protected intent that can only be sent
1922     * by the system.
1923     *
1924     * @see android.content.res.Configuration
1925     */
1926    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1927    public static final String ACTION_CONFIGURATION_CHANGED = "android.intent.action.CONFIGURATION_CHANGED";
1928    /**
1929     * Broadcast Action: The current device's locale has changed.
1930     *
1931     * <p class="note">This is a protected intent that can only be sent
1932     * by the system.
1933     */
1934    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1935    public static final String ACTION_LOCALE_CHANGED = "android.intent.action.LOCALE_CHANGED";
1936    /**
1937     * Broadcast Action:  This is a <em>sticky broadcast</em> containing the
1938     * charging state, level, and other information about the battery.
1939     * See {@link android.os.BatteryManager} for documentation on the
1940     * contents of the Intent.
1941     *
1942     * <p class="note">
1943     * You can <em>not</em> receive this through components declared
1944     * in manifests, only by explicitly registering for it with
1945     * {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
1946     * Context.registerReceiver()}.  See {@link #ACTION_BATTERY_LOW},
1947     * {@link #ACTION_BATTERY_OKAY}, {@link #ACTION_POWER_CONNECTED},
1948     * and {@link #ACTION_POWER_DISCONNECTED} for distinct battery-related
1949     * broadcasts that are sent and can be received through manifest
1950     * receivers.
1951     *
1952     * <p class="note">This is a protected intent that can only be sent
1953     * by the system.
1954     */
1955    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1956    public static final String ACTION_BATTERY_CHANGED = "android.intent.action.BATTERY_CHANGED";
1957    /**
1958     * Broadcast Action:  Indicates low battery condition on the device.
1959     * This broadcast corresponds to the "Low battery warning" system dialog.
1960     *
1961     * <p class="note">This is a protected intent that can only be sent
1962     * by the system.
1963     */
1964    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1965    public static final String ACTION_BATTERY_LOW = "android.intent.action.BATTERY_LOW";
1966    /**
1967     * Broadcast Action:  Indicates the battery is now okay after being low.
1968     * This will be sent after {@link #ACTION_BATTERY_LOW} once the battery has
1969     * gone back up to an okay state.
1970     *
1971     * <p class="note">This is a protected intent that can only be sent
1972     * by the system.
1973     */
1974    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1975    public static final String ACTION_BATTERY_OKAY = "android.intent.action.BATTERY_OKAY";
1976    /**
1977     * Broadcast Action:  External power has been connected to the device.
1978     * This is intended for applications that wish to register specifically to this notification.
1979     * Unlike ACTION_BATTERY_CHANGED, applications will be woken for this and so do not have to
1980     * stay active to receive this notification.  This action can be used to implement actions
1981     * that wait until power is available to trigger.
1982     *
1983     * <p class="note">This is a protected intent that can only be sent
1984     * by the system.
1985     */
1986    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1987    public static final String ACTION_POWER_CONNECTED = "android.intent.action.ACTION_POWER_CONNECTED";
1988    /**
1989     * Broadcast Action:  External power has been removed from the device.
1990     * This is intended for applications that wish to register specifically to this notification.
1991     * Unlike ACTION_BATTERY_CHANGED, applications will be woken for this and so do not have to
1992     * stay active to receive this notification.  This action can be used to implement actions
1993     * that wait until power is available to trigger.
1994     *
1995     * <p class="note">This is a protected intent that can only be sent
1996     * by the system.
1997     */
1998    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
1999    public static final String ACTION_POWER_DISCONNECTED =
2000            "android.intent.action.ACTION_POWER_DISCONNECTED";
2001    /**
2002     * Broadcast Action:  Device is shutting down.
2003     * This is broadcast when the device is being shut down (completely turned
2004     * off, not sleeping).  Once the broadcast is complete, the final shutdown
2005     * will proceed and all unsaved data lost.  Apps will not normally need
2006     * to handle this, since the foreground activity will be paused as well.
2007     *
2008     * <p class="note">This is a protected intent that can only be sent
2009     * by the system.
2010     * <p>May include the following extras:
2011     * <ul>
2012     * <li> {@link #EXTRA_SHUTDOWN_USERSPACE_ONLY} a boolean that is set to true if this
2013     * shutdown is only for userspace processes.  If not set, assumed to be false.
2014     * </ul>
2015     */
2016    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2017    public static final String ACTION_SHUTDOWN = "android.intent.action.ACTION_SHUTDOWN";
2018    /**
2019     * Activity Action:  Start this activity to request system shutdown.
2020     * The optional boolean extra field {@link #EXTRA_KEY_CONFIRM} can be set to true
2021     * to request confirmation from the user before shutting down.
2022     *
2023     * <p class="note">This is a protected intent that can only be sent
2024     * by the system.
2025     *
2026     * {@hide}
2027     */
2028    public static final String ACTION_REQUEST_SHUTDOWN = "android.intent.action.ACTION_REQUEST_SHUTDOWN";
2029    /**
2030     * Broadcast Action:  A sticky broadcast that indicates low memory
2031     * condition on the device
2032     *
2033     * <p class="note">This is a protected intent that can only be sent
2034     * by the system.
2035     */
2036    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2037    public static final String ACTION_DEVICE_STORAGE_LOW = "android.intent.action.DEVICE_STORAGE_LOW";
2038    /**
2039     * Broadcast Action:  Indicates low memory condition on the device no longer exists
2040     *
2041     * <p class="note">This is a protected intent that can only be sent
2042     * by the system.
2043     */
2044    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2045    public static final String ACTION_DEVICE_STORAGE_OK = "android.intent.action.DEVICE_STORAGE_OK";
2046    /**
2047     * Broadcast Action:  A sticky broadcast that indicates a memory full
2048     * condition on the device. This is intended for activities that want
2049     * to be able to fill the data partition completely, leaving only
2050     * enough free space to prevent system-wide SQLite failures.
2051     *
2052     * <p class="note">This is a protected intent that can only be sent
2053     * by the system.
2054     *
2055     * {@hide}
2056     */
2057    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2058    public static final String ACTION_DEVICE_STORAGE_FULL = "android.intent.action.DEVICE_STORAGE_FULL";
2059    /**
2060     * Broadcast Action:  Indicates memory full condition on the device
2061     * no longer exists.
2062     *
2063     * <p class="note">This is a protected intent that can only be sent
2064     * by the system.
2065     *
2066     * {@hide}
2067     */
2068    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2069    public static final String ACTION_DEVICE_STORAGE_NOT_FULL = "android.intent.action.DEVICE_STORAGE_NOT_FULL";
2070    /**
2071     * Broadcast Action:  Indicates low memory condition notification acknowledged by user
2072     * and package management should be started.
2073     * This is triggered by the user from the ACTION_DEVICE_STORAGE_LOW
2074     * notification.
2075     */
2076    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2077    public static final String ACTION_MANAGE_PACKAGE_STORAGE = "android.intent.action.MANAGE_PACKAGE_STORAGE";
2078    /**
2079     * Broadcast Action:  The device has entered USB Mass Storage mode.
2080     * This is used mainly for the USB Settings panel.
2081     * Apps should listen for ACTION_MEDIA_MOUNTED and ACTION_MEDIA_UNMOUNTED broadcasts to be notified
2082     * when the SD card file system is mounted or unmounted
2083     * @deprecated replaced by android.os.storage.StorageEventListener
2084     */
2085    @Deprecated
2086    public static final String ACTION_UMS_CONNECTED = "android.intent.action.UMS_CONNECTED";
2087
2088    /**
2089     * Broadcast Action:  The device has exited USB Mass Storage mode.
2090     * This is used mainly for the USB Settings panel.
2091     * Apps should listen for ACTION_MEDIA_MOUNTED and ACTION_MEDIA_UNMOUNTED broadcasts to be notified
2092     * when the SD card file system is mounted or unmounted
2093     * @deprecated replaced by android.os.storage.StorageEventListener
2094     */
2095    @Deprecated
2096    public static final String ACTION_UMS_DISCONNECTED = "android.intent.action.UMS_DISCONNECTED";
2097
2098    /**
2099     * Broadcast Action:  External media has been removed.
2100     * The path to the mount point for the removed media is contained in the Intent.mData field.
2101     */
2102    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2103    public static final String ACTION_MEDIA_REMOVED = "android.intent.action.MEDIA_REMOVED";
2104
2105    /**
2106     * Broadcast Action:  External media is present, but not mounted at its mount point.
2107     * The path to the mount point for the unmounted media is contained in the Intent.mData field.
2108     */
2109    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2110    public static final String ACTION_MEDIA_UNMOUNTED = "android.intent.action.MEDIA_UNMOUNTED";
2111
2112    /**
2113     * Broadcast Action:  External media is present, and being disk-checked
2114     * The path to the mount point for the checking media is contained in the Intent.mData field.
2115     */
2116    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2117    public static final String ACTION_MEDIA_CHECKING = "android.intent.action.MEDIA_CHECKING";
2118
2119    /**
2120     * Broadcast Action:  External media is present, but is using an incompatible fs (or is blank)
2121     * The path to the mount point for the checking media is contained in the Intent.mData field.
2122     */
2123    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2124    public static final String ACTION_MEDIA_NOFS = "android.intent.action.MEDIA_NOFS";
2125
2126    /**
2127     * Broadcast Action:  External media is present and mounted at its mount point.
2128     * The path to the mount point for the mounted media is contained in the Intent.mData field.
2129     * The Intent contains an extra with name "read-only" and Boolean value to indicate if the
2130     * media was mounted read only.
2131     */
2132    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2133    public static final String ACTION_MEDIA_MOUNTED = "android.intent.action.MEDIA_MOUNTED";
2134
2135    /**
2136     * Broadcast Action:  External media is unmounted because it is being shared via USB mass storage.
2137     * The path to the mount point for the shared media is contained in the Intent.mData field.
2138     */
2139    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2140    public static final String ACTION_MEDIA_SHARED = "android.intent.action.MEDIA_SHARED";
2141
2142    /**
2143     * Broadcast Action:  External media is no longer being shared via USB mass storage.
2144     * The path to the mount point for the previously shared media is contained in the Intent.mData field.
2145     *
2146     * @hide
2147     */
2148    public static final String ACTION_MEDIA_UNSHARED = "android.intent.action.MEDIA_UNSHARED";
2149
2150    /**
2151     * Broadcast Action:  External media was removed from SD card slot, but mount point was not unmounted.
2152     * The path to the mount point for the removed media is contained in the Intent.mData field.
2153     */
2154    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2155    public static final String ACTION_MEDIA_BAD_REMOVAL = "android.intent.action.MEDIA_BAD_REMOVAL";
2156
2157    /**
2158     * Broadcast Action:  External media is present but cannot be mounted.
2159     * The path to the mount point for the unmountable media is contained in the Intent.mData field.
2160     */
2161    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2162    public static final String ACTION_MEDIA_UNMOUNTABLE = "android.intent.action.MEDIA_UNMOUNTABLE";
2163
2164   /**
2165     * Broadcast Action:  User has expressed the desire to remove the external storage media.
2166     * Applications should close all files they have open within the mount point when they receive this intent.
2167     * The path to the mount point for the media to be ejected is contained in the Intent.mData field.
2168     */
2169    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2170    public static final String ACTION_MEDIA_EJECT = "android.intent.action.MEDIA_EJECT";
2171
2172    /**
2173     * Broadcast Action:  The media scanner has started scanning a directory.
2174     * The path to the directory being scanned is contained in the Intent.mData field.
2175     */
2176    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2177    public static final String ACTION_MEDIA_SCANNER_STARTED = "android.intent.action.MEDIA_SCANNER_STARTED";
2178
2179   /**
2180     * Broadcast Action:  The media scanner has finished scanning a directory.
2181     * The path to the scanned directory is contained in the Intent.mData field.
2182     */
2183    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2184    public static final String ACTION_MEDIA_SCANNER_FINISHED = "android.intent.action.MEDIA_SCANNER_FINISHED";
2185
2186   /**
2187     * Broadcast Action:  Request the media scanner to scan a file and add it to the media database.
2188     * The path to the file is contained in the Intent.mData field.
2189     */
2190    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2191    public static final String ACTION_MEDIA_SCANNER_SCAN_FILE = "android.intent.action.MEDIA_SCANNER_SCAN_FILE";
2192
2193   /**
2194     * Broadcast Action:  The "Media Button" was pressed.  Includes a single
2195     * extra field, {@link #EXTRA_KEY_EVENT}, containing the key event that
2196     * caused the broadcast.
2197     */
2198    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2199    public static final String ACTION_MEDIA_BUTTON = "android.intent.action.MEDIA_BUTTON";
2200
2201    /**
2202     * Broadcast Action:  The "Camera Button" was pressed.  Includes a single
2203     * extra field, {@link #EXTRA_KEY_EVENT}, containing the key event that
2204     * caused the broadcast.
2205     */
2206    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2207    public static final String ACTION_CAMERA_BUTTON = "android.intent.action.CAMERA_BUTTON";
2208
2209    // *** NOTE: @todo(*) The following really should go into a more domain-specific
2210    // location; they are not general-purpose actions.
2211
2212    /**
2213     * Broadcast Action: A GTalk connection has been established.
2214     */
2215    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2216    public static final String ACTION_GTALK_SERVICE_CONNECTED =
2217            "android.intent.action.GTALK_CONNECTED";
2218
2219    /**
2220     * Broadcast Action: A GTalk connection has been disconnected.
2221     */
2222    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2223    public static final String ACTION_GTALK_SERVICE_DISCONNECTED =
2224            "android.intent.action.GTALK_DISCONNECTED";
2225
2226    /**
2227     * Broadcast Action: An input method has been changed.
2228     */
2229    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2230    public static final String ACTION_INPUT_METHOD_CHANGED =
2231            "android.intent.action.INPUT_METHOD_CHANGED";
2232
2233    /**
2234     * <p>Broadcast Action: The user has switched the phone into or out of Airplane Mode. One or
2235     * more radios have been turned off or on. The intent will have the following extra value:</p>
2236     * <ul>
2237     *   <li><em>state</em> - A boolean value indicating whether Airplane Mode is on. If true,
2238     *   then cell radio and possibly other radios such as bluetooth or WiFi may have also been
2239     *   turned off</li>
2240     * </ul>
2241     *
2242     * <p class="note">This is a protected intent that can only be sent
2243     * by the system.
2244     */
2245    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2246    public static final String ACTION_AIRPLANE_MODE_CHANGED = "android.intent.action.AIRPLANE_MODE";
2247
2248    /**
2249     * Broadcast Action: Some content providers have parts of their namespace
2250     * where they publish new events or items that the user may be especially
2251     * interested in. For these things, they may broadcast this action when the
2252     * set of interesting items change.
2253     *
2254     * For example, GmailProvider sends this notification when the set of unread
2255     * mail in the inbox changes.
2256     *
2257     * <p>The data of the intent identifies which part of which provider
2258     * changed. When queried through the content resolver, the data URI will
2259     * return the data set in question.
2260     *
2261     * <p>The intent will have the following extra values:
2262     * <ul>
2263     *   <li><em>count</em> - The number of items in the data set. This is the
2264     *       same as the number of items in the cursor returned by querying the
2265     *       data URI. </li>
2266     * </ul>
2267     *
2268     * This intent will be sent at boot (if the count is non-zero) and when the
2269     * data set changes. It is possible for the data set to change without the
2270     * count changing (for example, if a new unread message arrives in the same
2271     * sync operation in which a message is archived). The phone should still
2272     * ring/vibrate/etc as normal in this case.
2273     */
2274    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2275    public static final String ACTION_PROVIDER_CHANGED =
2276            "android.intent.action.PROVIDER_CHANGED";
2277
2278    /**
2279     * Broadcast Action: Wired Headset plugged in or unplugged.
2280     *
2281     * Same as {@link android.media.AudioManager#ACTION_HEADSET_PLUG}, to be consulted for value
2282     *   and documentation.
2283     * <p>If the minimum SDK version of your application is
2284     * {@link android.os.Build.VERSION_CODES#LOLLIPOP}, it is recommended to refer
2285     * to the <code>AudioManager</code> constant in your receiver registration code instead.
2286     */
2287    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2288    public static final String ACTION_HEADSET_PLUG = android.media.AudioManager.ACTION_HEADSET_PLUG;
2289
2290    /**
2291     * <p>Broadcast Action: The user has switched on advanced settings in the settings app:</p>
2292     * <ul>
2293     *   <li><em>state</em> - A boolean value indicating whether the settings is on or off.</li>
2294     * </ul>
2295     *
2296     * <p class="note">This is a protected intent that can only be sent
2297     * by the system.
2298     *
2299     * @hide
2300     */
2301    //@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2302    public static final String ACTION_ADVANCED_SETTINGS_CHANGED
2303            = "android.intent.action.ADVANCED_SETTINGS";
2304
2305    /**
2306     *  Broadcast Action: Sent after application restrictions are changed.
2307     *
2308     * <p class="note">This is a protected intent that can only be sent
2309     * by the system.</p>
2310     */
2311    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2312    public static final String ACTION_APPLICATION_RESTRICTIONS_CHANGED =
2313            "android.intent.action.APPLICATION_RESTRICTIONS_CHANGED";
2314
2315    /**
2316     * Broadcast Action: An outgoing call is about to be placed.
2317     *
2318     * <p>The Intent will have the following extra value:</p>
2319     * <ul>
2320     *   <li><em>{@link android.content.Intent#EXTRA_PHONE_NUMBER}</em> -
2321     *       the phone number originally intended to be dialed.</li>
2322     * </ul>
2323     * <p>Once the broadcast is finished, the resultData is used as the actual
2324     * number to call.  If  <code>null</code>, no call will be placed.</p>
2325     * <p>It is perfectly acceptable for multiple receivers to process the
2326     * outgoing call in turn: for example, a parental control application
2327     * might verify that the user is authorized to place the call at that
2328     * time, then a number-rewriting application might add an area code if
2329     * one was not specified.</p>
2330     * <p>For consistency, any receiver whose purpose is to prohibit phone
2331     * calls should have a priority of 0, to ensure it will see the final
2332     * phone number to be dialed.
2333     * Any receiver whose purpose is to rewrite phone numbers to be called
2334     * should have a positive priority.
2335     * Negative priorities are reserved for the system for this broadcast;
2336     * using them may cause problems.</p>
2337     * <p>Any BroadcastReceiver receiving this Intent <em>must not</em>
2338     * abort the broadcast.</p>
2339     * <p>Emergency calls cannot be intercepted using this mechanism, and
2340     * other calls cannot be modified to call emergency numbers using this
2341     * mechanism.
2342     * <p>Some apps (such as VoIP apps) may want to redirect the outgoing
2343     * call to use their own service instead. Those apps should first prevent
2344     * the call from being placed by setting resultData to <code>null</code>
2345     * and then start their own app to make the call.
2346     * <p>You must hold the
2347     * {@link android.Manifest.permission#PROCESS_OUTGOING_CALLS}
2348     * permission to receive this Intent.</p>
2349     *
2350     * <p class="note">This is a protected intent that can only be sent
2351     * by the system.
2352     */
2353    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2354    public static final String ACTION_NEW_OUTGOING_CALL =
2355            "android.intent.action.NEW_OUTGOING_CALL";
2356
2357    /**
2358     * Broadcast Action: Have the device reboot.  This is only for use by
2359     * system code.
2360     *
2361     * <p class="note">This is a protected intent that can only be sent
2362     * by the system.
2363     */
2364    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2365    public static final String ACTION_REBOOT =
2366            "android.intent.action.REBOOT";
2367
2368    /**
2369     * Broadcast Action:  A sticky broadcast for changes in the physical
2370     * docking state of the device.
2371     *
2372     * <p>The intent will have the following extra values:
2373     * <ul>
2374     *   <li><em>{@link #EXTRA_DOCK_STATE}</em> - the current dock
2375     *       state, indicating which dock the device is physically in.</li>
2376     * </ul>
2377     * <p>This is intended for monitoring the current physical dock state.
2378     * See {@link android.app.UiModeManager} for the normal API dealing with
2379     * dock mode changes.
2380     */
2381    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2382    public static final String ACTION_DOCK_EVENT =
2383            "android.intent.action.DOCK_EVENT";
2384
2385    /**
2386     * Broadcast Action: A broadcast when idle maintenance can be started.
2387     * This means that the user is not interacting with the device and is
2388     * not expected to do so soon. Typical use of the idle maintenance is
2389     * to perform somehow expensive tasks that can be postponed at a moment
2390     * when they will not degrade user experience.
2391     * <p>
2392     * <p class="note">In order to keep the device responsive in case of an
2393     * unexpected user interaction, implementations of a maintenance task
2394     * should be interruptible. In such a scenario a broadcast with action
2395     * {@link #ACTION_IDLE_MAINTENANCE_END} will be sent. In other words, you
2396     * should not do the maintenance work in
2397     * {@link BroadcastReceiver#onReceive(Context, Intent)}, rather start a
2398     * maintenance service by {@link Context#startService(Intent)}. Also
2399     * you should hold a wake lock while your maintenance service is running
2400     * to prevent the device going to sleep.
2401     * </p>
2402     * <p>
2403     * <p class="note">This is a protected intent that can only be sent by
2404     * the system.
2405     * </p>
2406     *
2407     * @see #ACTION_IDLE_MAINTENANCE_END
2408     *
2409     * @hide
2410     */
2411    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2412    public static final String ACTION_IDLE_MAINTENANCE_START =
2413            "android.intent.action.ACTION_IDLE_MAINTENANCE_START";
2414
2415    /**
2416     * Broadcast Action:  A broadcast when idle maintenance should be stopped.
2417     * This means that the user was not interacting with the device as a result
2418     * of which a broadcast with action {@link #ACTION_IDLE_MAINTENANCE_START}
2419     * was sent and now the user started interacting with the device. Typical
2420     * use of the idle maintenance is to perform somehow expensive tasks that
2421     * can be postponed at a moment when they will not degrade user experience.
2422     * <p>
2423     * <p class="note">In order to keep the device responsive in case of an
2424     * unexpected user interaction, implementations of a maintenance task
2425     * should be interruptible. Hence, on receiving a broadcast with this
2426     * action, the maintenance task should be interrupted as soon as possible.
2427     * In other words, you should not do the maintenance work in
2428     * {@link BroadcastReceiver#onReceive(Context, Intent)}, rather stop the
2429     * maintenance service that was started on receiving of
2430     * {@link #ACTION_IDLE_MAINTENANCE_START}.Also you should release the wake
2431     * lock you acquired when your maintenance service started.
2432     * </p>
2433     * <p class="note">This is a protected intent that can only be sent
2434     * by the system.
2435     *
2436     * @see #ACTION_IDLE_MAINTENANCE_START
2437     *
2438     * @hide
2439     */
2440    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
2441    public static final String ACTION_IDLE_MAINTENANCE_END =
2442            "android.intent.action.ACTION_IDLE_MAINTENANCE_END";
2443
2444    /**
2445     * Broadcast Action: a remote intent is to be broadcasted.
2446     *
2447     * A remote intent is used for remote RPC between devices. The remote intent
2448     * is serialized and sent from one device to another device. The receiving
2449     * device parses the remote intent and broadcasts it. Note that anyone can
2450     * broadcast a remote intent. However, if the intent receiver of the remote intent
2451     * does not trust intent broadcasts from arbitrary intent senders, it should require
2452     * the sender to hold certain permissions so only trusted sender's broadcast will be
2453     * let through.
2454     * @hide
2455     */
2456    public static final String ACTION_REMOTE_INTENT =
2457            "com.google.android.c2dm.intent.RECEIVE";
2458
2459    /**
2460     * Broadcast Action: hook for permforming cleanup after a system update.
2461     *
2462     * The broadcast is sent when the system is booting, before the
2463     * BOOT_COMPLETED broadcast.  It is only sent to receivers in the system
2464     * image.  A receiver for this should do its work and then disable itself
2465     * so that it does not get run again at the next boot.
2466     * @hide
2467     */
2468    public static final String ACTION_PRE_BOOT_COMPLETED =
2469            "android.intent.action.PRE_BOOT_COMPLETED";
2470
2471    /**
2472     * Broadcast to a specific application to query any supported restrictions to impose
2473     * on restricted users. The broadcast intent contains an extra
2474     * {@link #EXTRA_RESTRICTIONS_BUNDLE} with the currently persisted
2475     * restrictions as a Bundle of key/value pairs. The value types can be Boolean, String or
2476     * String[] depending on the restriction type.<p/>
2477     * The response should contain an extra {@link #EXTRA_RESTRICTIONS_LIST},
2478     * which is of type <code>ArrayList&lt;RestrictionEntry&gt;</code>. It can also
2479     * contain an extra {@link #EXTRA_RESTRICTIONS_INTENT}, which is of type <code>Intent</code>.
2480     * The activity specified by that intent will be launched for a result which must contain
2481     * one of the extras {@link #EXTRA_RESTRICTIONS_LIST} or {@link #EXTRA_RESTRICTIONS_BUNDLE}.
2482     * The keys and values of the returned restrictions will be persisted.
2483     * @see RestrictionEntry
2484     */
2485    public static final String ACTION_GET_RESTRICTION_ENTRIES =
2486            "android.intent.action.GET_RESTRICTION_ENTRIES";
2487
2488    /**
2489     * @hide
2490     * Activity to challenge the user for a PIN that was configured when setting up
2491     * restrictions. Restrictions include blocking of apps and preventing certain user operations,
2492     * controlled by {@link android.os.UserManager#setUserRestrictions(Bundle).
2493     * Launch the activity using
2494     * {@link android.app.Activity#startActivityForResult(Intent, int)} and check if the
2495     * result is {@link android.app.Activity#RESULT_OK} for a successful response to the
2496     * challenge.<p/>
2497     * Before launching this activity, make sure that there is a PIN in effect, by calling
2498     * {@link android.os.UserManager#hasRestrictionsChallenge()}.
2499     */
2500    public static final String ACTION_RESTRICTIONS_CHALLENGE =
2501            "android.intent.action.RESTRICTIONS_CHALLENGE";
2502
2503    /**
2504     * Sent the first time a user is starting, to allow system apps to
2505     * perform one time initialization.  (This will not be seen by third
2506     * party applications because a newly initialized user does not have any
2507     * third party applications installed for it.)  This is sent early in
2508     * starting the user, around the time the home app is started, before
2509     * {@link #ACTION_BOOT_COMPLETED} is sent.  This is sent as a foreground
2510     * broadcast, since it is part of a visible user interaction; be as quick
2511     * as possible when handling it.
2512     */
2513    public static final String ACTION_USER_INITIALIZE =
2514            "android.intent.action.USER_INITIALIZE";
2515
2516    /**
2517     * Sent when a user switch is happening, causing the process's user to be
2518     * brought to the foreground.  This is only sent to receivers registered
2519     * through {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
2520     * Context.registerReceiver}.  It is sent to the user that is going to the
2521     * foreground.  This is sent as a foreground
2522     * broadcast, since it is part of a visible user interaction; be as quick
2523     * as possible when handling it.
2524     */
2525    public static final String ACTION_USER_FOREGROUND =
2526            "android.intent.action.USER_FOREGROUND";
2527
2528    /**
2529     * Sent when a user switch is happening, causing the process's user to be
2530     * sent to the background.  This is only sent to receivers registered
2531     * through {@link Context#registerReceiver(BroadcastReceiver, IntentFilter)
2532     * Context.registerReceiver}.  It is sent to the user that is going to the
2533     * background.  This is sent as a foreground
2534     * broadcast, since it is part of a visible user interaction; be as quick
2535     * as possible when handling it.
2536     */
2537    public static final String ACTION_USER_BACKGROUND =
2538            "android.intent.action.USER_BACKGROUND";
2539
2540    /**
2541     * Broadcast sent to the system when a user is added. Carries an extra
2542     * EXTRA_USER_HANDLE that has the userHandle of the new user.  It is sent to
2543     * all running users.  You must hold
2544     * {@link android.Manifest.permission#MANAGE_USERS} to receive this broadcast.
2545     * @hide
2546     */
2547    public static final String ACTION_USER_ADDED =
2548            "android.intent.action.USER_ADDED";
2549
2550    /**
2551     * Broadcast sent by the system when a user is started. Carries an extra
2552     * EXTRA_USER_HANDLE that has the userHandle of the user.  This is only sent to
2553     * registered receivers, not manifest receivers.  It is sent to the user
2554     * that has been started.  This is sent as a foreground
2555     * broadcast, since it is part of a visible user interaction; be as quick
2556     * as possible when handling it.
2557     * @hide
2558     */
2559    public static final String ACTION_USER_STARTED =
2560            "android.intent.action.USER_STARTED";
2561
2562    /**
2563     * Broadcast sent when a user is in the process of starting.  Carries an extra
2564     * EXTRA_USER_HANDLE that has the userHandle of the user.  This is only
2565     * sent to registered receivers, not manifest receivers.  It is sent to all
2566     * users (including the one that is being started).  You must hold
2567     * {@link android.Manifest.permission#INTERACT_ACROSS_USERS} to receive
2568     * this broadcast.  This is sent as a background broadcast, since
2569     * its result is not part of the primary UX flow; to safely keep track of
2570     * started/stopped state of a user you can use this in conjunction with
2571     * {@link #ACTION_USER_STOPPING}.  It is <b>not</b> generally safe to use with
2572     * other user state broadcasts since those are foreground broadcasts so can
2573     * execute in a different order.
2574     * @hide
2575     */
2576    public static final String ACTION_USER_STARTING =
2577            "android.intent.action.USER_STARTING";
2578
2579    /**
2580     * Broadcast sent when a user is going to be stopped.  Carries an extra
2581     * EXTRA_USER_HANDLE that has the userHandle of the user.  This is only
2582     * sent to registered receivers, not manifest receivers.  It is sent to all
2583     * users (including the one that is being stopped).  You must hold
2584     * {@link android.Manifest.permission#INTERACT_ACROSS_USERS} to receive
2585     * this broadcast.  The user will not stop until all receivers have
2586     * handled the broadcast.  This is sent as a background broadcast, since
2587     * its result is not part of the primary UX flow; to safely keep track of
2588     * started/stopped state of a user you can use this in conjunction with
2589     * {@link #ACTION_USER_STARTING}.  It is <b>not</b> generally safe to use with
2590     * other user state broadcasts since those are foreground broadcasts so can
2591     * execute in a different order.
2592     * @hide
2593     */
2594    public static final String ACTION_USER_STOPPING =
2595            "android.intent.action.USER_STOPPING";
2596
2597    /**
2598     * Broadcast sent to the system when a user is stopped. Carries an extra
2599     * EXTRA_USER_HANDLE that has the userHandle of the user.  This is similar to
2600     * {@link #ACTION_PACKAGE_RESTARTED}, but for an entire user instead of a
2601     * specific package.  This is only sent to registered receivers, not manifest
2602     * receivers.  It is sent to all running users <em>except</em> the one that
2603     * has just been stopped (which is no longer running).
2604     * @hide
2605     */
2606    public static final String ACTION_USER_STOPPED =
2607            "android.intent.action.USER_STOPPED";
2608
2609    /**
2610     * Broadcast sent to the system when a user is removed. Carries an extra EXTRA_USER_HANDLE that has
2611     * the userHandle of the user.  It is sent to all running users except the
2612     * one that has been removed. The user will not be completely removed until all receivers have
2613     * handled the broadcast. You must hold
2614     * {@link android.Manifest.permission#MANAGE_USERS} to receive this broadcast.
2615     * @hide
2616     */
2617    public static final String ACTION_USER_REMOVED =
2618            "android.intent.action.USER_REMOVED";
2619
2620    /**
2621     * Broadcast sent to the system when the user switches. Carries an extra EXTRA_USER_HANDLE that has
2622     * the userHandle of the user to become the current one. This is only sent to
2623     * registered receivers, not manifest receivers.  It is sent to all running users.
2624     * You must hold
2625     * {@link android.Manifest.permission#MANAGE_USERS} to receive this broadcast.
2626     * @hide
2627     */
2628    public static final String ACTION_USER_SWITCHED =
2629            "android.intent.action.USER_SWITCHED";
2630
2631    /**
2632     * Broadcast sent to the system when a user's information changes. Carries an extra
2633     * {@link #EXTRA_USER_HANDLE} to indicate which user's information changed.
2634     * This is only sent to registered receivers, not manifest receivers. It is sent to all users.
2635     * @hide
2636     */
2637    public static final String ACTION_USER_INFO_CHANGED =
2638            "android.intent.action.USER_INFO_CHANGED";
2639
2640    /**
2641     * Broadcast sent to the primary user when an associated managed profile is added (the profile
2642     * was created and is ready to be used). Carries an extra {@link #EXTRA_USER} that specifies
2643     * the UserHandle of the profile that was added. Only applications (for example Launchers)
2644     * that need to display merged content across both primary and managed profiles need to
2645     * worry about this broadcast. This is only sent to registered receivers,
2646     * not manifest receivers.
2647     */
2648    public static final String ACTION_MANAGED_PROFILE_ADDED =
2649            "android.intent.action.MANAGED_PROFILE_ADDED";
2650
2651    /**
2652     * Broadcast sent to the primary user when an associated managed profile is removed. Carries an
2653     * extra {@link #EXTRA_USER} that specifies the UserHandle of the profile that was removed.
2654     * Only applications (for example Launchers) that need to display merged content across both
2655     * primary and managed profiles need to worry about this broadcast. This is only sent to
2656     * registered receivers, not manifest receivers.
2657     */
2658    public static final String ACTION_MANAGED_PROFILE_REMOVED =
2659            "android.intent.action.MANAGED_PROFILE_REMOVED";
2660
2661    /**
2662     * Sent when the user taps on the clock widget in the system's "quick settings" area.
2663     */
2664    public static final String ACTION_QUICK_CLOCK =
2665            "android.intent.action.QUICK_CLOCK";
2666
2667    /**
2668     * Activity Action: Shows the brightness setting dialog.
2669     * @hide
2670     */
2671    public static final String ACTION_SHOW_BRIGHTNESS_DIALOG =
2672            "android.intent.action.SHOW_BRIGHTNESS_DIALOG";
2673
2674    /**
2675     * Broadcast Action:  A global button was pressed.  Includes a single
2676     * extra field, {@link #EXTRA_KEY_EVENT}, containing the key event that
2677     * caused the broadcast.
2678     * @hide
2679     */
2680    public static final String ACTION_GLOBAL_BUTTON = "android.intent.action.GLOBAL_BUTTON";
2681
2682    /**
2683     * Activity Action: Allow the user to select and return one or more existing
2684     * documents. When invoked, the system will display the various
2685     * {@link DocumentsProvider} instances installed on the device, letting the
2686     * user interactively navigate through them. These documents include local
2687     * media, such as photos and video, and documents provided by installed
2688     * cloud storage providers.
2689     * <p>
2690     * Each document is represented as a {@code content://} URI backed by a
2691     * {@link DocumentsProvider}, which can be opened as a stream with
2692     * {@link ContentResolver#openFileDescriptor(Uri, String)}, or queried for
2693     * {@link android.provider.DocumentsContract.Document} metadata.
2694     * <p>
2695     * All selected documents are returned to the calling application with
2696     * persistable read and write permission grants. If you want to maintain
2697     * access to the documents across device reboots, you need to explicitly
2698     * take the persistable permissions using
2699     * {@link ContentResolver#takePersistableUriPermission(Uri, int)}.
2700     * <p>
2701     * Callers must indicate the acceptable document MIME types through
2702     * {@link #setType(String)}. For example, to select photos, use
2703     * {@code image/*}. If multiple disjoint MIME types are acceptable, define
2704     * them in {@link #EXTRA_MIME_TYPES} and {@link #setType(String)} to
2705     * {@literal *}/*.
2706     * <p>
2707     * If the caller can handle multiple returned items (the user performing
2708     * multiple selection), then you can specify {@link #EXTRA_ALLOW_MULTIPLE}
2709     * to indicate this.
2710     * <p>
2711     * Callers must include {@link #CATEGORY_OPENABLE} in the Intent so that
2712     * returned URIs can be opened with
2713     * {@link ContentResolver#openFileDescriptor(Uri, String)}.
2714     * <p>
2715     * Output: The URI of the item that was picked, returned in
2716     * {@link #getData()}. This must be a {@code content://} URI so that any
2717     * receiver can access it. If multiple documents were selected, they are
2718     * returned in {@link #getClipData()}.
2719     *
2720     * @see DocumentsContract
2721     * @see #ACTION_OPEN_DOCUMENT_TREE
2722     * @see #ACTION_CREATE_DOCUMENT
2723     * @see #FLAG_GRANT_PERSISTABLE_URI_PERMISSION
2724     */
2725    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
2726    public static final String ACTION_OPEN_DOCUMENT = "android.intent.action.OPEN_DOCUMENT";
2727
2728    /**
2729     * Activity Action: Allow the user to create a new document. When invoked,
2730     * the system will display the various {@link DocumentsProvider} instances
2731     * installed on the device, letting the user navigate through them. The
2732     * returned document may be a newly created document with no content, or it
2733     * may be an existing document with the requested MIME type.
2734     * <p>
2735     * Each document is represented as a {@code content://} URI backed by a
2736     * {@link DocumentsProvider}, which can be opened as a stream with
2737     * {@link ContentResolver#openFileDescriptor(Uri, String)}, or queried for
2738     * {@link android.provider.DocumentsContract.Document} metadata.
2739     * <p>
2740     * Callers must indicate the concrete MIME type of the document being
2741     * created by setting {@link #setType(String)}. This MIME type cannot be
2742     * changed after the document is created.
2743     * <p>
2744     * Callers can provide an initial display name through {@link #EXTRA_TITLE},
2745     * but the user may change this value before creating the file.
2746     * <p>
2747     * Callers must include {@link #CATEGORY_OPENABLE} in the Intent so that
2748     * returned URIs can be opened with
2749     * {@link ContentResolver#openFileDescriptor(Uri, String)}.
2750     * <p>
2751     * Output: The URI of the item that was created. This must be a
2752     * {@code content://} URI so that any receiver can access it.
2753     *
2754     * @see DocumentsContract
2755     * @see #ACTION_OPEN_DOCUMENT
2756     * @see #ACTION_OPEN_DOCUMENT_TREE
2757     * @see #FLAG_GRANT_PERSISTABLE_URI_PERMISSION
2758     */
2759    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
2760    public static final String ACTION_CREATE_DOCUMENT = "android.intent.action.CREATE_DOCUMENT";
2761
2762    /**
2763     * Activity Action: Allow the user to pick a directory subtree. When
2764     * invoked, the system will display the various {@link DocumentsProvider}
2765     * instances installed on the device, letting the user navigate through
2766     * them. Apps can fully manage documents within the returned directory.
2767     * <p>
2768     * To gain access to descendant (child, grandchild, etc) documents, use
2769     * {@link DocumentsContract#buildDocumentUriUsingTree(Uri, String)} and
2770     * {@link DocumentsContract#buildChildDocumentsUriUsingTree(Uri, String)}
2771     * with the returned URI.
2772     * <p>
2773     * Output: The URI representing the selected directory tree.
2774     *
2775     * @see DocumentsContract
2776     */
2777    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
2778    public static final String
2779            ACTION_OPEN_DOCUMENT_TREE = "android.intent.action.OPEN_DOCUMENT_TREE";
2780
2781    /** {@hide} */
2782    public static final String ACTION_MASTER_CLEAR = "android.intent.action.MASTER_CLEAR";
2783
2784    // ---------------------------------------------------------------------
2785    // ---------------------------------------------------------------------
2786    // Standard intent categories (see addCategory()).
2787
2788    /**
2789     * Set if the activity should be an option for the default action
2790     * (center press) to perform on a piece of data.  Setting this will
2791     * hide from the user any activities without it set when performing an
2792     * action on some data.  Note that this is normally -not- set in the
2793     * Intent when initiating an action -- it is for use in intent filters
2794     * specified in packages.
2795     */
2796    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2797    public static final String CATEGORY_DEFAULT = "android.intent.category.DEFAULT";
2798    /**
2799     * Activities that can be safely invoked from a browser must support this
2800     * category.  For example, if the user is viewing a web page or an e-mail
2801     * and clicks on a link in the text, the Intent generated execute that
2802     * link will require the BROWSABLE category, so that only activities
2803     * supporting this category will be considered as possible actions.  By
2804     * supporting this category, you are promising that there is nothing
2805     * damaging (without user intervention) that can happen by invoking any
2806     * matching Intent.
2807     */
2808    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2809    public static final String CATEGORY_BROWSABLE = "android.intent.category.BROWSABLE";
2810    /**
2811     * @hide
2812     * Categories for activities that can participate in voice interaction.
2813     * An activity that supports this category must be prepared to run with
2814     * no UI shown at all (though in some case it may have a UI shown), and
2815     * rely on {@link android.app.VoiceInteractor} to interact with the user.
2816     */
2817    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2818    @SystemApi
2819    public static final String CATEGORY_VOICE = "android.intent.category.VOICE";
2820    /**
2821     * Set if the activity should be considered as an alternative action to
2822     * the data the user is currently viewing.  See also
2823     * {@link #CATEGORY_SELECTED_ALTERNATIVE} for an alternative action that
2824     * applies to the selection in a list of items.
2825     *
2826     * <p>Supporting this category means that you would like your activity to be
2827     * displayed in the set of alternative things the user can do, usually as
2828     * part of the current activity's options menu.  You will usually want to
2829     * include a specific label in the &lt;intent-filter&gt; of this action
2830     * describing to the user what it does.
2831     *
2832     * <p>The action of IntentFilter with this category is important in that it
2833     * describes the specific action the target will perform.  This generally
2834     * should not be a generic action (such as {@link #ACTION_VIEW}, but rather
2835     * a specific name such as "com.android.camera.action.CROP.  Only one
2836     * alternative of any particular action will be shown to the user, so using
2837     * a specific action like this makes sure that your alternative will be
2838     * displayed while also allowing other applications to provide their own
2839     * overrides of that particular action.
2840     */
2841    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2842    public static final String CATEGORY_ALTERNATIVE = "android.intent.category.ALTERNATIVE";
2843    /**
2844     * Set if the activity should be considered as an alternative selection
2845     * action to the data the user has currently selected.  This is like
2846     * {@link #CATEGORY_ALTERNATIVE}, but is used in activities showing a list
2847     * of items from which the user can select, giving them alternatives to the
2848     * default action that will be performed on it.
2849     */
2850    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2851    public static final String CATEGORY_SELECTED_ALTERNATIVE = "android.intent.category.SELECTED_ALTERNATIVE";
2852    /**
2853     * Intended to be used as a tab inside of a containing TabActivity.
2854     */
2855    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2856    public static final String CATEGORY_TAB = "android.intent.category.TAB";
2857    /**
2858     * Should be displayed in the top-level launcher.
2859     */
2860    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2861    public static final String CATEGORY_LAUNCHER = "android.intent.category.LAUNCHER";
2862    /**
2863     * Indicates an activity optimized for Leanback mode, and that should
2864     * be displayed in the Leanback launcher.
2865     */
2866    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2867    public static final String CATEGORY_LEANBACK_LAUNCHER = "android.intent.category.LEANBACK_LAUNCHER";
2868    /**
2869     * Indicates a Leanback settings activity to be displayed in the Leanback launcher.
2870     * @hide
2871     */
2872    @SystemApi
2873    public static final String CATEGORY_LEANBACK_SETTINGS = "android.intent.category.LEANBACK_SETTINGS";
2874    /**
2875     * Provides information about the package it is in; typically used if
2876     * a package does not contain a {@link #CATEGORY_LAUNCHER} to provide
2877     * a front-door to the user without having to be shown in the all apps list.
2878     */
2879    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2880    public static final String CATEGORY_INFO = "android.intent.category.INFO";
2881    /**
2882     * This is the home activity, that is the first activity that is displayed
2883     * when the device boots.
2884     */
2885    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2886    public static final String CATEGORY_HOME = "android.intent.category.HOME";
2887    /**
2888     * This activity is a preference panel.
2889     */
2890    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2891    public static final String CATEGORY_PREFERENCE = "android.intent.category.PREFERENCE";
2892    /**
2893     * This activity is a development preference panel.
2894     */
2895    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2896    public static final String CATEGORY_DEVELOPMENT_PREFERENCE = "android.intent.category.DEVELOPMENT_PREFERENCE";
2897    /**
2898     * Capable of running inside a parent activity container.
2899     */
2900    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2901    public static final String CATEGORY_EMBED = "android.intent.category.EMBED";
2902    /**
2903     * This activity allows the user to browse and download new applications.
2904     */
2905    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2906    public static final String CATEGORY_APP_MARKET = "android.intent.category.APP_MARKET";
2907    /**
2908     * This activity may be exercised by the monkey or other automated test tools.
2909     */
2910    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2911    public static final String CATEGORY_MONKEY = "android.intent.category.MONKEY";
2912    /**
2913     * To be used as a test (not part of the normal user experience).
2914     */
2915    public static final String CATEGORY_TEST = "android.intent.category.TEST";
2916    /**
2917     * To be used as a unit test (run through the Test Harness).
2918     */
2919    public static final String CATEGORY_UNIT_TEST = "android.intent.category.UNIT_TEST";
2920    /**
2921     * To be used as a sample code example (not part of the normal user
2922     * experience).
2923     */
2924    public static final String CATEGORY_SAMPLE_CODE = "android.intent.category.SAMPLE_CODE";
2925
2926    /**
2927     * Used to indicate that an intent only wants URIs that can be opened with
2928     * {@link ContentResolver#openFileDescriptor(Uri, String)}. Openable URIs
2929     * must support at least the columns defined in {@link OpenableColumns} when
2930     * queried.
2931     *
2932     * @see #ACTION_GET_CONTENT
2933     * @see #ACTION_OPEN_DOCUMENT
2934     * @see #ACTION_CREATE_DOCUMENT
2935     */
2936    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2937    public static final String CATEGORY_OPENABLE = "android.intent.category.OPENABLE";
2938
2939    /**
2940     * To be used as code under test for framework instrumentation tests.
2941     */
2942    public static final String CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST =
2943            "android.intent.category.FRAMEWORK_INSTRUMENTATION_TEST";
2944    /**
2945     * An activity to run when device is inserted into a car dock.
2946     * Used with {@link #ACTION_MAIN} to launch an activity.  For more
2947     * information, see {@link android.app.UiModeManager}.
2948     */
2949    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2950    public static final String CATEGORY_CAR_DOCK = "android.intent.category.CAR_DOCK";
2951    /**
2952     * An activity to run when device is inserted into a car dock.
2953     * Used with {@link #ACTION_MAIN} to launch an activity.  For more
2954     * information, see {@link android.app.UiModeManager}.
2955     */
2956    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2957    public static final String CATEGORY_DESK_DOCK = "android.intent.category.DESK_DOCK";
2958    /**
2959     * An activity to run when device is inserted into a analog (low end) dock.
2960     * Used with {@link #ACTION_MAIN} to launch an activity.  For more
2961     * information, see {@link android.app.UiModeManager}.
2962     */
2963    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2964    public static final String CATEGORY_LE_DESK_DOCK = "android.intent.category.LE_DESK_DOCK";
2965
2966    /**
2967     * An activity to run when device is inserted into a digital (high end) dock.
2968     * Used with {@link #ACTION_MAIN} to launch an activity.  For more
2969     * information, see {@link android.app.UiModeManager}.
2970     */
2971    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2972    public static final String CATEGORY_HE_DESK_DOCK = "android.intent.category.HE_DESK_DOCK";
2973
2974    /**
2975     * Used to indicate that the activity can be used in a car environment.
2976     */
2977    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2978    public static final String CATEGORY_CAR_MODE = "android.intent.category.CAR_MODE";
2979
2980    // ---------------------------------------------------------------------
2981    // ---------------------------------------------------------------------
2982    // Application launch intent categories (see addCategory()).
2983
2984    /**
2985     * Used with {@link #ACTION_MAIN} to launch the browser application.
2986     * The activity should be able to browse the Internet.
2987     * <p>NOTE: This should not be used as the primary key of an Intent,
2988     * since it will not result in the app launching with the correct
2989     * action and category.  Instead, use this with
2990     * {@link #makeMainSelectorActivity(String, String)} to generate a main
2991     * Intent with this category in the selector.</p>
2992     */
2993    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
2994    public static final String CATEGORY_APP_BROWSER = "android.intent.category.APP_BROWSER";
2995
2996    /**
2997     * Used with {@link #ACTION_MAIN} to launch the calculator application.
2998     * The activity should be able to perform standard arithmetic operations.
2999     * <p>NOTE: This should not be used as the primary key of an Intent,
3000     * since it will not result in the app launching with the correct
3001     * action and category.  Instead, use this with
3002     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3003     * Intent with this category in the selector.</p>
3004     */
3005    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3006    public static final String CATEGORY_APP_CALCULATOR = "android.intent.category.APP_CALCULATOR";
3007
3008    /**
3009     * Used with {@link #ACTION_MAIN} to launch the calendar application.
3010     * The activity should be able to view and manipulate calendar entries.
3011     * <p>NOTE: This should not be used as the primary key of an Intent,
3012     * since it will not result in the app launching with the correct
3013     * action and category.  Instead, use this with
3014     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3015     * Intent with this category in the selector.</p>
3016     */
3017    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3018    public static final String CATEGORY_APP_CALENDAR = "android.intent.category.APP_CALENDAR";
3019
3020    /**
3021     * Used with {@link #ACTION_MAIN} to launch the contacts application.
3022     * The activity should be able to view and manipulate address book entries.
3023     * <p>NOTE: This should not be used as the primary key of an Intent,
3024     * since it will not result in the app launching with the correct
3025     * action and category.  Instead, use this with
3026     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3027     * Intent with this category in the selector.</p>
3028     */
3029    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3030    public static final String CATEGORY_APP_CONTACTS = "android.intent.category.APP_CONTACTS";
3031
3032    /**
3033     * Used with {@link #ACTION_MAIN} to launch the email application.
3034     * The activity should be able to send and receive email.
3035     * <p>NOTE: This should not be used as the primary key of an Intent,
3036     * since it will not result in the app launching with the correct
3037     * action and category.  Instead, use this with
3038     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3039     * Intent with this category in the selector.</p>
3040     */
3041    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3042    public static final String CATEGORY_APP_EMAIL = "android.intent.category.APP_EMAIL";
3043
3044    /**
3045     * Used with {@link #ACTION_MAIN} to launch the gallery application.
3046     * The activity should be able to view and manipulate image and video files
3047     * stored on the device.
3048     * <p>NOTE: This should not be used as the primary key of an Intent,
3049     * since it will not result in the app launching with the correct
3050     * action and category.  Instead, use this with
3051     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3052     * Intent with this category in the selector.</p>
3053     */
3054    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3055    public static final String CATEGORY_APP_GALLERY = "android.intent.category.APP_GALLERY";
3056
3057    /**
3058     * Used with {@link #ACTION_MAIN} to launch the maps application.
3059     * The activity should be able to show the user's current location and surroundings.
3060     * <p>NOTE: This should not be used as the primary key of an Intent,
3061     * since it will not result in the app launching with the correct
3062     * action and category.  Instead, use this with
3063     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3064     * Intent with this category in the selector.</p>
3065     */
3066    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3067    public static final String CATEGORY_APP_MAPS = "android.intent.category.APP_MAPS";
3068
3069    /**
3070     * Used with {@link #ACTION_MAIN} to launch the messaging application.
3071     * The activity should be able to send and receive text messages.
3072     * <p>NOTE: This should not be used as the primary key of an Intent,
3073     * since it will not result in the app launching with the correct
3074     * action and category.  Instead, use this with
3075     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3076     * Intent with this category in the selector.</p>
3077     */
3078    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3079    public static final String CATEGORY_APP_MESSAGING = "android.intent.category.APP_MESSAGING";
3080
3081    /**
3082     * Used with {@link #ACTION_MAIN} to launch the music application.
3083     * The activity should be able to play, browse, or manipulate music files
3084     * stored on the device.
3085     * <p>NOTE: This should not be used as the primary key of an Intent,
3086     * since it will not result in the app launching with the correct
3087     * action and category.  Instead, use this with
3088     * {@link #makeMainSelectorActivity(String, String)} to generate a main
3089     * Intent with this category in the selector.</p>
3090     */
3091    @SdkConstant(SdkConstantType.INTENT_CATEGORY)
3092    public static final String CATEGORY_APP_MUSIC = "android.intent.category.APP_MUSIC";
3093
3094    // ---------------------------------------------------------------------
3095    // ---------------------------------------------------------------------
3096    // Standard extra data keys.
3097
3098    /**
3099     * The initial data to place in a newly created record.  Use with
3100     * {@link #ACTION_INSERT}.  The data here is a Map containing the same
3101     * fields as would be given to the underlying ContentProvider.insert()
3102     * call.
3103     */
3104    public static final String EXTRA_TEMPLATE = "android.intent.extra.TEMPLATE";
3105
3106    /**
3107     * A constant CharSequence that is associated with the Intent, used with
3108     * {@link #ACTION_SEND} to supply the literal data to be sent.  Note that
3109     * this may be a styled CharSequence, so you must use
3110     * {@link Bundle#getCharSequence(String) Bundle.getCharSequence()} to
3111     * retrieve it.
3112     */
3113    public static final String EXTRA_TEXT = "android.intent.extra.TEXT";
3114
3115    /**
3116     * A constant String that is associated with the Intent, used with
3117     * {@link #ACTION_SEND} to supply an alternative to {@link #EXTRA_TEXT}
3118     * as HTML formatted text.  Note that you <em>must</em> also supply
3119     * {@link #EXTRA_TEXT}.
3120     */
3121    public static final String EXTRA_HTML_TEXT = "android.intent.extra.HTML_TEXT";
3122
3123    /**
3124     * A content: URI holding a stream of data associated with the Intent,
3125     * used with {@link #ACTION_SEND} to supply the data being sent.
3126     */
3127    public static final String EXTRA_STREAM = "android.intent.extra.STREAM";
3128
3129    /**
3130     * A String[] holding e-mail addresses that should be delivered to.
3131     */
3132    public static final String EXTRA_EMAIL       = "android.intent.extra.EMAIL";
3133
3134    /**
3135     * A String[] holding e-mail addresses that should be carbon copied.
3136     */
3137    public static final String EXTRA_CC       = "android.intent.extra.CC";
3138
3139    /**
3140     * A String[] holding e-mail addresses that should be blind carbon copied.
3141     */
3142    public static final String EXTRA_BCC      = "android.intent.extra.BCC";
3143
3144    /**
3145     * A constant string holding the desired subject line of a message.
3146     */
3147    public static final String EXTRA_SUBJECT  = "android.intent.extra.SUBJECT";
3148
3149    /**
3150     * An Intent describing the choices you would like shown with
3151     * {@link #ACTION_PICK_ACTIVITY}.
3152     */
3153    public static final String EXTRA_INTENT = "android.intent.extra.INTENT";
3154
3155    /**
3156     * A CharSequence dialog title to provide to the user when used with a
3157     * {@link #ACTION_CHOOSER}.
3158     */
3159    public static final String EXTRA_TITLE = "android.intent.extra.TITLE";
3160
3161    /**
3162     * A Parcelable[] of {@link Intent} or
3163     * {@link android.content.pm.LabeledIntent} objects as set with
3164     * {@link #putExtra(String, Parcelable[])} of additional activities to place
3165     * a the front of the list of choices, when shown to the user with a
3166     * {@link #ACTION_CHOOSER}.
3167     */
3168    public static final String EXTRA_INITIAL_INTENTS = "android.intent.extra.INITIAL_INTENTS";
3169
3170    /**
3171     * A Bundle forming a mapping of potential target package names to different extras Bundles
3172     * to add to the default intent extras in {@link #EXTRA_INTENT} when used with
3173     * {@link #ACTION_CHOOSER}. Each key should be a package name. The package need not
3174     * be currently installed on the device.
3175     *
3176     * <p>An application may choose to provide alternate extras for the case where a user
3177     * selects an activity from a predetermined set of target packages. If the activity
3178     * the user selects from the chooser belongs to a package with its package name as
3179     * a key in this bundle, the corresponding extras for that package will be merged with
3180     * the extras already present in the intent at {@link #EXTRA_INTENT}. If a replacement
3181     * extra has the same key as an extra already present in the intent it will overwrite
3182     * the extra from the intent.</p>
3183     *
3184     * <p><em>Examples:</em>
3185     * <ul>
3186     *     <li>An application may offer different {@link #EXTRA_TEXT} to an application
3187     *     when sharing with it via {@link #ACTION_SEND}, augmenting a link with additional query
3188     *     parameters for that target.</li>
3189     *     <li>An application may offer additional metadata for known targets of a given intent
3190     *     to pass along information only relevant to that target such as account or content
3191     *     identifiers already known to that application.</li>
3192     * </ul></p>
3193     */
3194    public static final String EXTRA_REPLACEMENT_EXTRAS =
3195            "android.intent.extra.REPLACEMENT_EXTRAS";
3196
3197    /**
3198     * An {@link IntentSender} that will be notified if a user successfully chooses a target
3199     * component to handle an action in an {@link #ACTION_CHOOSER} activity. The IntentSender
3200     * will have the extra {@link #EXTRA_CHOSEN_COMPONENT} appended to it containing the
3201     * {@link ComponentName} of the chosen component.
3202     *
3203     * <p>In some situations this callback may never come, for example if the user abandons
3204     * the chooser, switches to another task or any number of other reasons. Apps should not
3205     * be written assuming that this callback will always occur.</p>
3206     */
3207    public static final String EXTRA_CHOSEN_COMPONENT_INTENT_SENDER =
3208            "android.intent.extra.CHOSEN_COMPONENT_INTENT_SENDER";
3209
3210    /**
3211     * The {@link ComponentName} chosen by the user to complete an action.
3212     *
3213     * @see #EXTRA_CHOSEN_COMPONENT_INTENT_SENDER
3214     */
3215    public static final String EXTRA_CHOSEN_COMPONENT = "android.intent.extra.CHOSEN_COMPONENT";
3216
3217    /**
3218     * A {@link android.view.KeyEvent} object containing the event that
3219     * triggered the creation of the Intent it is in.
3220     */
3221    public static final String EXTRA_KEY_EVENT = "android.intent.extra.KEY_EVENT";
3222
3223    /**
3224     * Set to true in {@link #ACTION_REQUEST_SHUTDOWN} to request confirmation from the user
3225     * before shutting down.
3226     *
3227     * {@hide}
3228     */
3229    public static final String EXTRA_KEY_CONFIRM = "android.intent.extra.KEY_CONFIRM";
3230
3231    /**
3232     * Used as a boolean extra field in {@link android.content.Intent#ACTION_PACKAGE_REMOVED} or
3233     * {@link android.content.Intent#ACTION_PACKAGE_CHANGED} intents to override the default action
3234     * of restarting the application.
3235     */
3236    public static final String EXTRA_DONT_KILL_APP = "android.intent.extra.DONT_KILL_APP";
3237
3238    /**
3239     * A String holding the phone number originally entered in
3240     * {@link android.content.Intent#ACTION_NEW_OUTGOING_CALL}, or the actual
3241     * number to call in a {@link android.content.Intent#ACTION_CALL}.
3242     */
3243    public static final String EXTRA_PHONE_NUMBER = "android.intent.extra.PHONE_NUMBER";
3244
3245    /**
3246     * Used as an int extra field in {@link android.content.Intent#ACTION_UID_REMOVED}
3247     * intents to supply the uid the package had been assigned.  Also an optional
3248     * extra in {@link android.content.Intent#ACTION_PACKAGE_REMOVED} or
3249     * {@link android.content.Intent#ACTION_PACKAGE_CHANGED} for the same
3250     * purpose.
3251     */
3252    public static final String EXTRA_UID = "android.intent.extra.UID";
3253
3254    /**
3255     * @hide String array of package names.
3256     */
3257    public static final String EXTRA_PACKAGES = "android.intent.extra.PACKAGES";
3258
3259    /**
3260     * Used as a boolean extra field in {@link android.content.Intent#ACTION_PACKAGE_REMOVED}
3261     * intents to indicate whether this represents a full uninstall (removing
3262     * both the code and its data) or a partial uninstall (leaving its data,
3263     * implying that this is an update).
3264     */
3265    public static final String EXTRA_DATA_REMOVED = "android.intent.extra.DATA_REMOVED";
3266
3267    /**
3268     * @hide
3269     * Used as a boolean extra field in {@link android.content.Intent#ACTION_PACKAGE_REMOVED}
3270     * intents to indicate that at this point the package has been removed for
3271     * all users on the device.
3272     */
3273    public static final String EXTRA_REMOVED_FOR_ALL_USERS
3274            = "android.intent.extra.REMOVED_FOR_ALL_USERS";
3275
3276    /**
3277     * Used as a boolean extra field in {@link android.content.Intent#ACTION_PACKAGE_REMOVED}
3278     * intents to indicate that this is a replacement of the package, so this
3279     * broadcast will immediately be followed by an add broadcast for a
3280     * different version of the same package.
3281     */
3282    public static final String EXTRA_REPLACING = "android.intent.extra.REPLACING";
3283
3284    /**
3285     * Used as an int extra field in {@link android.app.AlarmManager} intents
3286     * to tell the application being invoked how many pending alarms are being
3287     * delievered with the intent.  For one-shot alarms this will always be 1.
3288     * For recurring alarms, this might be greater than 1 if the device was
3289     * asleep or powered off at the time an earlier alarm would have been
3290     * delivered.
3291     */
3292    public static final String EXTRA_ALARM_COUNT = "android.intent.extra.ALARM_COUNT";
3293
3294    /**
3295     * Used as an int extra field in {@link android.content.Intent#ACTION_DOCK_EVENT}
3296     * intents to request the dock state.  Possible values are
3297     * {@link android.content.Intent#EXTRA_DOCK_STATE_UNDOCKED},
3298     * {@link android.content.Intent#EXTRA_DOCK_STATE_DESK}, or
3299     * {@link android.content.Intent#EXTRA_DOCK_STATE_CAR}, or
3300     * {@link android.content.Intent#EXTRA_DOCK_STATE_LE_DESK}, or
3301     * {@link android.content.Intent#EXTRA_DOCK_STATE_HE_DESK}.
3302     */
3303    public static final String EXTRA_DOCK_STATE = "android.intent.extra.DOCK_STATE";
3304
3305    /**
3306     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3307     * to represent that the phone is not in any dock.
3308     */
3309    public static final int EXTRA_DOCK_STATE_UNDOCKED = 0;
3310
3311    /**
3312     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3313     * to represent that the phone is in a desk dock.
3314     */
3315    public static final int EXTRA_DOCK_STATE_DESK = 1;
3316
3317    /**
3318     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3319     * to represent that the phone is in a car dock.
3320     */
3321    public static final int EXTRA_DOCK_STATE_CAR = 2;
3322
3323    /**
3324     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3325     * to represent that the phone is in a analog (low end) dock.
3326     */
3327    public static final int EXTRA_DOCK_STATE_LE_DESK = 3;
3328
3329    /**
3330     * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE}
3331     * to represent that the phone is in a digital (high end) dock.
3332     */
3333    public static final int EXTRA_DOCK_STATE_HE_DESK = 4;
3334
3335    /**
3336     * Boolean that can be supplied as meta-data with a dock activity, to
3337     * indicate that the dock should take over the home key when it is active.
3338     */
3339    public static final String METADATA_DOCK_HOME = "android.dock_home";
3340
3341    /**
3342     * Used as a parcelable extra field in {@link #ACTION_APP_ERROR}, containing
3343     * the bug report.
3344     */
3345    public static final String EXTRA_BUG_REPORT = "android.intent.extra.BUG_REPORT";
3346
3347    /**
3348     * Used in the extra field in the remote intent. It's astring token passed with the
3349     * remote intent.
3350     */
3351    public static final String EXTRA_REMOTE_INTENT_TOKEN =
3352            "android.intent.extra.remote_intent_token";
3353
3354    /**
3355     * @deprecated See {@link #EXTRA_CHANGED_COMPONENT_NAME_LIST}; this field
3356     * will contain only the first name in the list.
3357     */
3358    @Deprecated public static final String EXTRA_CHANGED_COMPONENT_NAME =
3359            "android.intent.extra.changed_component_name";
3360
3361    /**
3362     * This field is part of {@link android.content.Intent#ACTION_PACKAGE_CHANGED},
3363     * and contains a string array of all of the components that have changed.  If
3364     * the state of the overall package has changed, then it will contain an entry
3365     * with the package name itself.
3366     */
3367    public static final String EXTRA_CHANGED_COMPONENT_NAME_LIST =
3368            "android.intent.extra.changed_component_name_list";
3369
3370    /**
3371     * This field is part of
3372     * {@link android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_AVAILABLE},
3373     * {@link android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE}
3374     * and contains a string array of all of the components that have changed.
3375     */
3376    public static final String EXTRA_CHANGED_PACKAGE_LIST =
3377            "android.intent.extra.changed_package_list";
3378
3379    /**
3380     * This field is part of
3381     * {@link android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_AVAILABLE},
3382     * {@link android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE}
3383     * and contains an integer array of uids of all of the components
3384     * that have changed.
3385     */
3386    public static final String EXTRA_CHANGED_UID_LIST =
3387            "android.intent.extra.changed_uid_list";
3388
3389    /**
3390     * @hide
3391     * Magic extra system code can use when binding, to give a label for
3392     * who it is that has bound to a service.  This is an integer giving
3393     * a framework string resource that can be displayed to the user.
3394     */
3395    public static final String EXTRA_CLIENT_LABEL =
3396            "android.intent.extra.client_label";
3397
3398    /**
3399     * @hide
3400     * Magic extra system code can use when binding, to give a PendingIntent object
3401     * that can be launched for the user to disable the system's use of this
3402     * service.
3403     */
3404    public static final String EXTRA_CLIENT_INTENT =
3405            "android.intent.extra.client_intent";
3406
3407    /**
3408     * Extra used to indicate that an intent should only return data that is on
3409     * the local device. This is a boolean extra; the default is false. If true,
3410     * an implementation should only allow the user to select data that is
3411     * already on the device, not requiring it be downloaded from a remote
3412     * service when opened.
3413     *
3414     * @see #ACTION_GET_CONTENT
3415     * @see #ACTION_OPEN_DOCUMENT
3416     * @see #ACTION_OPEN_DOCUMENT_TREE
3417     * @see #ACTION_CREATE_DOCUMENT
3418     */
3419    public static final String EXTRA_LOCAL_ONLY =
3420            "android.intent.extra.LOCAL_ONLY";
3421
3422    /**
3423     * Extra used to indicate that an intent can allow the user to select and
3424     * return multiple items. This is a boolean extra; the default is false. If
3425     * true, an implementation is allowed to present the user with a UI where
3426     * they can pick multiple items that are all returned to the caller. When
3427     * this happens, they should be returned as the {@link #getClipData()} part
3428     * of the result Intent.
3429     *
3430     * @see #ACTION_GET_CONTENT
3431     * @see #ACTION_OPEN_DOCUMENT
3432     */
3433    public static final String EXTRA_ALLOW_MULTIPLE =
3434            "android.intent.extra.ALLOW_MULTIPLE";
3435
3436    /**
3437     * The integer userHandle carried with broadcast intents related to addition, removal and
3438     * switching of users and managed profiles - {@link #ACTION_USER_ADDED},
3439     * {@link #ACTION_USER_REMOVED} and {@link #ACTION_USER_SWITCHED}.
3440     *
3441     * @hide
3442     */
3443    public static final String EXTRA_USER_HANDLE =
3444            "android.intent.extra.user_handle";
3445
3446    /**
3447     * The UserHandle carried with broadcasts intents related to addition and removal of managed
3448     * profiles - {@link #ACTION_MANAGED_PROFILE_ADDED} and {@link #ACTION_MANAGED_PROFILE_REMOVED}.
3449     */
3450    public static final String EXTRA_USER =
3451            "android.intent.extra.USER";
3452
3453    /**
3454     * Extra used in the response from a BroadcastReceiver that handles
3455     * {@link #ACTION_GET_RESTRICTION_ENTRIES}. The type of the extra is
3456     * <code>ArrayList&lt;RestrictionEntry&gt;</code>.
3457     */
3458    public static final String EXTRA_RESTRICTIONS_LIST = "android.intent.extra.restrictions_list";
3459
3460    /**
3461     * Extra sent in the intent to the BroadcastReceiver that handles
3462     * {@link #ACTION_GET_RESTRICTION_ENTRIES}. The type of the extra is a Bundle containing
3463     * the restrictions as key/value pairs.
3464     */
3465    public static final String EXTRA_RESTRICTIONS_BUNDLE =
3466            "android.intent.extra.restrictions_bundle";
3467
3468    /**
3469     * Extra used in the response from a BroadcastReceiver that handles
3470     * {@link #ACTION_GET_RESTRICTION_ENTRIES}.
3471     */
3472    public static final String EXTRA_RESTRICTIONS_INTENT =
3473            "android.intent.extra.restrictions_intent";
3474
3475    /**
3476     * Extra used to communicate a set of acceptable MIME types. The type of the
3477     * extra is {@code String[]}. Values may be a combination of concrete MIME
3478     * types (such as "image/png") and/or partial MIME types (such as
3479     * "audio/*").
3480     *
3481     * @see #ACTION_GET_CONTENT
3482     * @see #ACTION_OPEN_DOCUMENT
3483     */
3484    public static final String EXTRA_MIME_TYPES = "android.intent.extra.MIME_TYPES";
3485
3486    /**
3487     * Optional extra for {@link #ACTION_SHUTDOWN} that allows the sender to qualify that
3488     * this shutdown is only for the user space of the system, not a complete shutdown.
3489     * When this is true, hardware devices can use this information to determine that
3490     * they shouldn't do a complete shutdown of their device since this is not a
3491     * complete shutdown down to the kernel, but only user space restarting.
3492     * The default if not supplied is false.
3493     */
3494    public static final String EXTRA_SHUTDOWN_USERSPACE_ONLY
3495            = "android.intent.extra.SHUTDOWN_USERSPACE_ONLY";
3496
3497    /**
3498     * Optional boolean extra for {@link #ACTION_TIME_CHANGED} that indicates the
3499     * user has set their time format preferences to the 24 hour format.
3500     *
3501     * @hide for internal use only.
3502     */
3503    public static final String EXTRA_TIME_PREF_24_HOUR_FORMAT =
3504            "android.intent.extra.TIME_PREF_24_HOUR_FORMAT";
3505
3506    /** {@hide} */
3507    public static final String EXTRA_REASON = "android.intent.extra.REASON";
3508
3509    // ---------------------------------------------------------------------
3510    // ---------------------------------------------------------------------
3511    // Intent flags (see mFlags variable).
3512
3513    /** @hide */
3514    @IntDef(flag = true, value = {
3515            FLAG_GRANT_READ_URI_PERMISSION, FLAG_GRANT_WRITE_URI_PERMISSION,
3516            FLAG_GRANT_PERSISTABLE_URI_PERMISSION, FLAG_GRANT_PREFIX_URI_PERMISSION })
3517    @Retention(RetentionPolicy.SOURCE)
3518    public @interface GrantUriMode {}
3519
3520    /** @hide */
3521    @IntDef(flag = true, value = {
3522            FLAG_GRANT_READ_URI_PERMISSION, FLAG_GRANT_WRITE_URI_PERMISSION })
3523    @Retention(RetentionPolicy.SOURCE)
3524    public @interface AccessUriMode {}
3525
3526    /**
3527     * Test if given mode flags specify an access mode, which must be at least
3528     * read and/or write.
3529     *
3530     * @hide
3531     */
3532    public static boolean isAccessUriMode(int modeFlags) {
3533        return (modeFlags & (Intent.FLAG_GRANT_READ_URI_PERMISSION
3534                | Intent.FLAG_GRANT_WRITE_URI_PERMISSION)) != 0;
3535    }
3536
3537    /**
3538     * If set, the recipient of this Intent will be granted permission to
3539     * perform read operations on the URI in the Intent's data and any URIs
3540     * specified in its ClipData.  When applying to an Intent's ClipData,
3541     * all URIs as well as recursive traversals through data or other ClipData
3542     * in Intent items will be granted; only the grant flags of the top-level
3543     * Intent are used.
3544     */
3545    public static final int FLAG_GRANT_READ_URI_PERMISSION = 0x00000001;
3546    /**
3547     * If set, the recipient of this Intent will be granted permission to
3548     * perform write operations on the URI in the Intent's data and any URIs
3549     * specified in its ClipData.  When applying to an Intent's ClipData,
3550     * all URIs as well as recursive traversals through data or other ClipData
3551     * in Intent items will be granted; only the grant flags of the top-level
3552     * Intent are used.
3553     */
3554    public static final int FLAG_GRANT_WRITE_URI_PERMISSION = 0x00000002;
3555    /**
3556     * Can be set by the caller to indicate that this Intent is coming from
3557     * a background operation, not from direct user interaction.
3558     */
3559    public static final int FLAG_FROM_BACKGROUND = 0x00000004;
3560    /**
3561     * A flag you can enable for debugging: when set, log messages will be
3562     * printed during the resolution of this intent to show you what has
3563     * been found to create the final resolved list.
3564     */
3565    public static final int FLAG_DEBUG_LOG_RESOLUTION = 0x00000008;
3566    /**
3567     * If set, this intent will not match any components in packages that
3568     * are currently stopped.  If this is not set, then the default behavior
3569     * is to include such applications in the result.
3570     */
3571    public static final int FLAG_EXCLUDE_STOPPED_PACKAGES = 0x00000010;
3572    /**
3573     * If set, this intent will always match any components in packages that
3574     * are currently stopped.  This is the default behavior when
3575     * {@link #FLAG_EXCLUDE_STOPPED_PACKAGES} is not set.  If both of these
3576     * flags are set, this one wins (it allows overriding of exclude for
3577     * places where the framework may automatically set the exclude flag).
3578     */
3579    public static final int FLAG_INCLUDE_STOPPED_PACKAGES = 0x00000020;
3580
3581    /**
3582     * When combined with {@link #FLAG_GRANT_READ_URI_PERMISSION} and/or
3583     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, the URI permission grant can be
3584     * persisted across device reboots until explicitly revoked with
3585     * {@link Context#revokeUriPermission(Uri, int)}. This flag only offers the
3586     * grant for possible persisting; the receiving application must call
3587     * {@link ContentResolver#takePersistableUriPermission(Uri, int)} to
3588     * actually persist.
3589     *
3590     * @see ContentResolver#takePersistableUriPermission(Uri, int)
3591     * @see ContentResolver#releasePersistableUriPermission(Uri, int)
3592     * @see ContentResolver#getPersistedUriPermissions()
3593     * @see ContentResolver#getOutgoingPersistedUriPermissions()
3594     */
3595    public static final int FLAG_GRANT_PERSISTABLE_URI_PERMISSION = 0x00000040;
3596
3597    /**
3598     * When combined with {@link #FLAG_GRANT_READ_URI_PERMISSION} and/or
3599     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, the URI permission grant
3600     * applies to any URI that is a prefix match against the original granted
3601     * URI. (Without this flag, the URI must match exactly for access to be
3602     * granted.) Another URI is considered a prefix match only when scheme,
3603     * authority, and all path segments defined by the prefix are an exact
3604     * match.
3605     */
3606    public static final int FLAG_GRANT_PREFIX_URI_PERMISSION = 0x00000080;
3607
3608    /**
3609     * If set, the new activity is not kept in the history stack.  As soon as
3610     * the user navigates away from it, the activity is finished.  This may also
3611     * be set with the {@link android.R.styleable#AndroidManifestActivity_noHistory
3612     * noHistory} attribute.
3613     *
3614     * <p>If set, {@link android.app.Activity#onActivityResult onActivityResult()}
3615     * is never invoked when the current activity starts a new activity which
3616     * sets a result and finishes.
3617     */
3618    public static final int FLAG_ACTIVITY_NO_HISTORY = 0x40000000;
3619    /**
3620     * If set, the activity will not be launched if it is already running
3621     * at the top of the history stack.
3622     */
3623    public static final int FLAG_ACTIVITY_SINGLE_TOP = 0x20000000;
3624    /**
3625     * If set, this activity will become the start of a new task on this
3626     * history stack.  A task (from the activity that started it to the
3627     * next task activity) defines an atomic group of activities that the
3628     * user can move to.  Tasks can be moved to the foreground and background;
3629     * all of the activities inside of a particular task always remain in
3630     * the same order.  See
3631     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
3632     * Stack</a> for more information about tasks.
3633     *
3634     * <p>This flag is generally used by activities that want
3635     * to present a "launcher" style behavior: they give the user a list of
3636     * separate things that can be done, which otherwise run completely
3637     * independently of the activity launching them.
3638     *
3639     * <p>When using this flag, if a task is already running for the activity
3640     * you are now starting, then a new activity will not be started; instead,
3641     * the current task will simply be brought to the front of the screen with
3642     * the state it was last in.  See {@link #FLAG_ACTIVITY_MULTIPLE_TASK} for a flag
3643     * to disable this behavior.
3644     *
3645     * <p>This flag can not be used when the caller is requesting a result from
3646     * the activity being launched.
3647     */
3648    public static final int FLAG_ACTIVITY_NEW_TASK = 0x10000000;
3649    /**
3650     * This flag is used to create a new task and launch an activity into it.
3651     * This flag is always paired with either {@link #FLAG_ACTIVITY_NEW_DOCUMENT}
3652     * or {@link #FLAG_ACTIVITY_NEW_TASK}. In both cases these flags alone would
3653     * search through existing tasks for ones matching this Intent. Only if no such
3654     * task is found would a new task be created. When paired with
3655     * FLAG_ACTIVITY_MULTIPLE_TASK both of these behaviors are modified to skip
3656     * the search for a matching task and unconditionally start a new task.
3657     *
3658     * <strong>When used with {@link #FLAG_ACTIVITY_NEW_TASK} do not use this
3659     * flag unless you are implementing your own
3660     * top-level application launcher.</strong>  Used in conjunction with
3661     * {@link #FLAG_ACTIVITY_NEW_TASK} to disable the
3662     * behavior of bringing an existing task to the foreground.  When set,
3663     * a new task is <em>always</em> started to host the Activity for the
3664     * Intent, regardless of whether there is already an existing task running
3665     * the same thing.
3666     *
3667     * <p><strong>Because the default system does not include graphical task management,
3668     * you should not use this flag unless you provide some way for a user to
3669     * return back to the tasks you have launched.</strong>
3670     *
3671     * See {@link #FLAG_ACTIVITY_NEW_DOCUMENT} for details of this flag's use for
3672     * creating new document tasks.
3673     *
3674     * <p>This flag is ignored if one of {@link #FLAG_ACTIVITY_NEW_TASK} or
3675     * {@link #FLAG_ACTIVITY_NEW_DOCUMENT} is not also set.
3676     *
3677     * <p>See
3678     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
3679     * Stack</a> for more information about tasks.
3680     *
3681     * @see #FLAG_ACTIVITY_NEW_DOCUMENT
3682     * @see #FLAG_ACTIVITY_NEW_TASK
3683     */
3684    public static final int FLAG_ACTIVITY_MULTIPLE_TASK = 0x08000000;
3685    /**
3686     * If set, and the activity being launched is already running in the
3687     * current task, then instead of launching a new instance of that activity,
3688     * all of the other activities on top of it will be closed and this Intent
3689     * will be delivered to the (now on top) old activity as a new Intent.
3690     *
3691     * <p>For example, consider a task consisting of the activities: A, B, C, D.
3692     * If D calls startActivity() with an Intent that resolves to the component
3693     * of activity B, then C and D will be finished and B receive the given
3694     * Intent, resulting in the stack now being: A, B.
3695     *
3696     * <p>The currently running instance of activity B in the above example will
3697     * either receive the new intent you are starting here in its
3698     * onNewIntent() method, or be itself finished and restarted with the
3699     * new intent.  If it has declared its launch mode to be "multiple" (the
3700     * default) and you have not set {@link #FLAG_ACTIVITY_SINGLE_TOP} in
3701     * the same intent, then it will be finished and re-created; for all other
3702     * launch modes or if {@link #FLAG_ACTIVITY_SINGLE_TOP} is set then this
3703     * Intent will be delivered to the current instance's onNewIntent().
3704     *
3705     * <p>This launch mode can also be used to good effect in conjunction with
3706     * {@link #FLAG_ACTIVITY_NEW_TASK}: if used to start the root activity
3707     * of a task, it will bring any currently running instance of that task
3708     * to the foreground, and then clear it to its root state.  This is
3709     * especially useful, for example, when launching an activity from the
3710     * notification manager.
3711     *
3712     * <p>See
3713     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
3714     * Stack</a> for more information about tasks.
3715     */
3716    public static final int FLAG_ACTIVITY_CLEAR_TOP = 0x04000000;
3717    /**
3718     * If set and this intent is being used to launch a new activity from an
3719     * existing one, then the reply target of the existing activity will be
3720     * transfered to the new activity.  This way the new activity can call
3721     * {@link android.app.Activity#setResult} and have that result sent back to
3722     * the reply target of the original activity.
3723     */
3724    public static final int FLAG_ACTIVITY_FORWARD_RESULT = 0x02000000;
3725    /**
3726     * If set and this intent is being used to launch a new activity from an
3727     * existing one, the current activity will not be counted as the top
3728     * activity for deciding whether the new intent should be delivered to
3729     * the top instead of starting a new one.  The previous activity will
3730     * be used as the top, with the assumption being that the current activity
3731     * will finish itself immediately.
3732     */
3733    public static final int FLAG_ACTIVITY_PREVIOUS_IS_TOP = 0x01000000;
3734    /**
3735     * If set, the new activity is not kept in the list of recently launched
3736     * activities.
3737     */
3738    public static final int FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS = 0x00800000;
3739    /**
3740     * This flag is not normally set by application code, but set for you by
3741     * the system as described in the
3742     * {@link android.R.styleable#AndroidManifestActivity_launchMode
3743     * launchMode} documentation for the singleTask mode.
3744     */
3745    public static final int FLAG_ACTIVITY_BROUGHT_TO_FRONT = 0x00400000;
3746    /**
3747     * If set, and this activity is either being started in a new task or
3748     * bringing to the top an existing task, then it will be launched as
3749     * the front door of the task.  This will result in the application of
3750     * any affinities needed to have that task in the proper state (either
3751     * moving activities to or from it), or simply resetting that task to
3752     * its initial state if needed.
3753     */
3754    public static final int FLAG_ACTIVITY_RESET_TASK_IF_NEEDED = 0x00200000;
3755    /**
3756     * This flag is not normally set by application code, but set for you by
3757     * the system if this activity is being launched from history
3758     * (longpress home key).
3759     */
3760    public static final int FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY = 0x00100000;
3761    /**
3762     * @deprecated As of API 21 this performs identically to
3763     * {@link #FLAG_ACTIVITY_NEW_DOCUMENT} which should be used instead of this.
3764     */
3765    public static final int FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET = 0x00080000;
3766    /**
3767     * This flag is used to open a document into a new task rooted at the activity launched
3768     * by this Intent. Through the use of this flag, or its equivalent attribute,
3769     * {@link android.R.attr#documentLaunchMode} multiple instances of the same activity
3770     * containing different documents will appear in the recent tasks list.
3771     *
3772     * <p>The use of the activity attribute form of this,
3773     * {@link android.R.attr#documentLaunchMode}, is
3774     * preferred over the Intent flag described here. The attribute form allows the
3775     * Activity to specify multiple document behavior for all launchers of the Activity
3776     * whereas using this flag requires each Intent that launches the Activity to specify it.
3777     *
3778     * <p>Note that the default semantics of this flag w.r.t. whether the recents entry for
3779     * it is kept after the activity is finished is different than the use of
3780     * {@link #FLAG_ACTIVITY_NEW_TASK} and {@link android.R.attr#documentLaunchMode} -- if
3781     * this flag is being used to create a new recents entry, then by default that entry
3782     * will be removed once the activity is finished.  You can modify this behavior with
3783     * {@link #FLAG_ACTIVITY_RETAIN_IN_RECENTS}.
3784     *
3785     * <p>FLAG_ACTIVITY_NEW_DOCUMENT may be used in conjunction with {@link
3786     * #FLAG_ACTIVITY_MULTIPLE_TASK}. When used alone it is the
3787     * equivalent of the Activity manifest specifying {@link
3788     * android.R.attr#documentLaunchMode}="intoExisting". When used with
3789     * FLAG_ACTIVITY_MULTIPLE_TASK it is the equivalent of the Activity manifest specifying
3790     * {@link android.R.attr#documentLaunchMode}="always".
3791     *
3792     * Refer to {@link android.R.attr#documentLaunchMode} for more information.
3793     *
3794     * @see android.R.attr#documentLaunchMode
3795     * @see #FLAG_ACTIVITY_MULTIPLE_TASK
3796     */
3797    public static final int FLAG_ACTIVITY_NEW_DOCUMENT = FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET;
3798    /**
3799     * If set, this flag will prevent the normal {@link android.app.Activity#onUserLeaveHint}
3800     * callback from occurring on the current frontmost activity before it is
3801     * paused as the newly-started activity is brought to the front.
3802     *
3803     * <p>Typically, an activity can rely on that callback to indicate that an
3804     * explicit user action has caused their activity to be moved out of the
3805     * foreground. The callback marks an appropriate point in the activity's
3806     * lifecycle for it to dismiss any notifications that it intends to display
3807     * "until the user has seen them," such as a blinking LED.
3808     *
3809     * <p>If an activity is ever started via any non-user-driven events such as
3810     * phone-call receipt or an alarm handler, this flag should be passed to {@link
3811     * Context#startActivity Context.startActivity}, ensuring that the pausing
3812     * activity does not think the user has acknowledged its notification.
3813     */
3814    public static final int FLAG_ACTIVITY_NO_USER_ACTION = 0x00040000;
3815    /**
3816     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
3817     * this flag will cause the launched activity to be brought to the front of its
3818     * task's history stack if it is already running.
3819     *
3820     * <p>For example, consider a task consisting of four activities: A, B, C, D.
3821     * If D calls startActivity() with an Intent that resolves to the component
3822     * of activity B, then B will be brought to the front of the history stack,
3823     * with this resulting order:  A, C, D, B.
3824     *
3825     * This flag will be ignored if {@link #FLAG_ACTIVITY_CLEAR_TOP} is also
3826     * specified.
3827     */
3828    public static final int FLAG_ACTIVITY_REORDER_TO_FRONT = 0X00020000;
3829    /**
3830     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
3831     * this flag will prevent the system from applying an activity transition
3832     * animation to go to the next activity state.  This doesn't mean an
3833     * animation will never run -- if another activity change happens that doesn't
3834     * specify this flag before the activity started here is displayed, then
3835     * that transition will be used.  This flag can be put to good use
3836     * when you are going to do a series of activity operations but the
3837     * animation seen by the user shouldn't be driven by the first activity
3838     * change but rather a later one.
3839     */
3840    public static final int FLAG_ACTIVITY_NO_ANIMATION = 0X00010000;
3841    /**
3842     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
3843     * this flag will cause any existing task that would be associated with the
3844     * activity to be cleared before the activity is started.  That is, the activity
3845     * becomes the new root of an otherwise empty task, and any old activities
3846     * are finished.  This can only be used in conjunction with {@link #FLAG_ACTIVITY_NEW_TASK}.
3847     */
3848    public static final int FLAG_ACTIVITY_CLEAR_TASK = 0X00008000;
3849    /**
3850     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
3851     * this flag will cause a newly launching task to be placed on top of the current
3852     * home activity task (if there is one).  That is, pressing back from the task
3853     * will always return the user to home even if that was not the last activity they
3854     * saw.   This can only be used in conjunction with {@link #FLAG_ACTIVITY_NEW_TASK}.
3855     */
3856    public static final int FLAG_ACTIVITY_TASK_ON_HOME = 0X00004000;
3857    /**
3858     * By default a document created by {@link #FLAG_ACTIVITY_NEW_DOCUMENT} will
3859     * have its entry in recent tasks removed when the user closes it (with back
3860     * or however else it may finish()). If you would like to instead allow the
3861     * document to be kept in recents so that it can be re-launched, you can use
3862     * this flag. When set and the task's activity is finished, the recents
3863     * entry will remain in the interface for the user to re-launch it, like a
3864     * recents entry for a top-level application.
3865     * <p>
3866     * The receiving activity can override this request with
3867     * {@link android.R.attr#autoRemoveFromRecents} or by explcitly calling
3868     * {@link android.app.Activity#finishAndRemoveTask()
3869     * Activity.finishAndRemoveTask()}.
3870     */
3871    public static final int FLAG_ACTIVITY_RETAIN_IN_RECENTS = 0x00002000;
3872
3873    /**
3874     * If set, when sending a broadcast only registered receivers will be
3875     * called -- no BroadcastReceiver components will be launched.
3876     */
3877    public static final int FLAG_RECEIVER_REGISTERED_ONLY = 0x40000000;
3878    /**
3879     * If set, when sending a broadcast the new broadcast will replace
3880     * any existing pending broadcast that matches it.  Matching is defined
3881     * by {@link Intent#filterEquals(Intent) Intent.filterEquals} returning
3882     * true for the intents of the two broadcasts.  When a match is found,
3883     * the new broadcast (and receivers associated with it) will replace the
3884     * existing one in the pending broadcast list, remaining at the same
3885     * position in the list.
3886     *
3887     * <p>This flag is most typically used with sticky broadcasts, which
3888     * only care about delivering the most recent values of the broadcast
3889     * to their receivers.
3890     */
3891    public static final int FLAG_RECEIVER_REPLACE_PENDING = 0x20000000;
3892    /**
3893     * If set, when sending a broadcast the recipient is allowed to run at
3894     * foreground priority, with a shorter timeout interval.  During normal
3895     * broadcasts the receivers are not automatically hoisted out of the
3896     * background priority class.
3897     */
3898    public static final int FLAG_RECEIVER_FOREGROUND = 0x10000000;
3899    /**
3900     * If this is an ordered broadcast, don't allow receivers to abort the broadcast.
3901     * They can still propagate results through to later receivers, but they can not prevent
3902     * later receivers from seeing the broadcast.
3903     */
3904    public static final int FLAG_RECEIVER_NO_ABORT = 0x08000000;
3905    /**
3906     * If set, when sending a broadcast <i>before boot has completed</i> only
3907     * registered receivers will be called -- no BroadcastReceiver components
3908     * will be launched.  Sticky intent state will be recorded properly even
3909     * if no receivers wind up being called.  If {@link #FLAG_RECEIVER_REGISTERED_ONLY}
3910     * is specified in the broadcast intent, this flag is unnecessary.
3911     *
3912     * <p>This flag is only for use by system sevices as a convenience to
3913     * avoid having to implement a more complex mechanism around detection
3914     * of boot completion.
3915     *
3916     * @hide
3917     */
3918    public static final int FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT = 0x04000000;
3919    /**
3920     * Set when this broadcast is for a boot upgrade, a special mode that
3921     * allows the broadcast to be sent before the system is ready and launches
3922     * the app process with no providers running in it.
3923     * @hide
3924     */
3925    public static final int FLAG_RECEIVER_BOOT_UPGRADE = 0x02000000;
3926
3927    /**
3928     * @hide Flags that can't be changed with PendingIntent.
3929     */
3930    public static final int IMMUTABLE_FLAGS = FLAG_GRANT_READ_URI_PERMISSION
3931            | FLAG_GRANT_WRITE_URI_PERMISSION | FLAG_GRANT_PERSISTABLE_URI_PERMISSION
3932            | FLAG_GRANT_PREFIX_URI_PERMISSION;
3933
3934    // ---------------------------------------------------------------------
3935    // ---------------------------------------------------------------------
3936    // toUri() and parseUri() options.
3937
3938    /**
3939     * Flag for use with {@link #toUri} and {@link #parseUri}: the URI string
3940     * always has the "intent:" scheme.  This syntax can be used when you want
3941     * to later disambiguate between URIs that are intended to describe an
3942     * Intent vs. all others that should be treated as raw URIs.  When used
3943     * with {@link #parseUri}, any other scheme will result in a generic
3944     * VIEW action for that raw URI.
3945     */
3946    public static final int URI_INTENT_SCHEME = 1<<0;
3947
3948    /**
3949     * Flag for use with {@link #toUri} and {@link #parseUri}: the URI string
3950     * always has the "android-app:" scheme.  This is a variation of
3951     * {@link #URI_INTENT_SCHEME} whose format is simpler for the case of an
3952     * http/https URI being delivered to a specific package name.  The format
3953     * is:
3954     *
3955     * <pre class="prettyprint">
3956     * android-app://{package_id}[/{scheme}[/{host}[/{path}]]][#Intent;{...}]</pre>
3957     *
3958     * <p>In this scheme, only the <code>package_id</code> is required.  If you include a host,
3959     * you must also include a scheme; including a path also requires both a host and a scheme.
3960     * The final #Intent; fragment can be used without a scheme, host, or path.
3961     * Note that this can not be
3962     * used with intents that have a {@link #setSelector}, since the base intent
3963     * will always have an explicit package name.</p>
3964     *
3965     * <p>Some examples of how this scheme maps to Intent objects:</p>
3966     * <table border="2" width="85%" align="center" frame="hsides" rules="rows">
3967     *     <colgroup align="left" />
3968     *     <colgroup align="left" />
3969     *     <thead>
3970     *     <tr><th>URI</th> <th>Intent</th></tr>
3971     *     </thead>
3972     *
3973     *     <tbody>
3974     *     <tr><td><code>android-app://com.example.app</code></td>
3975     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
3976     *             <tr><td>Action: </td><td>{@link #ACTION_MAIN}</td></tr>
3977     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
3978     *         </table></td>
3979     *     </tr>
3980     *     <tr><td><code>android-app://com.example.app/http/example.com</code></td>
3981     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
3982     *             <tr><td>Action: </td><td>{@link #ACTION_VIEW}</td></tr>
3983     *             <tr><td>Data: </td><td><code>http://example.com/</code></td></tr>
3984     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
3985     *         </table></td>
3986     *     </tr>
3987     *     <tr><td><code>android-app://com.example.app/http/example.com/foo?1234</code></td>
3988     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
3989     *             <tr><td>Action: </td><td>{@link #ACTION_VIEW}</td></tr>
3990     *             <tr><td>Data: </td><td><code>http://example.com/foo?1234</code></td></tr>
3991     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
3992     *         </table></td>
3993     *     </tr>
3994     *     <tr><td><code>android-app://com.example.app/<br />#Intent;action=com.example.MY_ACTION;end</code></td>
3995     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
3996     *             <tr><td>Action: </td><td><code>com.example.MY_ACTION</code></td></tr>
3997     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
3998     *         </table></td>
3999     *     </tr>
4000     *     <tr><td><code>android-app://com.example.app/http/example.com/foo?1234<br />#Intent;action=com.example.MY_ACTION;end</code></td>
4001     *         <td><table style="margin:0;border:0;cellpadding:0;cellspacing:0">
4002     *             <tr><td>Action: </td><td><code>com.example.MY_ACTION</code></td></tr>
4003     *             <tr><td>Data: </td><td><code>http://example.com/foo?1234</code></td></tr>
4004     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
4005     *         </table></td>
4006     *     </tr>
4007     *     <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>
4008     *         <td><table border="" style="margin:0" >
4009     *             <tr><td>Action: </td><td><code>com.example.MY_ACTION</code></td></tr>
4010     *             <tr><td>Package: </td><td><code>com.example.app</code></td></tr>
4011     *             <tr><td>Extras: </td><td><code>some_int=(int)100<br />some_str=(String)hello</code></td></tr>
4012     *         </table></td>
4013     *     </tr>
4014     *     </tbody>
4015     * </table>
4016     */
4017    public static final int URI_ANDROID_APP_SCHEME = 1<<1;
4018
4019    /**
4020     * Flag for use with {@link #toUri} and {@link #parseUri}: allow parsing
4021     * of unsafe information.  In particular, the flags {@link #FLAG_GRANT_READ_URI_PERMISSION},
4022     * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, {@link #FLAG_GRANT_PERSISTABLE_URI_PERMISSION},
4023     * and {@link #FLAG_GRANT_PREFIX_URI_PERMISSION} flags can not be set, so that the
4024     * generated Intent can not cause unexpected data access to happen.
4025     *
4026     * <p>If you do not trust the source of the URI being parsed, you should still do further
4027     * processing to protect yourself from it.  In particular, when using it to start an
4028     * activity you should usually add in {@link #CATEGORY_BROWSABLE} to limit the activities
4029     * that can handle it.</p>
4030     */
4031    public static final int URI_ALLOW_UNSAFE = 1<<2;
4032
4033    // ---------------------------------------------------------------------
4034
4035    private String mAction;
4036    private Uri mData;
4037    private String mType;
4038    private String mPackage;
4039    private ComponentName mComponent;
4040    private int mFlags;
4041    private ArraySet<String> mCategories;
4042    private Bundle mExtras;
4043    private Rect mSourceBounds;
4044    private Intent mSelector;
4045    private ClipData mClipData;
4046    private int mContentUserHint = UserHandle.USER_CURRENT;
4047
4048    // ---------------------------------------------------------------------
4049
4050    /**
4051     * Create an empty intent.
4052     */
4053    public Intent() {
4054    }
4055
4056    /**
4057     * Copy constructor.
4058     */
4059    public Intent(Intent o) {
4060        this.mAction = o.mAction;
4061        this.mData = o.mData;
4062        this.mType = o.mType;
4063        this.mPackage = o.mPackage;
4064        this.mComponent = o.mComponent;
4065        this.mFlags = o.mFlags;
4066        this.mContentUserHint = o.mContentUserHint;
4067        if (o.mCategories != null) {
4068            this.mCategories = new ArraySet<String>(o.mCategories);
4069        }
4070        if (o.mExtras != null) {
4071            this.mExtras = new Bundle(o.mExtras);
4072        }
4073        if (o.mSourceBounds != null) {
4074            this.mSourceBounds = new Rect(o.mSourceBounds);
4075        }
4076        if (o.mSelector != null) {
4077            this.mSelector = new Intent(o.mSelector);
4078        }
4079        if (o.mClipData != null) {
4080            this.mClipData = new ClipData(o.mClipData);
4081        }
4082    }
4083
4084    @Override
4085    public Object clone() {
4086        return new Intent(this);
4087    }
4088
4089    private Intent(Intent o, boolean all) {
4090        this.mAction = o.mAction;
4091        this.mData = o.mData;
4092        this.mType = o.mType;
4093        this.mPackage = o.mPackage;
4094        this.mComponent = o.mComponent;
4095        if (o.mCategories != null) {
4096            this.mCategories = new ArraySet<String>(o.mCategories);
4097        }
4098    }
4099
4100    /**
4101     * Make a clone of only the parts of the Intent that are relevant for
4102     * filter matching: the action, data, type, component, and categories.
4103     */
4104    public Intent cloneFilter() {
4105        return new Intent(this, false);
4106    }
4107
4108    /**
4109     * Create an intent with a given action.  All other fields (data, type,
4110     * class) are null.  Note that the action <em>must</em> be in a
4111     * namespace because Intents are used globally in the system -- for
4112     * example the system VIEW action is android.intent.action.VIEW; an
4113     * application's custom action would be something like
4114     * com.google.app.myapp.CUSTOM_ACTION.
4115     *
4116     * @param action The Intent action, such as ACTION_VIEW.
4117     */
4118    public Intent(String action) {
4119        setAction(action);
4120    }
4121
4122    /**
4123     * Create an intent with a given action and for a given data url.  Note
4124     * that the action <em>must</em> be in a namespace because Intents are
4125     * used globally in the system -- for example the system VIEW action is
4126     * android.intent.action.VIEW; an application's custom action would be
4127     * something like com.google.app.myapp.CUSTOM_ACTION.
4128     *
4129     * <p><em>Note: scheme and host name matching in the Android framework is
4130     * case-sensitive, unlike the formal RFC.  As a result,
4131     * you should always ensure that you write your Uri with these elements
4132     * using lower case letters, and normalize any Uris you receive from
4133     * outside of Android to ensure the scheme and host is lower case.</em></p>
4134     *
4135     * @param action The Intent action, such as ACTION_VIEW.
4136     * @param uri The Intent data URI.
4137     */
4138    public Intent(String action, Uri uri) {
4139        setAction(action);
4140        mData = uri;
4141    }
4142
4143    /**
4144     * Create an intent for a specific component.  All other fields (action, data,
4145     * type, class) are null, though they can be modified later with explicit
4146     * calls.  This provides a convenient way to create an intent that is
4147     * intended to execute a hard-coded class name, rather than relying on the
4148     * system to find an appropriate class for you; see {@link #setComponent}
4149     * for more information on the repercussions of this.
4150     *
4151     * @param packageContext A Context of the application package implementing
4152     * this class.
4153     * @param cls The component class that is to be used for the intent.
4154     *
4155     * @see #setClass
4156     * @see #setComponent
4157     * @see #Intent(String, android.net.Uri , Context, Class)
4158     */
4159    public Intent(Context packageContext, Class<?> cls) {
4160        mComponent = new ComponentName(packageContext, cls);
4161    }
4162
4163    /**
4164     * Create an intent for a specific component with a specified action and data.
4165     * This is equivalent to using {@link #Intent(String, android.net.Uri)} to
4166     * construct the Intent and then calling {@link #setClass} to set its
4167     * class.
4168     *
4169     * <p><em>Note: scheme and host name matching in the Android framework is
4170     * case-sensitive, unlike the formal RFC.  As a result,
4171     * you should always ensure that you write your Uri with these elements
4172     * using lower case letters, and normalize any Uris you receive from
4173     * outside of Android to ensure the scheme and host is lower case.</em></p>
4174     *
4175     * @param action The Intent action, such as ACTION_VIEW.
4176     * @param uri The Intent data URI.
4177     * @param packageContext A Context of the application package implementing
4178     * this class.
4179     * @param cls The component class that is to be used for the intent.
4180     *
4181     * @see #Intent(String, android.net.Uri)
4182     * @see #Intent(Context, Class)
4183     * @see #setClass
4184     * @see #setComponent
4185     */
4186    public Intent(String action, Uri uri,
4187            Context packageContext, Class<?> cls) {
4188        setAction(action);
4189        mData = uri;
4190        mComponent = new ComponentName(packageContext, cls);
4191    }
4192
4193    /**
4194     * Create an intent to launch the main (root) activity of a task.  This
4195     * is the Intent that is started when the application's is launched from
4196     * Home.  For anything else that wants to launch an application in the
4197     * same way, it is important that they use an Intent structured the same
4198     * way, and can use this function to ensure this is the case.
4199     *
4200     * <p>The returned Intent has the given Activity component as its explicit
4201     * component, {@link #ACTION_MAIN} as its action, and includes the
4202     * category {@link #CATEGORY_LAUNCHER}.  This does <em>not</em> have
4203     * {@link #FLAG_ACTIVITY_NEW_TASK} set, though typically you will want
4204     * to do that through {@link #addFlags(int)} on the returned Intent.
4205     *
4206     * @param mainActivity The main activity component that this Intent will
4207     * launch.
4208     * @return Returns a newly created Intent that can be used to launch the
4209     * activity as a main application entry.
4210     *
4211     * @see #setClass
4212     * @see #setComponent
4213     */
4214    public static Intent makeMainActivity(ComponentName mainActivity) {
4215        Intent intent = new Intent(ACTION_MAIN);
4216        intent.setComponent(mainActivity);
4217        intent.addCategory(CATEGORY_LAUNCHER);
4218        return intent;
4219    }
4220
4221    /**
4222     * Make an Intent for the main activity of an application, without
4223     * specifying a specific activity to run but giving a selector to find
4224     * the activity.  This results in a final Intent that is structured
4225     * the same as when the application is launched from
4226     * Home.  For anything else that wants to launch an application in the
4227     * same way, it is important that they use an Intent structured the same
4228     * way, and can use this function to ensure this is the case.
4229     *
4230     * <p>The returned Intent has {@link #ACTION_MAIN} as its action, and includes the
4231     * category {@link #CATEGORY_LAUNCHER}.  This does <em>not</em> have
4232     * {@link #FLAG_ACTIVITY_NEW_TASK} set, though typically you will want
4233     * to do that through {@link #addFlags(int)} on the returned Intent.
4234     *
4235     * @param selectorAction The action name of the Intent's selector.
4236     * @param selectorCategory The name of a category to add to the Intent's
4237     * selector.
4238     * @return Returns a newly created Intent that can be used to launch the
4239     * activity as a main application entry.
4240     *
4241     * @see #setSelector(Intent)
4242     */
4243    public static Intent makeMainSelectorActivity(String selectorAction,
4244            String selectorCategory) {
4245        Intent intent = new Intent(ACTION_MAIN);
4246        intent.addCategory(CATEGORY_LAUNCHER);
4247        Intent selector = new Intent();
4248        selector.setAction(selectorAction);
4249        selector.addCategory(selectorCategory);
4250        intent.setSelector(selector);
4251        return intent;
4252    }
4253
4254    /**
4255     * Make an Intent that can be used to re-launch an application's task
4256     * in its base state.  This is like {@link #makeMainActivity(ComponentName)},
4257     * but also sets the flags {@link #FLAG_ACTIVITY_NEW_TASK} and
4258     * {@link #FLAG_ACTIVITY_CLEAR_TASK}.
4259     *
4260     * @param mainActivity The activity component that is the root of the
4261     * task; this is the activity that has been published in the application's
4262     * manifest as the main launcher icon.
4263     *
4264     * @return Returns a newly created Intent that can be used to relaunch the
4265     * activity's task in its root state.
4266     */
4267    public static Intent makeRestartActivityTask(ComponentName mainActivity) {
4268        Intent intent = makeMainActivity(mainActivity);
4269        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
4270                | Intent.FLAG_ACTIVITY_CLEAR_TASK);
4271        return intent;
4272    }
4273
4274    /**
4275     * Call {@link #parseUri} with 0 flags.
4276     * @deprecated Use {@link #parseUri} instead.
4277     */
4278    @Deprecated
4279    public static Intent getIntent(String uri) throws URISyntaxException {
4280        return parseUri(uri, 0);
4281    }
4282
4283    /**
4284     * Create an intent from a URI.  This URI may encode the action,
4285     * category, and other intent fields, if it was returned by
4286     * {@link #toUri}.  If the Intent was not generate by toUri(), its data
4287     * will be the entire URI and its action will be ACTION_VIEW.
4288     *
4289     * <p>The URI given here must not be relative -- that is, it must include
4290     * the scheme and full path.
4291     *
4292     * @param uri The URI to turn into an Intent.
4293     * @param flags Additional processing flags.  Either 0,
4294     * {@link #URI_INTENT_SCHEME}, or {@link #URI_ANDROID_APP_SCHEME}.
4295     *
4296     * @return Intent The newly created Intent object.
4297     *
4298     * @throws URISyntaxException Throws URISyntaxError if the basic URI syntax
4299     * it bad (as parsed by the Uri class) or the Intent data within the
4300     * URI is invalid.
4301     *
4302     * @see #toUri
4303     */
4304    public static Intent parseUri(String uri, int flags) throws URISyntaxException {
4305        int i = 0;
4306        try {
4307            final boolean androidApp = uri.startsWith("android-app:");
4308
4309            // Validate intent scheme if requested.
4310            if ((flags&(URI_INTENT_SCHEME|URI_ANDROID_APP_SCHEME)) != 0) {
4311                if (!uri.startsWith("intent:") && !androidApp) {
4312                    Intent intent = new Intent(ACTION_VIEW);
4313                    try {
4314                        intent.setData(Uri.parse(uri));
4315                    } catch (IllegalArgumentException e) {
4316                        throw new URISyntaxException(uri, e.getMessage());
4317                    }
4318                    return intent;
4319                }
4320            }
4321
4322            i = uri.lastIndexOf("#");
4323            // simple case
4324            if (i == -1) {
4325                if (!androidApp) {
4326                    return new Intent(ACTION_VIEW, Uri.parse(uri));
4327                }
4328
4329            // old format Intent URI
4330            } else if (!uri.startsWith("#Intent;", i)) {
4331                if (!androidApp) {
4332                    return getIntentOld(uri, flags);
4333                } else {
4334                    i = -1;
4335                }
4336            }
4337
4338            // new format
4339            Intent intent = new Intent(ACTION_VIEW);
4340            Intent baseIntent = intent;
4341            boolean explicitAction = false;
4342            boolean inSelector = false;
4343
4344            // fetch data part, if present
4345            String scheme = null;
4346            String data;
4347            if (i >= 0) {
4348                data = uri.substring(0, i);
4349                i += 8; // length of "#Intent;"
4350            } else {
4351                data = uri;
4352            }
4353
4354            // loop over contents of Intent, all name=value;
4355            while (i >= 0 && !uri.startsWith("end", i)) {
4356                int eq = uri.indexOf('=', i);
4357                if (eq < 0) eq = i-1;
4358                int semi = uri.indexOf(';', i);
4359                String value = eq < semi ? Uri.decode(uri.substring(eq + 1, semi)) : "";
4360
4361                // action
4362                if (uri.startsWith("action=", i)) {
4363                    intent.setAction(value);
4364                    if (!inSelector) {
4365                        explicitAction = true;
4366                    }
4367                }
4368
4369                // categories
4370                else if (uri.startsWith("category=", i)) {
4371                    intent.addCategory(value);
4372                }
4373
4374                // type
4375                else if (uri.startsWith("type=", i)) {
4376                    intent.mType = value;
4377                }
4378
4379                // launch flags
4380                else if (uri.startsWith("launchFlags=", i)) {
4381                    intent.mFlags = Integer.decode(value).intValue();
4382                    if ((flags& URI_ALLOW_UNSAFE) == 0) {
4383                        intent.mFlags &= ~IMMUTABLE_FLAGS;
4384                    }
4385                }
4386
4387                // package
4388                else if (uri.startsWith("package=", i)) {
4389                    intent.mPackage = value;
4390                }
4391
4392                // component
4393                else if (uri.startsWith("component=", i)) {
4394                    intent.mComponent = ComponentName.unflattenFromString(value);
4395                }
4396
4397                // scheme
4398                else if (uri.startsWith("scheme=", i)) {
4399                    if (inSelector) {
4400                        intent.mData = Uri.parse(value + ":");
4401                    } else {
4402                        scheme = value;
4403                    }
4404                }
4405
4406                // source bounds
4407                else if (uri.startsWith("sourceBounds=", i)) {
4408                    intent.mSourceBounds = Rect.unflattenFromString(value);
4409                }
4410
4411                // selector
4412                else if (semi == (i+3) && uri.startsWith("SEL", i)) {
4413                    intent = new Intent();
4414                    inSelector = true;
4415                }
4416
4417                // extra
4418                else {
4419                    String key = Uri.decode(uri.substring(i + 2, eq));
4420                    // create Bundle if it doesn't already exist
4421                    if (intent.mExtras == null) intent.mExtras = new Bundle();
4422                    Bundle b = intent.mExtras;
4423                    // add EXTRA
4424                    if      (uri.startsWith("S.", i)) b.putString(key, value);
4425                    else if (uri.startsWith("B.", i)) b.putBoolean(key, Boolean.parseBoolean(value));
4426                    else if (uri.startsWith("b.", i)) b.putByte(key, Byte.parseByte(value));
4427                    else if (uri.startsWith("c.", i)) b.putChar(key, value.charAt(0));
4428                    else if (uri.startsWith("d.", i)) b.putDouble(key, Double.parseDouble(value));
4429                    else if (uri.startsWith("f.", i)) b.putFloat(key, Float.parseFloat(value));
4430                    else if (uri.startsWith("i.", i)) b.putInt(key, Integer.parseInt(value));
4431                    else if (uri.startsWith("l.", i)) b.putLong(key, Long.parseLong(value));
4432                    else if (uri.startsWith("s.", i)) b.putShort(key, Short.parseShort(value));
4433                    else throw new URISyntaxException(uri, "unknown EXTRA type", i);
4434                }
4435
4436                // move to the next item
4437                i = semi + 1;
4438            }
4439
4440            if (inSelector) {
4441                // The Intent had a selector; fix it up.
4442                if (baseIntent.mPackage == null) {
4443                    baseIntent.setSelector(intent);
4444                }
4445                intent = baseIntent;
4446            }
4447
4448            if (data != null) {
4449                if (data.startsWith("intent:")) {
4450                    data = data.substring(7);
4451                    if (scheme != null) {
4452                        data = scheme + ':' + data;
4453                    }
4454                } else if (data.startsWith("android-app:")) {
4455                    if (data.charAt(12) == '/' && data.charAt(13) == '/') {
4456                        // Correctly formed android-app, first part is package name.
4457                        int end = data.indexOf('/', 14);
4458                        if (end < 0) {
4459                            // All we have is a package name.
4460                            intent.mPackage = data.substring(14);
4461                            if (!explicitAction) {
4462                                intent.setAction(ACTION_MAIN);
4463                            }
4464                            data = "";
4465                        } else {
4466                            // Target the Intent at the given package name always.
4467                            String authority = null;
4468                            intent.mPackage = data.substring(14, end);
4469                            int newEnd;
4470                            if ((end+1) < data.length()) {
4471                                if ((newEnd=data.indexOf('/', end+1)) >= 0) {
4472                                    // Found a scheme, remember it.
4473                                    scheme = data.substring(end+1, newEnd);
4474                                    end = newEnd;
4475                                    if (end < data.length() && (newEnd=data.indexOf('/', end+1)) >= 0) {
4476                                        // Found a authority, remember it.
4477                                        authority = data.substring(end+1, newEnd);
4478                                        end = newEnd;
4479                                    }
4480                                } else {
4481                                    // All we have is a scheme.
4482                                    scheme = data.substring(end+1);
4483                                }
4484                            }
4485                            if (scheme == null) {
4486                                // If there was no scheme, then this just targets the package.
4487                                if (!explicitAction) {
4488                                    intent.setAction(ACTION_MAIN);
4489                                }
4490                                data = "";
4491                            } else if (authority == null) {
4492                                data = scheme + ":";
4493                            } else {
4494                                data = scheme + "://" + authority + data.substring(end);
4495                            }
4496                        }
4497                    } else {
4498                        data = "";
4499                    }
4500                }
4501
4502                if (data.length() > 0) {
4503                    try {
4504                        intent.mData = Uri.parse(data);
4505                    } catch (IllegalArgumentException e) {
4506                        throw new URISyntaxException(uri, e.getMessage());
4507                    }
4508                }
4509            }
4510
4511            return intent;
4512
4513        } catch (IndexOutOfBoundsException e) {
4514            throw new URISyntaxException(uri, "illegal Intent URI format", i);
4515        }
4516    }
4517
4518    public static Intent getIntentOld(String uri) throws URISyntaxException {
4519        return getIntentOld(uri, 0);
4520    }
4521
4522    private static Intent getIntentOld(String uri, int flags) throws URISyntaxException {
4523        Intent intent;
4524
4525        int i = uri.lastIndexOf('#');
4526        if (i >= 0) {
4527            String action = null;
4528            final int intentFragmentStart = i;
4529            boolean isIntentFragment = false;
4530
4531            i++;
4532
4533            if (uri.regionMatches(i, "action(", 0, 7)) {
4534                isIntentFragment = true;
4535                i += 7;
4536                int j = uri.indexOf(')', i);
4537                action = uri.substring(i, j);
4538                i = j + 1;
4539            }
4540
4541            intent = new Intent(action);
4542
4543            if (uri.regionMatches(i, "categories(", 0, 11)) {
4544                isIntentFragment = true;
4545                i += 11;
4546                int j = uri.indexOf(')', i);
4547                while (i < j) {
4548                    int sep = uri.indexOf('!', i);
4549                    if (sep < 0 || sep > j) sep = j;
4550                    if (i < sep) {
4551                        intent.addCategory(uri.substring(i, sep));
4552                    }
4553                    i = sep + 1;
4554                }
4555                i = j + 1;
4556            }
4557
4558            if (uri.regionMatches(i, "type(", 0, 5)) {
4559                isIntentFragment = true;
4560                i += 5;
4561                int j = uri.indexOf(')', i);
4562                intent.mType = uri.substring(i, j);
4563                i = j + 1;
4564            }
4565
4566            if (uri.regionMatches(i, "launchFlags(", 0, 12)) {
4567                isIntentFragment = true;
4568                i += 12;
4569                int j = uri.indexOf(')', i);
4570                intent.mFlags = Integer.decode(uri.substring(i, j)).intValue();
4571                if ((flags& URI_ALLOW_UNSAFE) == 0) {
4572                    intent.mFlags &= ~IMMUTABLE_FLAGS;
4573                }
4574                i = j + 1;
4575            }
4576
4577            if (uri.regionMatches(i, "component(", 0, 10)) {
4578                isIntentFragment = true;
4579                i += 10;
4580                int j = uri.indexOf(')', i);
4581                int sep = uri.indexOf('!', i);
4582                if (sep >= 0 && sep < j) {
4583                    String pkg = uri.substring(i, sep);
4584                    String cls = uri.substring(sep + 1, j);
4585                    intent.mComponent = new ComponentName(pkg, cls);
4586                }
4587                i = j + 1;
4588            }
4589
4590            if (uri.regionMatches(i, "extras(", 0, 7)) {
4591                isIntentFragment = true;
4592                i += 7;
4593
4594                final int closeParen = uri.indexOf(')', i);
4595                if (closeParen == -1) throw new URISyntaxException(uri,
4596                        "EXTRA missing trailing ')'", i);
4597
4598                while (i < closeParen) {
4599                    // fetch the key value
4600                    int j = uri.indexOf('=', i);
4601                    if (j <= i + 1 || i >= closeParen) {
4602                        throw new URISyntaxException(uri, "EXTRA missing '='", i);
4603                    }
4604                    char type = uri.charAt(i);
4605                    i++;
4606                    String key = uri.substring(i, j);
4607                    i = j + 1;
4608
4609                    // get type-value
4610                    j = uri.indexOf('!', i);
4611                    if (j == -1 || j >= closeParen) j = closeParen;
4612                    if (i >= j) throw new URISyntaxException(uri, "EXTRA missing '!'", i);
4613                    String value = uri.substring(i, j);
4614                    i = j;
4615
4616                    // create Bundle if it doesn't already exist
4617                    if (intent.mExtras == null) intent.mExtras = new Bundle();
4618
4619                    // add item to bundle
4620                    try {
4621                        switch (type) {
4622                            case 'S':
4623                                intent.mExtras.putString(key, Uri.decode(value));
4624                                break;
4625                            case 'B':
4626                                intent.mExtras.putBoolean(key, Boolean.parseBoolean(value));
4627                                break;
4628                            case 'b':
4629                                intent.mExtras.putByte(key, Byte.parseByte(value));
4630                                break;
4631                            case 'c':
4632                                intent.mExtras.putChar(key, Uri.decode(value).charAt(0));
4633                                break;
4634                            case 'd':
4635                                intent.mExtras.putDouble(key, Double.parseDouble(value));
4636                                break;
4637                            case 'f':
4638                                intent.mExtras.putFloat(key, Float.parseFloat(value));
4639                                break;
4640                            case 'i':
4641                                intent.mExtras.putInt(key, Integer.parseInt(value));
4642                                break;
4643                            case 'l':
4644                                intent.mExtras.putLong(key, Long.parseLong(value));
4645                                break;
4646                            case 's':
4647                                intent.mExtras.putShort(key, Short.parseShort(value));
4648                                break;
4649                            default:
4650                                throw new URISyntaxException(uri, "EXTRA has unknown type", i);
4651                        }
4652                    } catch (NumberFormatException e) {
4653                        throw new URISyntaxException(uri, "EXTRA value can't be parsed", i);
4654                    }
4655
4656                    char ch = uri.charAt(i);
4657                    if (ch == ')') break;
4658                    if (ch != '!') throw new URISyntaxException(uri, "EXTRA missing '!'", i);
4659                    i++;
4660                }
4661            }
4662
4663            if (isIntentFragment) {
4664                intent.mData = Uri.parse(uri.substring(0, intentFragmentStart));
4665            } else {
4666                intent.mData = Uri.parse(uri);
4667            }
4668
4669            if (intent.mAction == null) {
4670                // By default, if no action is specified, then use VIEW.
4671                intent.mAction = ACTION_VIEW;
4672            }
4673
4674        } else {
4675            intent = new Intent(ACTION_VIEW, Uri.parse(uri));
4676        }
4677
4678        return intent;
4679    }
4680
4681    /**
4682     * Retrieve the general action to be performed, such as
4683     * {@link #ACTION_VIEW}.  The action describes the general way the rest of
4684     * the information in the intent should be interpreted -- most importantly,
4685     * what to do with the data returned by {@link #getData}.
4686     *
4687     * @return The action of this intent or null if none is specified.
4688     *
4689     * @see #setAction
4690     */
4691    public String getAction() {
4692        return mAction;
4693    }
4694
4695    /**
4696     * Retrieve data this intent is operating on.  This URI specifies the name
4697     * of the data; often it uses the content: scheme, specifying data in a
4698     * content provider.  Other schemes may be handled by specific activities,
4699     * such as http: by the web browser.
4700     *
4701     * @return The URI of the data this intent is targeting or null.
4702     *
4703     * @see #getScheme
4704     * @see #setData
4705     */
4706    public Uri getData() {
4707        return mData;
4708    }
4709
4710    /**
4711     * The same as {@link #getData()}, but returns the URI as an encoded
4712     * String.
4713     */
4714    public String getDataString() {
4715        return mData != null ? mData.toString() : null;
4716    }
4717
4718    /**
4719     * Return the scheme portion of the intent's data.  If the data is null or
4720     * does not include a scheme, null is returned.  Otherwise, the scheme
4721     * prefix without the final ':' is returned, i.e. "http".
4722     *
4723     * <p>This is the same as calling getData().getScheme() (and checking for
4724     * null data).
4725     *
4726     * @return The scheme of this intent.
4727     *
4728     * @see #getData
4729     */
4730    public String getScheme() {
4731        return mData != null ? mData.getScheme() : null;
4732    }
4733
4734    /**
4735     * Retrieve any explicit MIME type included in the intent.  This is usually
4736     * null, as the type is determined by the intent data.
4737     *
4738     * @return If a type was manually set, it is returned; else null is
4739     *         returned.
4740     *
4741     * @see #resolveType(ContentResolver)
4742     * @see #setType
4743     */
4744    public String getType() {
4745        return mType;
4746    }
4747
4748    /**
4749     * Return the MIME data type of this intent.  If the type field is
4750     * explicitly set, that is simply returned.  Otherwise, if the data is set,
4751     * the type of that data is returned.  If neither fields are set, a null is
4752     * returned.
4753     *
4754     * @return The MIME type of this intent.
4755     *
4756     * @see #getType
4757     * @see #resolveType(ContentResolver)
4758     */
4759    public String resolveType(Context context) {
4760        return resolveType(context.getContentResolver());
4761    }
4762
4763    /**
4764     * Return the MIME data type of this intent.  If the type field is
4765     * explicitly set, that is simply returned.  Otherwise, if the data is set,
4766     * the type of that data is returned.  If neither fields are set, a null is
4767     * returned.
4768     *
4769     * @param resolver A ContentResolver that can be used to determine the MIME
4770     *                 type of the intent's data.
4771     *
4772     * @return The MIME type of this intent.
4773     *
4774     * @see #getType
4775     * @see #resolveType(Context)
4776     */
4777    public String resolveType(ContentResolver resolver) {
4778        if (mType != null) {
4779            return mType;
4780        }
4781        if (mData != null) {
4782            if ("content".equals(mData.getScheme())) {
4783                return resolver.getType(mData);
4784            }
4785        }
4786        return null;
4787    }
4788
4789    /**
4790     * Return the MIME data type of this intent, only if it will be needed for
4791     * intent resolution.  This is not generally useful for application code;
4792     * it is used by the frameworks for communicating with back-end system
4793     * services.
4794     *
4795     * @param resolver A ContentResolver that can be used to determine the MIME
4796     *                 type of the intent's data.
4797     *
4798     * @return The MIME type of this intent, or null if it is unknown or not
4799     *         needed.
4800     */
4801    public String resolveTypeIfNeeded(ContentResolver resolver) {
4802        if (mComponent != null) {
4803            return mType;
4804        }
4805        return resolveType(resolver);
4806    }
4807
4808    /**
4809     * Check if a category exists in the intent.
4810     *
4811     * @param category The category to check.
4812     *
4813     * @return boolean True if the intent contains the category, else false.
4814     *
4815     * @see #getCategories
4816     * @see #addCategory
4817     */
4818    public boolean hasCategory(String category) {
4819        return mCategories != null && mCategories.contains(category);
4820    }
4821
4822    /**
4823     * Return the set of all categories in the intent.  If there are no categories,
4824     * returns NULL.
4825     *
4826     * @return The set of categories you can examine.  Do not modify!
4827     *
4828     * @see #hasCategory
4829     * @see #addCategory
4830     */
4831    public Set<String> getCategories() {
4832        return mCategories;
4833    }
4834
4835    /**
4836     * Return the specific selector associated with this Intent.  If there is
4837     * none, returns null.  See {@link #setSelector} for more information.
4838     *
4839     * @see #setSelector
4840     */
4841    public Intent getSelector() {
4842        return mSelector;
4843    }
4844
4845    /**
4846     * Return the {@link ClipData} associated with this Intent.  If there is
4847     * none, returns null.  See {@link #setClipData} for more information.
4848     *
4849     * @see #setClipData
4850     */
4851    public ClipData getClipData() {
4852        return mClipData;
4853    }
4854
4855    /** @hide */
4856    public int getContentUserHint() {
4857        return mContentUserHint;
4858    }
4859
4860    /**
4861     * Sets the ClassLoader that will be used when unmarshalling
4862     * any Parcelable values from the extras of this Intent.
4863     *
4864     * @param loader a ClassLoader, or null to use the default loader
4865     * at the time of unmarshalling.
4866     */
4867    public void setExtrasClassLoader(ClassLoader loader) {
4868        if (mExtras != null) {
4869            mExtras.setClassLoader(loader);
4870        }
4871    }
4872
4873    /**
4874     * Returns true if an extra value is associated with the given name.
4875     * @param name the extra's name
4876     * @return true if the given extra is present.
4877     */
4878    public boolean hasExtra(String name) {
4879        return mExtras != null && mExtras.containsKey(name);
4880    }
4881
4882    /**
4883     * Returns true if the Intent's extras contain a parcelled file descriptor.
4884     * @return true if the Intent contains a parcelled file descriptor.
4885     */
4886    public boolean hasFileDescriptors() {
4887        return mExtras != null && mExtras.hasFileDescriptors();
4888    }
4889
4890    /** @hide */
4891    public void setAllowFds(boolean allowFds) {
4892        if (mExtras != null) {
4893            mExtras.setAllowFds(allowFds);
4894        }
4895    }
4896
4897    /**
4898     * Retrieve extended data from the intent.
4899     *
4900     * @param name The name of the desired item.
4901     *
4902     * @return the value of an item that previously added with putExtra()
4903     * or null if none was found.
4904     *
4905     * @deprecated
4906     * @hide
4907     */
4908    @Deprecated
4909    public Object getExtra(String name) {
4910        return getExtra(name, null);
4911    }
4912
4913    /**
4914     * Retrieve extended data from the intent.
4915     *
4916     * @param name The name of the desired item.
4917     * @param defaultValue the value to be returned if no value of the desired
4918     * type is stored with the given name.
4919     *
4920     * @return the value of an item that previously added with putExtra()
4921     * or the default value if none was found.
4922     *
4923     * @see #putExtra(String, boolean)
4924     */
4925    public boolean getBooleanExtra(String name, boolean defaultValue) {
4926        return mExtras == null ? defaultValue :
4927            mExtras.getBoolean(name, defaultValue);
4928    }
4929
4930    /**
4931     * Retrieve extended data from the intent.
4932     *
4933     * @param name The name of the desired item.
4934     * @param defaultValue the value to be returned if no value of the desired
4935     * type is stored with the given name.
4936     *
4937     * @return the value of an item that previously added with putExtra()
4938     * or the default value if none was found.
4939     *
4940     * @see #putExtra(String, byte)
4941     */
4942    public byte getByteExtra(String name, byte defaultValue) {
4943        return mExtras == null ? defaultValue :
4944            mExtras.getByte(name, defaultValue);
4945    }
4946
4947    /**
4948     * Retrieve extended data from the intent.
4949     *
4950     * @param name The name of the desired item.
4951     * @param defaultValue the value to be returned if no value of the desired
4952     * type is stored with the given name.
4953     *
4954     * @return the value of an item that previously added with putExtra()
4955     * or the default value if none was found.
4956     *
4957     * @see #putExtra(String, short)
4958     */
4959    public short getShortExtra(String name, short defaultValue) {
4960        return mExtras == null ? defaultValue :
4961            mExtras.getShort(name, defaultValue);
4962    }
4963
4964    /**
4965     * Retrieve extended data from the intent.
4966     *
4967     * @param name The name of the desired item.
4968     * @param defaultValue the value to be returned if no value of the desired
4969     * type is stored with the given name.
4970     *
4971     * @return the value of an item that previously added with putExtra()
4972     * or the default value if none was found.
4973     *
4974     * @see #putExtra(String, char)
4975     */
4976    public char getCharExtra(String name, char defaultValue) {
4977        return mExtras == null ? defaultValue :
4978            mExtras.getChar(name, defaultValue);
4979    }
4980
4981    /**
4982     * Retrieve extended data from the intent.
4983     *
4984     * @param name The name of the desired item.
4985     * @param defaultValue the value to be returned if no value of the desired
4986     * type is stored with the given name.
4987     *
4988     * @return the value of an item that previously added with putExtra()
4989     * or the default value if none was found.
4990     *
4991     * @see #putExtra(String, int)
4992     */
4993    public int getIntExtra(String name, int defaultValue) {
4994        return mExtras == null ? defaultValue :
4995            mExtras.getInt(name, defaultValue);
4996    }
4997
4998    /**
4999     * Retrieve extended data from the intent.
5000     *
5001     * @param name The name of the desired item.
5002     * @param defaultValue the value to be returned if no value of the desired
5003     * type is stored with the given name.
5004     *
5005     * @return the value of an item that previously added with putExtra()
5006     * or the default value if none was found.
5007     *
5008     * @see #putExtra(String, long)
5009     */
5010    public long getLongExtra(String name, long defaultValue) {
5011        return mExtras == null ? defaultValue :
5012            mExtras.getLong(name, defaultValue);
5013    }
5014
5015    /**
5016     * Retrieve extended data from the intent.
5017     *
5018     * @param name The name of the desired item.
5019     * @param defaultValue the value to be returned if no value of the desired
5020     * type is stored with the given name.
5021     *
5022     * @return the value of an item that previously added with putExtra(),
5023     * or the default value if no such item is present
5024     *
5025     * @see #putExtra(String, float)
5026     */
5027    public float getFloatExtra(String name, float defaultValue) {
5028        return mExtras == null ? defaultValue :
5029            mExtras.getFloat(name, defaultValue);
5030    }
5031
5032    /**
5033     * Retrieve extended data from the intent.
5034     *
5035     * @param name The name of the desired item.
5036     * @param defaultValue the value to be returned if no value of the desired
5037     * type is stored with the given name.
5038     *
5039     * @return the value of an item that previously added with putExtra()
5040     * or the default value if none was found.
5041     *
5042     * @see #putExtra(String, double)
5043     */
5044    public double getDoubleExtra(String name, double defaultValue) {
5045        return mExtras == null ? defaultValue :
5046            mExtras.getDouble(name, defaultValue);
5047    }
5048
5049    /**
5050     * Retrieve extended data from the intent.
5051     *
5052     * @param name The name of the desired item.
5053     *
5054     * @return the value of an item that previously added with putExtra()
5055     * or null if no String value was found.
5056     *
5057     * @see #putExtra(String, String)
5058     */
5059    public String getStringExtra(String name) {
5060        return mExtras == null ? null : mExtras.getString(name);
5061    }
5062
5063    /**
5064     * Retrieve extended data from the intent.
5065     *
5066     * @param name The name of the desired item.
5067     *
5068     * @return the value of an item that previously added with putExtra()
5069     * or null if no CharSequence value was found.
5070     *
5071     * @see #putExtra(String, CharSequence)
5072     */
5073    public CharSequence getCharSequenceExtra(String name) {
5074        return mExtras == null ? null : mExtras.getCharSequence(name);
5075    }
5076
5077    /**
5078     * Retrieve extended data from the intent.
5079     *
5080     * @param name The name of the desired item.
5081     *
5082     * @return the value of an item that previously added with putExtra()
5083     * or null if no Parcelable value was found.
5084     *
5085     * @see #putExtra(String, Parcelable)
5086     */
5087    public <T extends Parcelable> T getParcelableExtra(String name) {
5088        return mExtras == null ? null : mExtras.<T>getParcelable(name);
5089    }
5090
5091    /**
5092     * Retrieve extended data from the intent.
5093     *
5094     * @param name The name of the desired item.
5095     *
5096     * @return the value of an item that previously added with putExtra()
5097     * or null if no Parcelable[] value was found.
5098     *
5099     * @see #putExtra(String, Parcelable[])
5100     */
5101    public Parcelable[] getParcelableArrayExtra(String name) {
5102        return mExtras == null ? null : mExtras.getParcelableArray(name);
5103    }
5104
5105    /**
5106     * Retrieve extended data from the intent.
5107     *
5108     * @param name The name of the desired item.
5109     *
5110     * @return the value of an item that previously added with putExtra()
5111     * or null if no ArrayList<Parcelable> value was found.
5112     *
5113     * @see #putParcelableArrayListExtra(String, ArrayList)
5114     */
5115    public <T extends Parcelable> ArrayList<T> getParcelableArrayListExtra(String name) {
5116        return mExtras == null ? null : mExtras.<T>getParcelableArrayList(name);
5117    }
5118
5119    /**
5120     * Retrieve extended data from the intent.
5121     *
5122     * @param name The name of the desired item.
5123     *
5124     * @return the value of an item that previously added with putExtra()
5125     * or null if no Serializable value was found.
5126     *
5127     * @see #putExtra(String, Serializable)
5128     */
5129    public Serializable getSerializableExtra(String name) {
5130        return mExtras == null ? null : mExtras.getSerializable(name);
5131    }
5132
5133    /**
5134     * Retrieve extended data from the intent.
5135     *
5136     * @param name The name of the desired item.
5137     *
5138     * @return the value of an item that previously added with putExtra()
5139     * or null if no ArrayList<Integer> value was found.
5140     *
5141     * @see #putIntegerArrayListExtra(String, ArrayList)
5142     */
5143    public ArrayList<Integer> getIntegerArrayListExtra(String name) {
5144        return mExtras == null ? null : mExtras.getIntegerArrayList(name);
5145    }
5146
5147    /**
5148     * Retrieve extended data from the intent.
5149     *
5150     * @param name The name of the desired item.
5151     *
5152     * @return the value of an item that previously added with putExtra()
5153     * or null if no ArrayList<String> value was found.
5154     *
5155     * @see #putStringArrayListExtra(String, ArrayList)
5156     */
5157    public ArrayList<String> getStringArrayListExtra(String name) {
5158        return mExtras == null ? null : mExtras.getStringArrayList(name);
5159    }
5160
5161    /**
5162     * Retrieve extended data from the intent.
5163     *
5164     * @param name The name of the desired item.
5165     *
5166     * @return the value of an item that previously added with putExtra()
5167     * or null if no ArrayList<CharSequence> value was found.
5168     *
5169     * @see #putCharSequenceArrayListExtra(String, ArrayList)
5170     */
5171    public ArrayList<CharSequence> getCharSequenceArrayListExtra(String name) {
5172        return mExtras == null ? null : mExtras.getCharSequenceArrayList(name);
5173    }
5174
5175    /**
5176     * Retrieve extended data from the intent.
5177     *
5178     * @param name The name of the desired item.
5179     *
5180     * @return the value of an item that previously added with putExtra()
5181     * or null if no boolean array value was found.
5182     *
5183     * @see #putExtra(String, boolean[])
5184     */
5185    public boolean[] getBooleanArrayExtra(String name) {
5186        return mExtras == null ? null : mExtras.getBooleanArray(name);
5187    }
5188
5189    /**
5190     * Retrieve extended data from the intent.
5191     *
5192     * @param name The name of the desired item.
5193     *
5194     * @return the value of an item that previously added with putExtra()
5195     * or null if no byte array value was found.
5196     *
5197     * @see #putExtra(String, byte[])
5198     */
5199    public byte[] getByteArrayExtra(String name) {
5200        return mExtras == null ? null : mExtras.getByteArray(name);
5201    }
5202
5203    /**
5204     * Retrieve extended data from the intent.
5205     *
5206     * @param name The name of the desired item.
5207     *
5208     * @return the value of an item that previously added with putExtra()
5209     * or null if no short array value was found.
5210     *
5211     * @see #putExtra(String, short[])
5212     */
5213    public short[] getShortArrayExtra(String name) {
5214        return mExtras == null ? null : mExtras.getShortArray(name);
5215    }
5216
5217    /**
5218     * Retrieve extended data from the intent.
5219     *
5220     * @param name The name of the desired item.
5221     *
5222     * @return the value of an item that previously added with putExtra()
5223     * or null if no char array value was found.
5224     *
5225     * @see #putExtra(String, char[])
5226     */
5227    public char[] getCharArrayExtra(String name) {
5228        return mExtras == null ? null : mExtras.getCharArray(name);
5229    }
5230
5231    /**
5232     * Retrieve extended data from the intent.
5233     *
5234     * @param name The name of the desired item.
5235     *
5236     * @return the value of an item that previously added with putExtra()
5237     * or null if no int array value was found.
5238     *
5239     * @see #putExtra(String, int[])
5240     */
5241    public int[] getIntArrayExtra(String name) {
5242        return mExtras == null ? null : mExtras.getIntArray(name);
5243    }
5244
5245    /**
5246     * Retrieve extended data from the intent.
5247     *
5248     * @param name The name of the desired item.
5249     *
5250     * @return the value of an item that previously added with putExtra()
5251     * or null if no long array value was found.
5252     *
5253     * @see #putExtra(String, long[])
5254     */
5255    public long[] getLongArrayExtra(String name) {
5256        return mExtras == null ? null : mExtras.getLongArray(name);
5257    }
5258
5259    /**
5260     * Retrieve extended data from the intent.
5261     *
5262     * @param name The name of the desired item.
5263     *
5264     * @return the value of an item that previously added with putExtra()
5265     * or null if no float array value was found.
5266     *
5267     * @see #putExtra(String, float[])
5268     */
5269    public float[] getFloatArrayExtra(String name) {
5270        return mExtras == null ? null : mExtras.getFloatArray(name);
5271    }
5272
5273    /**
5274     * Retrieve extended data from the intent.
5275     *
5276     * @param name The name of the desired item.
5277     *
5278     * @return the value of an item that previously added with putExtra()
5279     * or null if no double array value was found.
5280     *
5281     * @see #putExtra(String, double[])
5282     */
5283    public double[] getDoubleArrayExtra(String name) {
5284        return mExtras == null ? null : mExtras.getDoubleArray(name);
5285    }
5286
5287    /**
5288     * Retrieve extended data from the intent.
5289     *
5290     * @param name The name of the desired item.
5291     *
5292     * @return the value of an item that previously added with putExtra()
5293     * or null if no String array value was found.
5294     *
5295     * @see #putExtra(String, String[])
5296     */
5297    public String[] getStringArrayExtra(String name) {
5298        return mExtras == null ? null : mExtras.getStringArray(name);
5299    }
5300
5301    /**
5302     * Retrieve extended data from the intent.
5303     *
5304     * @param name The name of the desired item.
5305     *
5306     * @return the value of an item that previously added with putExtra()
5307     * or null if no CharSequence array value was found.
5308     *
5309     * @see #putExtra(String, CharSequence[])
5310     */
5311    public CharSequence[] getCharSequenceArrayExtra(String name) {
5312        return mExtras == null ? null : mExtras.getCharSequenceArray(name);
5313    }
5314
5315    /**
5316     * Retrieve extended data from the intent.
5317     *
5318     * @param name The name of the desired item.
5319     *
5320     * @return the value of an item that previously added with putExtra()
5321     * or null if no Bundle value was found.
5322     *
5323     * @see #putExtra(String, Bundle)
5324     */
5325    public Bundle getBundleExtra(String name) {
5326        return mExtras == null ? null : mExtras.getBundle(name);
5327    }
5328
5329    /**
5330     * Retrieve extended data from the intent.
5331     *
5332     * @param name The name of the desired item.
5333     *
5334     * @return the value of an item that previously added with putExtra()
5335     * or null if no IBinder value was found.
5336     *
5337     * @see #putExtra(String, IBinder)
5338     *
5339     * @deprecated
5340     * @hide
5341     */
5342    @Deprecated
5343    public IBinder getIBinderExtra(String name) {
5344        return mExtras == null ? null : mExtras.getIBinder(name);
5345    }
5346
5347    /**
5348     * Retrieve extended data from the intent.
5349     *
5350     * @param name The name of the desired item.
5351     * @param defaultValue The default value to return in case no item is
5352     * associated with the key 'name'
5353     *
5354     * @return the value of an item that previously added with putExtra()
5355     * or defaultValue if none was found.
5356     *
5357     * @see #putExtra
5358     *
5359     * @deprecated
5360     * @hide
5361     */
5362    @Deprecated
5363    public Object getExtra(String name, Object defaultValue) {
5364        Object result = defaultValue;
5365        if (mExtras != null) {
5366            Object result2 = mExtras.get(name);
5367            if (result2 != null) {
5368                result = result2;
5369            }
5370        }
5371
5372        return result;
5373    }
5374
5375    /**
5376     * Retrieves a map of extended data from the intent.
5377     *
5378     * @return the map of all extras previously added with putExtra(),
5379     * or null if none have been added.
5380     */
5381    public Bundle getExtras() {
5382        return (mExtras != null)
5383                ? new Bundle(mExtras)
5384                : null;
5385    }
5386
5387    /**
5388     * Retrieve any special flags associated with this intent.  You will
5389     * normally just set them with {@link #setFlags} and let the system
5390     * take the appropriate action with them.
5391     *
5392     * @return int The currently set flags.
5393     *
5394     * @see #setFlags
5395     */
5396    public int getFlags() {
5397        return mFlags;
5398    }
5399
5400    /** @hide */
5401    public boolean isExcludingStopped() {
5402        return (mFlags&(FLAG_EXCLUDE_STOPPED_PACKAGES|FLAG_INCLUDE_STOPPED_PACKAGES))
5403                == FLAG_EXCLUDE_STOPPED_PACKAGES;
5404    }
5405
5406    /**
5407     * Retrieve the application package name this Intent is limited to.  When
5408     * resolving an Intent, if non-null this limits the resolution to only
5409     * components in the given application package.
5410     *
5411     * @return The name of the application package for the Intent.
5412     *
5413     * @see #resolveActivity
5414     * @see #setPackage
5415     */
5416    public String getPackage() {
5417        return mPackage;
5418    }
5419
5420    /**
5421     * Retrieve the concrete component associated with the intent.  When receiving
5422     * an intent, this is the component that was found to best handle it (that is,
5423     * yourself) and will always be non-null; in all other cases it will be
5424     * null unless explicitly set.
5425     *
5426     * @return The name of the application component to handle the intent.
5427     *
5428     * @see #resolveActivity
5429     * @see #setComponent
5430     */
5431    public ComponentName getComponent() {
5432        return mComponent;
5433    }
5434
5435    /**
5436     * Get the bounds of the sender of this intent, in screen coordinates.  This can be
5437     * used as a hint to the receiver for animations and the like.  Null means that there
5438     * is no source bounds.
5439     */
5440    public Rect getSourceBounds() {
5441        return mSourceBounds;
5442    }
5443
5444    /**
5445     * Return the Activity component that should be used to handle this intent.
5446     * The appropriate component is determined based on the information in the
5447     * intent, evaluated as follows:
5448     *
5449     * <p>If {@link #getComponent} returns an explicit class, that is returned
5450     * without any further consideration.
5451     *
5452     * <p>The activity must handle the {@link Intent#CATEGORY_DEFAULT} Intent
5453     * category to be considered.
5454     *
5455     * <p>If {@link #getAction} is non-NULL, the activity must handle this
5456     * action.
5457     *
5458     * <p>If {@link #resolveType} returns non-NULL, the activity must handle
5459     * this type.
5460     *
5461     * <p>If {@link #addCategory} has added any categories, the activity must
5462     * handle ALL of the categories specified.
5463     *
5464     * <p>If {@link #getPackage} is non-NULL, only activity components in
5465     * that application package will be considered.
5466     *
5467     * <p>If there are no activities that satisfy all of these conditions, a
5468     * null string is returned.
5469     *
5470     * <p>If multiple activities are found to satisfy the intent, the one with
5471     * the highest priority will be used.  If there are multiple activities
5472     * with the same priority, the system will either pick the best activity
5473     * based on user preference, or resolve to a system class that will allow
5474     * the user to pick an activity and forward from there.
5475     *
5476     * <p>This method is implemented simply by calling
5477     * {@link PackageManager#resolveActivity} with the "defaultOnly" parameter
5478     * true.</p>
5479     * <p> This API is called for you as part of starting an activity from an
5480     * intent.  You do not normally need to call it yourself.</p>
5481     *
5482     * @param pm The package manager with which to resolve the Intent.
5483     *
5484     * @return Name of the component implementing an activity that can
5485     *         display the intent.
5486     *
5487     * @see #setComponent
5488     * @see #getComponent
5489     * @see #resolveActivityInfo
5490     */
5491    public ComponentName resolveActivity(PackageManager pm) {
5492        if (mComponent != null) {
5493            return mComponent;
5494        }
5495
5496        ResolveInfo info = pm.resolveActivity(
5497            this, PackageManager.MATCH_DEFAULT_ONLY);
5498        if (info != null) {
5499            return new ComponentName(
5500                    info.activityInfo.applicationInfo.packageName,
5501                    info.activityInfo.name);
5502        }
5503
5504        return null;
5505    }
5506
5507    /**
5508     * Resolve the Intent into an {@link ActivityInfo}
5509     * describing the activity that should execute the intent.  Resolution
5510     * follows the same rules as described for {@link #resolveActivity}, but
5511     * you get back the completely information about the resolved activity
5512     * instead of just its class name.
5513     *
5514     * @param pm The package manager with which to resolve the Intent.
5515     * @param flags Addition information to retrieve as per
5516     * {@link PackageManager#getActivityInfo(ComponentName, int)
5517     * PackageManager.getActivityInfo()}.
5518     *
5519     * @return PackageManager.ActivityInfo
5520     *
5521     * @see #resolveActivity
5522     */
5523    public ActivityInfo resolveActivityInfo(PackageManager pm, int flags) {
5524        ActivityInfo ai = null;
5525        if (mComponent != null) {
5526            try {
5527                ai = pm.getActivityInfo(mComponent, flags);
5528            } catch (PackageManager.NameNotFoundException e) {
5529                // ignore
5530            }
5531        } else {
5532            ResolveInfo info = pm.resolveActivity(
5533                this, PackageManager.MATCH_DEFAULT_ONLY | flags);
5534            if (info != null) {
5535                ai = info.activityInfo;
5536            }
5537        }
5538
5539        return ai;
5540    }
5541
5542    /**
5543     * Special function for use by the system to resolve service
5544     * intents to system apps.  Throws an exception if there are
5545     * multiple potential matches to the Intent.  Returns null if
5546     * there are no matches.
5547     * @hide
5548     */
5549    public ComponentName resolveSystemService(PackageManager pm, int flags) {
5550        if (mComponent != null) {
5551            return mComponent;
5552        }
5553
5554        List<ResolveInfo> results = pm.queryIntentServices(this, flags);
5555        if (results == null) {
5556            return null;
5557        }
5558        ComponentName comp = null;
5559        for (int i=0; i<results.size(); i++) {
5560            ResolveInfo ri = results.get(i);
5561            if ((ri.serviceInfo.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) == 0) {
5562                continue;
5563            }
5564            ComponentName foundComp = new ComponentName(ri.serviceInfo.applicationInfo.packageName,
5565                    ri.serviceInfo.name);
5566            if (comp != null) {
5567                throw new IllegalStateException("Multiple system services handle " + this
5568                        + ": " + comp + ", " + foundComp);
5569            }
5570            comp = foundComp;
5571        }
5572        return comp;
5573    }
5574
5575    /**
5576     * Set the general action to be performed.
5577     *
5578     * @param action An action name, such as ACTION_VIEW.  Application-specific
5579     *               actions should be prefixed with the vendor's package name.
5580     *
5581     * @return Returns the same Intent object, for chaining multiple calls
5582     * into a single statement.
5583     *
5584     * @see #getAction
5585     */
5586    public Intent setAction(String action) {
5587        mAction = action != null ? action.intern() : null;
5588        return this;
5589    }
5590
5591    /**
5592     * Set the data this intent is operating on.  This method automatically
5593     * clears any type that was previously set by {@link #setType} or
5594     * {@link #setTypeAndNormalize}.
5595     *
5596     * <p><em>Note: scheme matching in the Android framework is
5597     * case-sensitive, unlike the formal RFC. As a result,
5598     * you should always write your Uri with a lower case scheme,
5599     * or use {@link Uri#normalizeScheme} or
5600     * {@link #setDataAndNormalize}
5601     * to ensure that the scheme is converted to lower case.</em>
5602     *
5603     * @param data The Uri of the data this intent is now targeting.
5604     *
5605     * @return Returns the same Intent object, for chaining multiple calls
5606     * into a single statement.
5607     *
5608     * @see #getData
5609     * @see #setDataAndNormalize
5610     * @see android.net.Uri#normalizeScheme()
5611     */
5612    public Intent setData(Uri data) {
5613        mData = data;
5614        mType = null;
5615        return this;
5616    }
5617
5618    /**
5619     * Normalize and set the data this intent is operating on.
5620     *
5621     * <p>This method automatically clears any type that was
5622     * previously set (for example, by {@link #setType}).
5623     *
5624     * <p>The data Uri is normalized using
5625     * {@link android.net.Uri#normalizeScheme} before it is set,
5626     * so really this is just a convenience method for
5627     * <pre>
5628     * setData(data.normalize())
5629     * </pre>
5630     *
5631     * @param data The Uri of the data this intent is now targeting.
5632     *
5633     * @return Returns the same Intent object, for chaining multiple calls
5634     * into a single statement.
5635     *
5636     * @see #getData
5637     * @see #setType
5638     * @see android.net.Uri#normalizeScheme
5639     */
5640    public Intent setDataAndNormalize(Uri data) {
5641        return setData(data.normalizeScheme());
5642    }
5643
5644    /**
5645     * Set an explicit MIME data type.
5646     *
5647     * <p>This is used to create intents that only specify a type and not data,
5648     * for example to indicate the type of data to return.
5649     *
5650     * <p>This method automatically clears any data that was
5651     * previously set (for example by {@link #setData}).
5652     *
5653     * <p><em>Note: MIME type matching in the Android framework is
5654     * case-sensitive, unlike formal RFC MIME types.  As a result,
5655     * you should always write your MIME types with lower case letters,
5656     * or use {@link #normalizeMimeType} or {@link #setTypeAndNormalize}
5657     * to ensure that it is converted to lower case.</em>
5658     *
5659     * @param type The MIME type of the data being handled by this intent.
5660     *
5661     * @return Returns the same Intent object, for chaining multiple calls
5662     * into a single statement.
5663     *
5664     * @see #getType
5665     * @see #setTypeAndNormalize
5666     * @see #setDataAndType
5667     * @see #normalizeMimeType
5668     */
5669    public Intent setType(String type) {
5670        mData = null;
5671        mType = type;
5672        return this;
5673    }
5674
5675    /**
5676     * Normalize and set an explicit MIME data type.
5677     *
5678     * <p>This is used to create intents that only specify a type and not data,
5679     * for example to indicate the type of data to return.
5680     *
5681     * <p>This method automatically clears any data that was
5682     * previously set (for example by {@link #setData}).
5683     *
5684     * <p>The MIME type is normalized using
5685     * {@link #normalizeMimeType} before it is set,
5686     * so really this is just a convenience method for
5687     * <pre>
5688     * setType(Intent.normalizeMimeType(type))
5689     * </pre>
5690     *
5691     * @param type The MIME type of the data being handled by this intent.
5692     *
5693     * @return Returns the same Intent object, for chaining multiple calls
5694     * into a single statement.
5695     *
5696     * @see #getType
5697     * @see #setData
5698     * @see #normalizeMimeType
5699     */
5700    public Intent setTypeAndNormalize(String type) {
5701        return setType(normalizeMimeType(type));
5702    }
5703
5704    /**
5705     * (Usually optional) Set the data for the intent along with an explicit
5706     * MIME data type.  This method should very rarely be used -- it allows you
5707     * to override the MIME type that would ordinarily be inferred from the
5708     * data with your own type given here.
5709     *
5710     * <p><em>Note: MIME type and Uri scheme matching in the
5711     * Android framework is case-sensitive, unlike the formal RFC definitions.
5712     * As a result, you should always write these elements with lower case letters,
5713     * or use {@link #normalizeMimeType} or {@link android.net.Uri#normalizeScheme} or
5714     * {@link #setDataAndTypeAndNormalize}
5715     * to ensure that they are converted to lower case.</em>
5716     *
5717     * @param data The Uri of the data this intent is now targeting.
5718     * @param type The MIME type of the data being handled by this intent.
5719     *
5720     * @return Returns the same Intent object, for chaining multiple calls
5721     * into a single statement.
5722     *
5723     * @see #setType
5724     * @see #setData
5725     * @see #normalizeMimeType
5726     * @see android.net.Uri#normalizeScheme
5727     * @see #setDataAndTypeAndNormalize
5728     */
5729    public Intent setDataAndType(Uri data, String type) {
5730        mData = data;
5731        mType = type;
5732        return this;
5733    }
5734
5735    /**
5736     * (Usually optional) Normalize and set both the data Uri and an explicit
5737     * MIME data type.  This method should very rarely be used -- it allows you
5738     * to override the MIME type that would ordinarily be inferred from the
5739     * data with your own type given here.
5740     *
5741     * <p>The data Uri and the MIME type are normalize using
5742     * {@link android.net.Uri#normalizeScheme} and {@link #normalizeMimeType}
5743     * before they are set, so really this is just a convenience method for
5744     * <pre>
5745     * setDataAndType(data.normalize(), Intent.normalizeMimeType(type))
5746     * </pre>
5747     *
5748     * @param data The Uri of the data this intent is now targeting.
5749     * @param type The MIME type of the data being handled by this intent.
5750     *
5751     * @return Returns the same Intent object, for chaining multiple calls
5752     * into a single statement.
5753     *
5754     * @see #setType
5755     * @see #setData
5756     * @see #setDataAndType
5757     * @see #normalizeMimeType
5758     * @see android.net.Uri#normalizeScheme
5759     */
5760    public Intent setDataAndTypeAndNormalize(Uri data, String type) {
5761        return setDataAndType(data.normalizeScheme(), normalizeMimeType(type));
5762    }
5763
5764    /**
5765     * Add a new category to the intent.  Categories provide additional detail
5766     * about the action the intent performs.  When resolving an intent, only
5767     * activities that provide <em>all</em> of the requested categories will be
5768     * used.
5769     *
5770     * @param category The desired category.  This can be either one of the
5771     *               predefined Intent categories, or a custom category in your own
5772     *               namespace.
5773     *
5774     * @return Returns the same Intent object, for chaining multiple calls
5775     * into a single statement.
5776     *
5777     * @see #hasCategory
5778     * @see #removeCategory
5779     */
5780    public Intent addCategory(String category) {
5781        if (mCategories == null) {
5782            mCategories = new ArraySet<String>();
5783        }
5784        mCategories.add(category.intern());
5785        return this;
5786    }
5787
5788    /**
5789     * Remove a category from an intent.
5790     *
5791     * @param category The category to remove.
5792     *
5793     * @see #addCategory
5794     */
5795    public void removeCategory(String category) {
5796        if (mCategories != null) {
5797            mCategories.remove(category);
5798            if (mCategories.size() == 0) {
5799                mCategories = null;
5800            }
5801        }
5802    }
5803
5804    /**
5805     * Set a selector for this Intent.  This is a modification to the kinds of
5806     * things the Intent will match.  If the selector is set, it will be used
5807     * when trying to find entities that can handle the Intent, instead of the
5808     * main contents of the Intent.  This allows you build an Intent containing
5809     * a generic protocol while targeting it more specifically.
5810     *
5811     * <p>An example of where this may be used is with things like
5812     * {@link #CATEGORY_APP_BROWSER}.  This category allows you to build an
5813     * Intent that will launch the Browser application.  However, the correct
5814     * main entry point of an application is actually {@link #ACTION_MAIN}
5815     * {@link #CATEGORY_LAUNCHER} with {@link #setComponent(ComponentName)}
5816     * used to specify the actual Activity to launch.  If you launch the browser
5817     * with something different, undesired behavior may happen if the user has
5818     * previously or later launches it the normal way, since they do not match.
5819     * Instead, you can build an Intent with the MAIN action (but no ComponentName
5820     * yet specified) and set a selector with {@link #ACTION_MAIN} and
5821     * {@link #CATEGORY_APP_BROWSER} to point it specifically to the browser activity.
5822     *
5823     * <p>Setting a selector does not impact the behavior of
5824     * {@link #filterEquals(Intent)} and {@link #filterHashCode()}.  This is part of the
5825     * desired behavior of a selector -- it does not impact the base meaning
5826     * of the Intent, just what kinds of things will be matched against it
5827     * when determining who can handle it.</p>
5828     *
5829     * <p>You can not use both a selector and {@link #setPackage(String)} on
5830     * the same base Intent.</p>
5831     *
5832     * @param selector The desired selector Intent; set to null to not use
5833     * a special selector.
5834     */
5835    public void setSelector(Intent selector) {
5836        if (selector == this) {
5837            throw new IllegalArgumentException(
5838                    "Intent being set as a selector of itself");
5839        }
5840        if (selector != null && mPackage != null) {
5841            throw new IllegalArgumentException(
5842                    "Can't set selector when package name is already set");
5843        }
5844        mSelector = selector;
5845    }
5846
5847    /**
5848     * Set a {@link ClipData} associated with this Intent.  This replaces any
5849     * previously set ClipData.
5850     *
5851     * <p>The ClipData in an intent is not used for Intent matching or other
5852     * such operations.  Semantically it is like extras, used to transmit
5853     * additional data with the Intent.  The main feature of using this over
5854     * the extras for data is that {@link #FLAG_GRANT_READ_URI_PERMISSION}
5855     * and {@link #FLAG_GRANT_WRITE_URI_PERMISSION} will operate on any URI
5856     * items included in the clip data.  This is useful, in particular, if
5857     * you want to transmit an Intent containing multiple <code>content:</code>
5858     * URIs for which the recipient may not have global permission to access the
5859     * content provider.
5860     *
5861     * <p>If the ClipData contains items that are themselves Intents, any
5862     * grant flags in those Intents will be ignored.  Only the top-level flags
5863     * of the main Intent are respected, and will be applied to all Uri or
5864     * Intent items in the clip (or sub-items of the clip).
5865     *
5866     * <p>The MIME type, label, and icon in the ClipData object are not
5867     * directly used by Intent.  Applications should generally rely on the
5868     * MIME type of the Intent itself, not what it may find in the ClipData.
5869     * A common practice is to construct a ClipData for use with an Intent
5870     * with a MIME type of "*&#47;*".
5871     *
5872     * @param clip The new clip to set.  May be null to clear the current clip.
5873     */
5874    public void setClipData(ClipData clip) {
5875        mClipData = clip;
5876    }
5877
5878    /**
5879     * This is NOT a secure mechanism to identify the user who sent the intent.
5880     * When the intent is sent to a different user, it is used to fix uris by adding the userId
5881     * who sent the intent.
5882     * @hide
5883     */
5884    public void setContentUserHint(int contentUserHint) {
5885        mContentUserHint = contentUserHint;
5886    }
5887
5888    /**
5889     * Add extended data to the intent.  The name must include a package
5890     * prefix, for example the app com.android.contacts would use names
5891     * like "com.android.contacts.ShowAll".
5892     *
5893     * @param name The name of the extra data, with package prefix.
5894     * @param value The boolean data value.
5895     *
5896     * @return Returns the same Intent object, for chaining multiple calls
5897     * into a single statement.
5898     *
5899     * @see #putExtras
5900     * @see #removeExtra
5901     * @see #getBooleanExtra(String, boolean)
5902     */
5903    public Intent putExtra(String name, boolean value) {
5904        if (mExtras == null) {
5905            mExtras = new Bundle();
5906        }
5907        mExtras.putBoolean(name, value);
5908        return this;
5909    }
5910
5911    /**
5912     * Add extended data to the intent.  The name must include a package
5913     * prefix, for example the app com.android.contacts would use names
5914     * like "com.android.contacts.ShowAll".
5915     *
5916     * @param name The name of the extra data, with package prefix.
5917     * @param value The byte data value.
5918     *
5919     * @return Returns the same Intent object, for chaining multiple calls
5920     * into a single statement.
5921     *
5922     * @see #putExtras
5923     * @see #removeExtra
5924     * @see #getByteExtra(String, byte)
5925     */
5926    public Intent putExtra(String name, byte value) {
5927        if (mExtras == null) {
5928            mExtras = new Bundle();
5929        }
5930        mExtras.putByte(name, value);
5931        return this;
5932    }
5933
5934    /**
5935     * Add extended data to the intent.  The name must include a package
5936     * prefix, for example the app com.android.contacts would use names
5937     * like "com.android.contacts.ShowAll".
5938     *
5939     * @param name The name of the extra data, with package prefix.
5940     * @param value The char data value.
5941     *
5942     * @return Returns the same Intent object, for chaining multiple calls
5943     * into a single statement.
5944     *
5945     * @see #putExtras
5946     * @see #removeExtra
5947     * @see #getCharExtra(String, char)
5948     */
5949    public Intent putExtra(String name, char value) {
5950        if (mExtras == null) {
5951            mExtras = new Bundle();
5952        }
5953        mExtras.putChar(name, value);
5954        return this;
5955    }
5956
5957    /**
5958     * Add extended data to the intent.  The name must include a package
5959     * prefix, for example the app com.android.contacts would use names
5960     * like "com.android.contacts.ShowAll".
5961     *
5962     * @param name The name of the extra data, with package prefix.
5963     * @param value The short data value.
5964     *
5965     * @return Returns the same Intent object, for chaining multiple calls
5966     * into a single statement.
5967     *
5968     * @see #putExtras
5969     * @see #removeExtra
5970     * @see #getShortExtra(String, short)
5971     */
5972    public Intent putExtra(String name, short value) {
5973        if (mExtras == null) {
5974            mExtras = new Bundle();
5975        }
5976        mExtras.putShort(name, value);
5977        return this;
5978    }
5979
5980    /**
5981     * Add extended data to the intent.  The name must include a package
5982     * prefix, for example the app com.android.contacts would use names
5983     * like "com.android.contacts.ShowAll".
5984     *
5985     * @param name The name of the extra data, with package prefix.
5986     * @param value The integer data value.
5987     *
5988     * @return Returns the same Intent object, for chaining multiple calls
5989     * into a single statement.
5990     *
5991     * @see #putExtras
5992     * @see #removeExtra
5993     * @see #getIntExtra(String, int)
5994     */
5995    public Intent putExtra(String name, int value) {
5996        if (mExtras == null) {
5997            mExtras = new Bundle();
5998        }
5999        mExtras.putInt(name, value);
6000        return this;
6001    }
6002
6003    /**
6004     * Add extended data to the intent.  The name must include a package
6005     * prefix, for example the app com.android.contacts would use names
6006     * like "com.android.contacts.ShowAll".
6007     *
6008     * @param name The name of the extra data, with package prefix.
6009     * @param value The long data value.
6010     *
6011     * @return Returns the same Intent object, for chaining multiple calls
6012     * into a single statement.
6013     *
6014     * @see #putExtras
6015     * @see #removeExtra
6016     * @see #getLongExtra(String, long)
6017     */
6018    public Intent putExtra(String name, long value) {
6019        if (mExtras == null) {
6020            mExtras = new Bundle();
6021        }
6022        mExtras.putLong(name, value);
6023        return this;
6024    }
6025
6026    /**
6027     * Add extended data to the intent.  The name must include a package
6028     * prefix, for example the app com.android.contacts would use names
6029     * like "com.android.contacts.ShowAll".
6030     *
6031     * @param name The name of the extra data, with package prefix.
6032     * @param value The float data value.
6033     *
6034     * @return Returns the same Intent object, for chaining multiple calls
6035     * into a single statement.
6036     *
6037     * @see #putExtras
6038     * @see #removeExtra
6039     * @see #getFloatExtra(String, float)
6040     */
6041    public Intent putExtra(String name, float value) {
6042        if (mExtras == null) {
6043            mExtras = new Bundle();
6044        }
6045        mExtras.putFloat(name, value);
6046        return this;
6047    }
6048
6049    /**
6050     * Add extended data to the intent.  The name must include a package
6051     * prefix, for example the app com.android.contacts would use names
6052     * like "com.android.contacts.ShowAll".
6053     *
6054     * @param name The name of the extra data, with package prefix.
6055     * @param value The double data value.
6056     *
6057     * @return Returns the same Intent object, for chaining multiple calls
6058     * into a single statement.
6059     *
6060     * @see #putExtras
6061     * @see #removeExtra
6062     * @see #getDoubleExtra(String, double)
6063     */
6064    public Intent putExtra(String name, double value) {
6065        if (mExtras == null) {
6066            mExtras = new Bundle();
6067        }
6068        mExtras.putDouble(name, value);
6069        return this;
6070    }
6071
6072    /**
6073     * Add extended data to the intent.  The name must include a package
6074     * prefix, for example the app com.android.contacts would use names
6075     * like "com.android.contacts.ShowAll".
6076     *
6077     * @param name The name of the extra data, with package prefix.
6078     * @param value The String data value.
6079     *
6080     * @return Returns the same Intent object, for chaining multiple calls
6081     * into a single statement.
6082     *
6083     * @see #putExtras
6084     * @see #removeExtra
6085     * @see #getStringExtra(String)
6086     */
6087    public Intent putExtra(String name, String value) {
6088        if (mExtras == null) {
6089            mExtras = new Bundle();
6090        }
6091        mExtras.putString(name, value);
6092        return this;
6093    }
6094
6095    /**
6096     * Add extended data to the intent.  The name must include a package
6097     * prefix, for example the app com.android.contacts would use names
6098     * like "com.android.contacts.ShowAll".
6099     *
6100     * @param name The name of the extra data, with package prefix.
6101     * @param value The CharSequence data value.
6102     *
6103     * @return Returns the same Intent object, for chaining multiple calls
6104     * into a single statement.
6105     *
6106     * @see #putExtras
6107     * @see #removeExtra
6108     * @see #getCharSequenceExtra(String)
6109     */
6110    public Intent putExtra(String name, CharSequence value) {
6111        if (mExtras == null) {
6112            mExtras = new Bundle();
6113        }
6114        mExtras.putCharSequence(name, value);
6115        return this;
6116    }
6117
6118    /**
6119     * Add extended data to the intent.  The name must include a package
6120     * prefix, for example the app com.android.contacts would use names
6121     * like "com.android.contacts.ShowAll".
6122     *
6123     * @param name The name of the extra data, with package prefix.
6124     * @param value The Parcelable data value.
6125     *
6126     * @return Returns the same Intent object, for chaining multiple calls
6127     * into a single statement.
6128     *
6129     * @see #putExtras
6130     * @see #removeExtra
6131     * @see #getParcelableExtra(String)
6132     */
6133    public Intent putExtra(String name, Parcelable value) {
6134        if (mExtras == null) {
6135            mExtras = new Bundle();
6136        }
6137        mExtras.putParcelable(name, value);
6138        return this;
6139    }
6140
6141    /**
6142     * Add extended data to the intent.  The name must include a package
6143     * prefix, for example the app com.android.contacts would use names
6144     * like "com.android.contacts.ShowAll".
6145     *
6146     * @param name The name of the extra data, with package prefix.
6147     * @param value The Parcelable[] data value.
6148     *
6149     * @return Returns the same Intent object, for chaining multiple calls
6150     * into a single statement.
6151     *
6152     * @see #putExtras
6153     * @see #removeExtra
6154     * @see #getParcelableArrayExtra(String)
6155     */
6156    public Intent putExtra(String name, Parcelable[] value) {
6157        if (mExtras == null) {
6158            mExtras = new Bundle();
6159        }
6160        mExtras.putParcelableArray(name, value);
6161        return this;
6162    }
6163
6164    /**
6165     * Add extended data to the intent.  The name must include a package
6166     * prefix, for example the app com.android.contacts would use names
6167     * like "com.android.contacts.ShowAll".
6168     *
6169     * @param name The name of the extra data, with package prefix.
6170     * @param value The ArrayList<Parcelable> data value.
6171     *
6172     * @return Returns the same Intent object, for chaining multiple calls
6173     * into a single statement.
6174     *
6175     * @see #putExtras
6176     * @see #removeExtra
6177     * @see #getParcelableArrayListExtra(String)
6178     */
6179    public Intent putParcelableArrayListExtra(String name, ArrayList<? extends Parcelable> value) {
6180        if (mExtras == null) {
6181            mExtras = new Bundle();
6182        }
6183        mExtras.putParcelableArrayList(name, value);
6184        return this;
6185    }
6186
6187    /**
6188     * Add extended data to the intent.  The name must include a package
6189     * prefix, for example the app com.android.contacts would use names
6190     * like "com.android.contacts.ShowAll".
6191     *
6192     * @param name The name of the extra data, with package prefix.
6193     * @param value The ArrayList<Integer> data value.
6194     *
6195     * @return Returns the same Intent object, for chaining multiple calls
6196     * into a single statement.
6197     *
6198     * @see #putExtras
6199     * @see #removeExtra
6200     * @see #getIntegerArrayListExtra(String)
6201     */
6202    public Intent putIntegerArrayListExtra(String name, ArrayList<Integer> value) {
6203        if (mExtras == null) {
6204            mExtras = new Bundle();
6205        }
6206        mExtras.putIntegerArrayList(name, value);
6207        return this;
6208    }
6209
6210    /**
6211     * Add extended data to the intent.  The name must include a package
6212     * prefix, for example the app com.android.contacts would use names
6213     * like "com.android.contacts.ShowAll".
6214     *
6215     * @param name The name of the extra data, with package prefix.
6216     * @param value The ArrayList<String> data value.
6217     *
6218     * @return Returns the same Intent object, for chaining multiple calls
6219     * into a single statement.
6220     *
6221     * @see #putExtras
6222     * @see #removeExtra
6223     * @see #getStringArrayListExtra(String)
6224     */
6225    public Intent putStringArrayListExtra(String name, ArrayList<String> value) {
6226        if (mExtras == null) {
6227            mExtras = new Bundle();
6228        }
6229        mExtras.putStringArrayList(name, value);
6230        return this;
6231    }
6232
6233    /**
6234     * Add extended data to the intent.  The name must include a package
6235     * prefix, for example the app com.android.contacts would use names
6236     * like "com.android.contacts.ShowAll".
6237     *
6238     * @param name The name of the extra data, with package prefix.
6239     * @param value The ArrayList<CharSequence> data value.
6240     *
6241     * @return Returns the same Intent object, for chaining multiple calls
6242     * into a single statement.
6243     *
6244     * @see #putExtras
6245     * @see #removeExtra
6246     * @see #getCharSequenceArrayListExtra(String)
6247     */
6248    public Intent putCharSequenceArrayListExtra(String name, ArrayList<CharSequence> value) {
6249        if (mExtras == null) {
6250            mExtras = new Bundle();
6251        }
6252        mExtras.putCharSequenceArrayList(name, value);
6253        return this;
6254    }
6255
6256    /**
6257     * Add extended data to the intent.  The name must include a package
6258     * prefix, for example the app com.android.contacts would use names
6259     * like "com.android.contacts.ShowAll".
6260     *
6261     * @param name The name of the extra data, with package prefix.
6262     * @param value The Serializable data value.
6263     *
6264     * @return Returns the same Intent object, for chaining multiple calls
6265     * into a single statement.
6266     *
6267     * @see #putExtras
6268     * @see #removeExtra
6269     * @see #getSerializableExtra(String)
6270     */
6271    public Intent putExtra(String name, Serializable value) {
6272        if (mExtras == null) {
6273            mExtras = new Bundle();
6274        }
6275        mExtras.putSerializable(name, value);
6276        return this;
6277    }
6278
6279    /**
6280     * Add extended data to the intent.  The name must include a package
6281     * prefix, for example the app com.android.contacts would use names
6282     * like "com.android.contacts.ShowAll".
6283     *
6284     * @param name The name of the extra data, with package prefix.
6285     * @param value The boolean array data value.
6286     *
6287     * @return Returns the same Intent object, for chaining multiple calls
6288     * into a single statement.
6289     *
6290     * @see #putExtras
6291     * @see #removeExtra
6292     * @see #getBooleanArrayExtra(String)
6293     */
6294    public Intent putExtra(String name, boolean[] value) {
6295        if (mExtras == null) {
6296            mExtras = new Bundle();
6297        }
6298        mExtras.putBooleanArray(name, value);
6299        return this;
6300    }
6301
6302    /**
6303     * Add extended data to the intent.  The name must include a package
6304     * prefix, for example the app com.android.contacts would use names
6305     * like "com.android.contacts.ShowAll".
6306     *
6307     * @param name The name of the extra data, with package prefix.
6308     * @param value The byte array data value.
6309     *
6310     * @return Returns the same Intent object, for chaining multiple calls
6311     * into a single statement.
6312     *
6313     * @see #putExtras
6314     * @see #removeExtra
6315     * @see #getByteArrayExtra(String)
6316     */
6317    public Intent putExtra(String name, byte[] value) {
6318        if (mExtras == null) {
6319            mExtras = new Bundle();
6320        }
6321        mExtras.putByteArray(name, value);
6322        return this;
6323    }
6324
6325    /**
6326     * Add extended data to the intent.  The name must include a package
6327     * prefix, for example the app com.android.contacts would use names
6328     * like "com.android.contacts.ShowAll".
6329     *
6330     * @param name The name of the extra data, with package prefix.
6331     * @param value The short array data value.
6332     *
6333     * @return Returns the same Intent object, for chaining multiple calls
6334     * into a single statement.
6335     *
6336     * @see #putExtras
6337     * @see #removeExtra
6338     * @see #getShortArrayExtra(String)
6339     */
6340    public Intent putExtra(String name, short[] value) {
6341        if (mExtras == null) {
6342            mExtras = new Bundle();
6343        }
6344        mExtras.putShortArray(name, value);
6345        return this;
6346    }
6347
6348    /**
6349     * Add extended data to the intent.  The name must include a package
6350     * prefix, for example the app com.android.contacts would use names
6351     * like "com.android.contacts.ShowAll".
6352     *
6353     * @param name The name of the extra data, with package prefix.
6354     * @param value The char array data value.
6355     *
6356     * @return Returns the same Intent object, for chaining multiple calls
6357     * into a single statement.
6358     *
6359     * @see #putExtras
6360     * @see #removeExtra
6361     * @see #getCharArrayExtra(String)
6362     */
6363    public Intent putExtra(String name, char[] value) {
6364        if (mExtras == null) {
6365            mExtras = new Bundle();
6366        }
6367        mExtras.putCharArray(name, value);
6368        return this;
6369    }
6370
6371    /**
6372     * Add extended data to the intent.  The name must include a package
6373     * prefix, for example the app com.android.contacts would use names
6374     * like "com.android.contacts.ShowAll".
6375     *
6376     * @param name The name of the extra data, with package prefix.
6377     * @param value The int array data value.
6378     *
6379     * @return Returns the same Intent object, for chaining multiple calls
6380     * into a single statement.
6381     *
6382     * @see #putExtras
6383     * @see #removeExtra
6384     * @see #getIntArrayExtra(String)
6385     */
6386    public Intent putExtra(String name, int[] value) {
6387        if (mExtras == null) {
6388            mExtras = new Bundle();
6389        }
6390        mExtras.putIntArray(name, value);
6391        return this;
6392    }
6393
6394    /**
6395     * Add extended data to the intent.  The name must include a package
6396     * prefix, for example the app com.android.contacts would use names
6397     * like "com.android.contacts.ShowAll".
6398     *
6399     * @param name The name of the extra data, with package prefix.
6400     * @param value The byte array data value.
6401     *
6402     * @return Returns the same Intent object, for chaining multiple calls
6403     * into a single statement.
6404     *
6405     * @see #putExtras
6406     * @see #removeExtra
6407     * @see #getLongArrayExtra(String)
6408     */
6409    public Intent putExtra(String name, long[] value) {
6410        if (mExtras == null) {
6411            mExtras = new Bundle();
6412        }
6413        mExtras.putLongArray(name, value);
6414        return this;
6415    }
6416
6417    /**
6418     * Add extended data to the intent.  The name must include a package
6419     * prefix, for example the app com.android.contacts would use names
6420     * like "com.android.contacts.ShowAll".
6421     *
6422     * @param name The name of the extra data, with package prefix.
6423     * @param value The float array data value.
6424     *
6425     * @return Returns the same Intent object, for chaining multiple calls
6426     * into a single statement.
6427     *
6428     * @see #putExtras
6429     * @see #removeExtra
6430     * @see #getFloatArrayExtra(String)
6431     */
6432    public Intent putExtra(String name, float[] value) {
6433        if (mExtras == null) {
6434            mExtras = new Bundle();
6435        }
6436        mExtras.putFloatArray(name, value);
6437        return this;
6438    }
6439
6440    /**
6441     * Add extended data to the intent.  The name must include a package
6442     * prefix, for example the app com.android.contacts would use names
6443     * like "com.android.contacts.ShowAll".
6444     *
6445     * @param name The name of the extra data, with package prefix.
6446     * @param value The double array data value.
6447     *
6448     * @return Returns the same Intent object, for chaining multiple calls
6449     * into a single statement.
6450     *
6451     * @see #putExtras
6452     * @see #removeExtra
6453     * @see #getDoubleArrayExtra(String)
6454     */
6455    public Intent putExtra(String name, double[] value) {
6456        if (mExtras == null) {
6457            mExtras = new Bundle();
6458        }
6459        mExtras.putDoubleArray(name, value);
6460        return this;
6461    }
6462
6463    /**
6464     * Add extended data to the intent.  The name must include a package
6465     * prefix, for example the app com.android.contacts would use names
6466     * like "com.android.contacts.ShowAll".
6467     *
6468     * @param name The name of the extra data, with package prefix.
6469     * @param value The String array data value.
6470     *
6471     * @return Returns the same Intent object, for chaining multiple calls
6472     * into a single statement.
6473     *
6474     * @see #putExtras
6475     * @see #removeExtra
6476     * @see #getStringArrayExtra(String)
6477     */
6478    public Intent putExtra(String name, String[] value) {
6479        if (mExtras == null) {
6480            mExtras = new Bundle();
6481        }
6482        mExtras.putStringArray(name, value);
6483        return this;
6484    }
6485
6486    /**
6487     * Add extended data to the intent.  The name must include a package
6488     * prefix, for example the app com.android.contacts would use names
6489     * like "com.android.contacts.ShowAll".
6490     *
6491     * @param name The name of the extra data, with package prefix.
6492     * @param value The CharSequence array data value.
6493     *
6494     * @return Returns the same Intent object, for chaining multiple calls
6495     * into a single statement.
6496     *
6497     * @see #putExtras
6498     * @see #removeExtra
6499     * @see #getCharSequenceArrayExtra(String)
6500     */
6501    public Intent putExtra(String name, CharSequence[] value) {
6502        if (mExtras == null) {
6503            mExtras = new Bundle();
6504        }
6505        mExtras.putCharSequenceArray(name, value);
6506        return this;
6507    }
6508
6509    /**
6510     * Add extended data to the intent.  The name must include a package
6511     * prefix, for example the app com.android.contacts would use names
6512     * like "com.android.contacts.ShowAll".
6513     *
6514     * @param name The name of the extra data, with package prefix.
6515     * @param value The Bundle data value.
6516     *
6517     * @return Returns the same Intent object, for chaining multiple calls
6518     * into a single statement.
6519     *
6520     * @see #putExtras
6521     * @see #removeExtra
6522     * @see #getBundleExtra(String)
6523     */
6524    public Intent putExtra(String name, Bundle value) {
6525        if (mExtras == null) {
6526            mExtras = new Bundle();
6527        }
6528        mExtras.putBundle(name, value);
6529        return this;
6530    }
6531
6532    /**
6533     * Add extended data to the intent.  The name must include a package
6534     * prefix, for example the app com.android.contacts would use names
6535     * like "com.android.contacts.ShowAll".
6536     *
6537     * @param name The name of the extra data, with package prefix.
6538     * @param value The IBinder data value.
6539     *
6540     * @return Returns the same Intent object, for chaining multiple calls
6541     * into a single statement.
6542     *
6543     * @see #putExtras
6544     * @see #removeExtra
6545     * @see #getIBinderExtra(String)
6546     *
6547     * @deprecated
6548     * @hide
6549     */
6550    @Deprecated
6551    public Intent putExtra(String name, IBinder value) {
6552        if (mExtras == null) {
6553            mExtras = new Bundle();
6554        }
6555        mExtras.putIBinder(name, value);
6556        return this;
6557    }
6558
6559    /**
6560     * Copy all extras in 'src' in to this intent.
6561     *
6562     * @param src Contains the extras to copy.
6563     *
6564     * @see #putExtra
6565     */
6566    public Intent putExtras(Intent src) {
6567        if (src.mExtras != null) {
6568            if (mExtras == null) {
6569                mExtras = new Bundle(src.mExtras);
6570            } else {
6571                mExtras.putAll(src.mExtras);
6572            }
6573        }
6574        return this;
6575    }
6576
6577    /**
6578     * Add a set of extended data to the intent.  The keys must include a package
6579     * prefix, for example the app com.android.contacts would use names
6580     * like "com.android.contacts.ShowAll".
6581     *
6582     * @param extras The Bundle of extras to add to this intent.
6583     *
6584     * @see #putExtra
6585     * @see #removeExtra
6586     */
6587    public Intent putExtras(Bundle extras) {
6588        if (mExtras == null) {
6589            mExtras = new Bundle();
6590        }
6591        mExtras.putAll(extras);
6592        return this;
6593    }
6594
6595    /**
6596     * Completely replace the extras in the Intent with the extras in the
6597     * given Intent.
6598     *
6599     * @param src The exact extras contained in this Intent are copied
6600     * into the target intent, replacing any that were previously there.
6601     */
6602    public Intent replaceExtras(Intent src) {
6603        mExtras = src.mExtras != null ? new Bundle(src.mExtras) : null;
6604        return this;
6605    }
6606
6607    /**
6608     * Completely replace the extras in the Intent with the given Bundle of
6609     * extras.
6610     *
6611     * @param extras The new set of extras in the Intent, or null to erase
6612     * all extras.
6613     */
6614    public Intent replaceExtras(Bundle extras) {
6615        mExtras = extras != null ? new Bundle(extras) : null;
6616        return this;
6617    }
6618
6619    /**
6620     * Remove extended data from the intent.
6621     *
6622     * @see #putExtra
6623     */
6624    public void removeExtra(String name) {
6625        if (mExtras != null) {
6626            mExtras.remove(name);
6627            if (mExtras.size() == 0) {
6628                mExtras = null;
6629            }
6630        }
6631    }
6632
6633    /**
6634     * Set special flags controlling how this intent is handled.  Most values
6635     * here depend on the type of component being executed by the Intent,
6636     * specifically the FLAG_ACTIVITY_* flags are all for use with
6637     * {@link Context#startActivity Context.startActivity()} and the
6638     * FLAG_RECEIVER_* flags are all for use with
6639     * {@link Context#sendBroadcast(Intent) Context.sendBroadcast()}.
6640     *
6641     * <p>See the
6642     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
6643     * Stack</a> documentation for important information on how some of these options impact
6644     * the behavior of your application.
6645     *
6646     * @param flags The desired flags.
6647     *
6648     * @return Returns the same Intent object, for chaining multiple calls
6649     * into a single statement.
6650     *
6651     * @see #getFlags
6652     * @see #addFlags
6653     *
6654     * @see #FLAG_GRANT_READ_URI_PERMISSION
6655     * @see #FLAG_GRANT_WRITE_URI_PERMISSION
6656     * @see #FLAG_GRANT_PERSISTABLE_URI_PERMISSION
6657     * @see #FLAG_GRANT_PREFIX_URI_PERMISSION
6658     * @see #FLAG_DEBUG_LOG_RESOLUTION
6659     * @see #FLAG_FROM_BACKGROUND
6660     * @see #FLAG_ACTIVITY_BROUGHT_TO_FRONT
6661     * @see #FLAG_ACTIVITY_CLEAR_TASK
6662     * @see #FLAG_ACTIVITY_CLEAR_TOP
6663     * @see #FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET
6664     * @see #FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
6665     * @see #FLAG_ACTIVITY_FORWARD_RESULT
6666     * @see #FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY
6667     * @see #FLAG_ACTIVITY_MULTIPLE_TASK
6668     * @see #FLAG_ACTIVITY_NEW_DOCUMENT
6669     * @see #FLAG_ACTIVITY_NEW_TASK
6670     * @see #FLAG_ACTIVITY_NO_ANIMATION
6671     * @see #FLAG_ACTIVITY_NO_HISTORY
6672     * @see #FLAG_ACTIVITY_NO_USER_ACTION
6673     * @see #FLAG_ACTIVITY_PREVIOUS_IS_TOP
6674     * @see #FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
6675     * @see #FLAG_ACTIVITY_REORDER_TO_FRONT
6676     * @see #FLAG_ACTIVITY_SINGLE_TOP
6677     * @see #FLAG_ACTIVITY_TASK_ON_HOME
6678     * @see #FLAG_RECEIVER_REGISTERED_ONLY
6679     */
6680    public Intent setFlags(int flags) {
6681        mFlags = flags;
6682        return this;
6683    }
6684
6685    /**
6686     * Add additional flags to the intent (or with existing flags
6687     * value).
6688     *
6689     * @param flags The new flags to set.
6690     *
6691     * @return Returns the same Intent object, for chaining multiple calls
6692     * into a single statement.
6693     *
6694     * @see #setFlags
6695     */
6696    public Intent addFlags(int flags) {
6697        mFlags |= flags;
6698        return this;
6699    }
6700
6701    /**
6702     * (Usually optional) Set an explicit application package name that limits
6703     * the components this Intent will resolve to.  If left to the default
6704     * value of null, all components in all applications will considered.
6705     * If non-null, the Intent can only match the components in the given
6706     * application package.
6707     *
6708     * @param packageName The name of the application package to handle the
6709     * intent, or null to allow any application package.
6710     *
6711     * @return Returns the same Intent object, for chaining multiple calls
6712     * into a single statement.
6713     *
6714     * @see #getPackage
6715     * @see #resolveActivity
6716     */
6717    public Intent setPackage(String packageName) {
6718        if (packageName != null && mSelector != null) {
6719            throw new IllegalArgumentException(
6720                    "Can't set package name when selector is already set");
6721        }
6722        mPackage = packageName;
6723        return this;
6724    }
6725
6726    /**
6727     * (Usually optional) Explicitly set the component to handle the intent.
6728     * If left with the default value of null, the system will determine the
6729     * appropriate class to use based on the other fields (action, data,
6730     * type, categories) in the Intent.  If this class is defined, the
6731     * specified class will always be used regardless of the other fields.  You
6732     * should only set this value when you know you absolutely want a specific
6733     * class to be used; otherwise it is better to let the system find the
6734     * appropriate class so that you will respect the installed applications
6735     * and user preferences.
6736     *
6737     * @param component The name of the application component to handle the
6738     * intent, or null to let the system find one for you.
6739     *
6740     * @return Returns the same Intent object, for chaining multiple calls
6741     * into a single statement.
6742     *
6743     * @see #setClass
6744     * @see #setClassName(Context, String)
6745     * @see #setClassName(String, String)
6746     * @see #getComponent
6747     * @see #resolveActivity
6748     */
6749    public Intent setComponent(ComponentName component) {
6750        mComponent = component;
6751        return this;
6752    }
6753
6754    /**
6755     * Convenience for calling {@link #setComponent} with an
6756     * explicit class name.
6757     *
6758     * @param packageContext A Context of the application package implementing
6759     * this class.
6760     * @param className The name of a class inside of the application package
6761     * that will be used as the component for this Intent.
6762     *
6763     * @return Returns the same Intent object, for chaining multiple calls
6764     * into a single statement.
6765     *
6766     * @see #setComponent
6767     * @see #setClass
6768     */
6769    public Intent setClassName(Context packageContext, String className) {
6770        mComponent = new ComponentName(packageContext, className);
6771        return this;
6772    }
6773
6774    /**
6775     * Convenience for calling {@link #setComponent} with an
6776     * explicit application package name and class name.
6777     *
6778     * @param packageName The name of the package implementing the desired
6779     * component.
6780     * @param className The name of a class inside of the application package
6781     * that will be used as the component for this Intent.
6782     *
6783     * @return Returns the same Intent object, for chaining multiple calls
6784     * into a single statement.
6785     *
6786     * @see #setComponent
6787     * @see #setClass
6788     */
6789    public Intent setClassName(String packageName, String className) {
6790        mComponent = new ComponentName(packageName, className);
6791        return this;
6792    }
6793
6794    /**
6795     * Convenience for calling {@link #setComponent(ComponentName)} with the
6796     * name returned by a {@link Class} object.
6797     *
6798     * @param packageContext A Context of the application package implementing
6799     * this class.
6800     * @param cls The class name to set, equivalent to
6801     *            <code>setClassName(context, cls.getName())</code>.
6802     *
6803     * @return Returns the same Intent object, for chaining multiple calls
6804     * into a single statement.
6805     *
6806     * @see #setComponent
6807     */
6808    public Intent setClass(Context packageContext, Class<?> cls) {
6809        mComponent = new ComponentName(packageContext, cls);
6810        return this;
6811    }
6812
6813    /**
6814     * Set the bounds of the sender of this intent, in screen coordinates.  This can be
6815     * used as a hint to the receiver for animations and the like.  Null means that there
6816     * is no source bounds.
6817     */
6818    public void setSourceBounds(Rect r) {
6819        if (r != null) {
6820            mSourceBounds = new Rect(r);
6821        } else {
6822            mSourceBounds = null;
6823        }
6824    }
6825
6826    /** @hide */
6827    @IntDef(flag = true,
6828            value = {
6829                    FILL_IN_ACTION,
6830                    FILL_IN_DATA,
6831                    FILL_IN_CATEGORIES,
6832                    FILL_IN_COMPONENT,
6833                    FILL_IN_PACKAGE,
6834                    FILL_IN_SOURCE_BOUNDS,
6835                    FILL_IN_SELECTOR,
6836                    FILL_IN_CLIP_DATA
6837            })
6838    @Retention(RetentionPolicy.SOURCE)
6839    public @interface FillInFlags {}
6840
6841    /**
6842     * Use with {@link #fillIn} to allow the current action value to be
6843     * overwritten, even if it is already set.
6844     */
6845    public static final int FILL_IN_ACTION = 1<<0;
6846
6847    /**
6848     * Use with {@link #fillIn} to allow the current data or type value
6849     * overwritten, even if it is already set.
6850     */
6851    public static final int FILL_IN_DATA = 1<<1;
6852
6853    /**
6854     * Use with {@link #fillIn} to allow the current categories to be
6855     * overwritten, even if they are already set.
6856     */
6857    public static final int FILL_IN_CATEGORIES = 1<<2;
6858
6859    /**
6860     * Use with {@link #fillIn} to allow the current component value to be
6861     * overwritten, even if it is already set.
6862     */
6863    public static final int FILL_IN_COMPONENT = 1<<3;
6864
6865    /**
6866     * Use with {@link #fillIn} to allow the current package value to be
6867     * overwritten, even if it is already set.
6868     */
6869    public static final int FILL_IN_PACKAGE = 1<<4;
6870
6871    /**
6872     * Use with {@link #fillIn} to allow the current bounds rectangle to be
6873     * overwritten, even if it is already set.
6874     */
6875    public static final int FILL_IN_SOURCE_BOUNDS = 1<<5;
6876
6877    /**
6878     * Use with {@link #fillIn} to allow the current selector to be
6879     * overwritten, even if it is already set.
6880     */
6881    public static final int FILL_IN_SELECTOR = 1<<6;
6882
6883    /**
6884     * Use with {@link #fillIn} to allow the current ClipData to be
6885     * overwritten, even if it is already set.
6886     */
6887    public static final int FILL_IN_CLIP_DATA = 1<<7;
6888
6889    /**
6890     * Copy the contents of <var>other</var> in to this object, but only
6891     * where fields are not defined by this object.  For purposes of a field
6892     * being defined, the following pieces of data in the Intent are
6893     * considered to be separate fields:
6894     *
6895     * <ul>
6896     * <li> action, as set by {@link #setAction}.
6897     * <li> data Uri and MIME type, as set by {@link #setData(Uri)},
6898     * {@link #setType(String)}, or {@link #setDataAndType(Uri, String)}.
6899     * <li> categories, as set by {@link #addCategory}.
6900     * <li> package, as set by {@link #setPackage}.
6901     * <li> component, as set by {@link #setComponent(ComponentName)} or
6902     * related methods.
6903     * <li> source bounds, as set by {@link #setSourceBounds}.
6904     * <li> selector, as set by {@link #setSelector(Intent)}.
6905     * <li> clip data, as set by {@link #setClipData(ClipData)}.
6906     * <li> each top-level name in the associated extras.
6907     * </ul>
6908     *
6909     * <p>In addition, you can use the {@link #FILL_IN_ACTION},
6910     * {@link #FILL_IN_DATA}, {@link #FILL_IN_CATEGORIES}, {@link #FILL_IN_PACKAGE},
6911     * {@link #FILL_IN_COMPONENT}, {@link #FILL_IN_SOURCE_BOUNDS},
6912     * {@link #FILL_IN_SELECTOR}, and {@link #FILL_IN_CLIP_DATA} to override
6913     * the restriction where the corresponding field will not be replaced if
6914     * it is already set.
6915     *
6916     * <p>Note: The component field will only be copied if {@link #FILL_IN_COMPONENT}
6917     * is explicitly specified.  The selector will only be copied if
6918     * {@link #FILL_IN_SELECTOR} is explicitly specified.
6919     *
6920     * <p>For example, consider Intent A with {data="foo", categories="bar"}
6921     * and Intent B with {action="gotit", data-type="some/thing",
6922     * categories="one","two"}.
6923     *
6924     * <p>Calling A.fillIn(B, Intent.FILL_IN_DATA) will result in A now
6925     * containing: {action="gotit", data-type="some/thing",
6926     * categories="bar"}.
6927     *
6928     * @param other Another Intent whose values are to be used to fill in
6929     * the current one.
6930     * @param flags Options to control which fields can be filled in.
6931     *
6932     * @return Returns a bit mask of {@link #FILL_IN_ACTION},
6933     * {@link #FILL_IN_DATA}, {@link #FILL_IN_CATEGORIES}, {@link #FILL_IN_PACKAGE},
6934     * {@link #FILL_IN_COMPONENT}, {@link #FILL_IN_SOURCE_BOUNDS},
6935     * {@link #FILL_IN_SELECTOR} and {@link #FILL_IN_CLIP_DATA indicating which fields were
6936     * changed.
6937     */
6938    @FillInFlags
6939    public int fillIn(Intent other, @FillInFlags int flags) {
6940        int changes = 0;
6941        boolean mayHaveCopiedUris = false;
6942        if (other.mAction != null
6943                && (mAction == null || (flags&FILL_IN_ACTION) != 0)) {
6944            mAction = other.mAction;
6945            changes |= FILL_IN_ACTION;
6946        }
6947        if ((other.mData != null || other.mType != null)
6948                && ((mData == null && mType == null)
6949                        || (flags&FILL_IN_DATA) != 0)) {
6950            mData = other.mData;
6951            mType = other.mType;
6952            changes |= FILL_IN_DATA;
6953            mayHaveCopiedUris = true;
6954        }
6955        if (other.mCategories != null
6956                && (mCategories == null || (flags&FILL_IN_CATEGORIES) != 0)) {
6957            if (other.mCategories != null) {
6958                mCategories = new ArraySet<String>(other.mCategories);
6959            }
6960            changes |= FILL_IN_CATEGORIES;
6961        }
6962        if (other.mPackage != null
6963                && (mPackage == null || (flags&FILL_IN_PACKAGE) != 0)) {
6964            // Only do this if mSelector is not set.
6965            if (mSelector == null) {
6966                mPackage = other.mPackage;
6967                changes |= FILL_IN_PACKAGE;
6968            }
6969        }
6970        // Selector is special: it can only be set if explicitly allowed,
6971        // for the same reason as the component name.
6972        if (other.mSelector != null && (flags&FILL_IN_SELECTOR) != 0) {
6973            if (mPackage == null) {
6974                mSelector = new Intent(other.mSelector);
6975                mPackage = null;
6976                changes |= FILL_IN_SELECTOR;
6977            }
6978        }
6979        if (other.mClipData != null
6980                && (mClipData == null || (flags&FILL_IN_CLIP_DATA) != 0)) {
6981            mClipData = other.mClipData;
6982            changes |= FILL_IN_CLIP_DATA;
6983            mayHaveCopiedUris = true;
6984        }
6985        // Component is special: it can -only- be set if explicitly allowed,
6986        // since otherwise the sender could force the intent somewhere the
6987        // originator didn't intend.
6988        if (other.mComponent != null && (flags&FILL_IN_COMPONENT) != 0) {
6989            mComponent = other.mComponent;
6990            changes |= FILL_IN_COMPONENT;
6991        }
6992        mFlags |= other.mFlags;
6993        if (other.mSourceBounds != null
6994                && (mSourceBounds == null || (flags&FILL_IN_SOURCE_BOUNDS) != 0)) {
6995            mSourceBounds = new Rect(other.mSourceBounds);
6996            changes |= FILL_IN_SOURCE_BOUNDS;
6997        }
6998        if (mExtras == null) {
6999            if (other.mExtras != null) {
7000                mExtras = new Bundle(other.mExtras);
7001                mayHaveCopiedUris = true;
7002            }
7003        } else if (other.mExtras != null) {
7004            try {
7005                Bundle newb = new Bundle(other.mExtras);
7006                newb.putAll(mExtras);
7007                mExtras = newb;
7008                mayHaveCopiedUris = true;
7009            } catch (RuntimeException e) {
7010                // Modifying the extras can cause us to unparcel the contents
7011                // of the bundle, and if we do this in the system process that
7012                // may fail.  We really should handle this (i.e., the Bundle
7013                // impl shouldn't be on top of a plain map), but for now just
7014                // ignore it and keep the original contents. :(
7015                Log.w("Intent", "Failure filling in extras", e);
7016            }
7017        }
7018        if (mayHaveCopiedUris && mContentUserHint == UserHandle.USER_CURRENT
7019                && other.mContentUserHint != UserHandle.USER_CURRENT) {
7020            mContentUserHint = other.mContentUserHint;
7021        }
7022        return changes;
7023    }
7024
7025    /**
7026     * Wrapper class holding an Intent and implementing comparisons on it for
7027     * the purpose of filtering.  The class implements its
7028     * {@link #equals equals()} and {@link #hashCode hashCode()} methods as
7029     * simple calls to {@link Intent#filterEquals(Intent)}  filterEquals()} and
7030     * {@link android.content.Intent#filterHashCode()}  filterHashCode()}
7031     * on the wrapped Intent.
7032     */
7033    public static final class FilterComparison {
7034        private final Intent mIntent;
7035        private final int mHashCode;
7036
7037        public FilterComparison(Intent intent) {
7038            mIntent = intent;
7039            mHashCode = intent.filterHashCode();
7040        }
7041
7042        /**
7043         * Return the Intent that this FilterComparison represents.
7044         * @return Returns the Intent held by the FilterComparison.  Do
7045         * not modify!
7046         */
7047        public Intent getIntent() {
7048            return mIntent;
7049        }
7050
7051        @Override
7052        public boolean equals(Object obj) {
7053            if (obj instanceof FilterComparison) {
7054                Intent other = ((FilterComparison)obj).mIntent;
7055                return mIntent.filterEquals(other);
7056            }
7057            return false;
7058        }
7059
7060        @Override
7061        public int hashCode() {
7062            return mHashCode;
7063        }
7064    }
7065
7066    /**
7067     * Determine if two intents are the same for the purposes of intent
7068     * resolution (filtering). That is, if their action, data, type,
7069     * class, and categories are the same.  This does <em>not</em> compare
7070     * any extra data included in the intents.
7071     *
7072     * @param other The other Intent to compare against.
7073     *
7074     * @return Returns true if action, data, type, class, and categories
7075     *         are the same.
7076     */
7077    public boolean filterEquals(Intent other) {
7078        if (other == null) {
7079            return false;
7080        }
7081        if (!Objects.equals(this.mAction, other.mAction)) return false;
7082        if (!Objects.equals(this.mData, other.mData)) return false;
7083        if (!Objects.equals(this.mType, other.mType)) return false;
7084        if (!Objects.equals(this.mPackage, other.mPackage)) return false;
7085        if (!Objects.equals(this.mComponent, other.mComponent)) return false;
7086        if (!Objects.equals(this.mCategories, other.mCategories)) return false;
7087
7088        return true;
7089    }
7090
7091    /**
7092     * Generate hash code that matches semantics of filterEquals().
7093     *
7094     * @return Returns the hash value of the action, data, type, class, and
7095     *         categories.
7096     *
7097     * @see #filterEquals
7098     */
7099    public int filterHashCode() {
7100        int code = 0;
7101        if (mAction != null) {
7102            code += mAction.hashCode();
7103        }
7104        if (mData != null) {
7105            code += mData.hashCode();
7106        }
7107        if (mType != null) {
7108            code += mType.hashCode();
7109        }
7110        if (mPackage != null) {
7111            code += mPackage.hashCode();
7112        }
7113        if (mComponent != null) {
7114            code += mComponent.hashCode();
7115        }
7116        if (mCategories != null) {
7117            code += mCategories.hashCode();
7118        }
7119        return code;
7120    }
7121
7122    @Override
7123    public String toString() {
7124        StringBuilder b = new StringBuilder(128);
7125
7126        b.append("Intent { ");
7127        toShortString(b, true, true, true, false);
7128        b.append(" }");
7129
7130        return b.toString();
7131    }
7132
7133    /** @hide */
7134    public String toInsecureString() {
7135        StringBuilder b = new StringBuilder(128);
7136
7137        b.append("Intent { ");
7138        toShortString(b, false, true, true, false);
7139        b.append(" }");
7140
7141        return b.toString();
7142    }
7143
7144    /** @hide */
7145    public String toInsecureStringWithClip() {
7146        StringBuilder b = new StringBuilder(128);
7147
7148        b.append("Intent { ");
7149        toShortString(b, false, true, true, true);
7150        b.append(" }");
7151
7152        return b.toString();
7153    }
7154
7155    /** @hide */
7156    public String toShortString(boolean secure, boolean comp, boolean extras, boolean clip) {
7157        StringBuilder b = new StringBuilder(128);
7158        toShortString(b, secure, comp, extras, clip);
7159        return b.toString();
7160    }
7161
7162    /** @hide */
7163    public void toShortString(StringBuilder b, boolean secure, boolean comp, boolean extras,
7164            boolean clip) {
7165        boolean first = true;
7166        if (mAction != null) {
7167            b.append("act=").append(mAction);
7168            first = false;
7169        }
7170        if (mCategories != null) {
7171            if (!first) {
7172                b.append(' ');
7173            }
7174            first = false;
7175            b.append("cat=[");
7176            for (int i=0; i<mCategories.size(); i++) {
7177                if (i > 0) b.append(',');
7178                b.append(mCategories.valueAt(i));
7179            }
7180            b.append("]");
7181        }
7182        if (mData != null) {
7183            if (!first) {
7184                b.append(' ');
7185            }
7186            first = false;
7187            b.append("dat=");
7188            if (secure) {
7189                b.append(mData.toSafeString());
7190            } else {
7191                b.append(mData);
7192            }
7193        }
7194        if (mType != null) {
7195            if (!first) {
7196                b.append(' ');
7197            }
7198            first = false;
7199            b.append("typ=").append(mType);
7200        }
7201        if (mFlags != 0) {
7202            if (!first) {
7203                b.append(' ');
7204            }
7205            first = false;
7206            b.append("flg=0x").append(Integer.toHexString(mFlags));
7207        }
7208        if (mPackage != null) {
7209            if (!first) {
7210                b.append(' ');
7211            }
7212            first = false;
7213            b.append("pkg=").append(mPackage);
7214        }
7215        if (comp && mComponent != null) {
7216            if (!first) {
7217                b.append(' ');
7218            }
7219            first = false;
7220            b.append("cmp=").append(mComponent.flattenToShortString());
7221        }
7222        if (mSourceBounds != null) {
7223            if (!first) {
7224                b.append(' ');
7225            }
7226            first = false;
7227            b.append("bnds=").append(mSourceBounds.toShortString());
7228        }
7229        if (mClipData != null) {
7230            if (!first) {
7231                b.append(' ');
7232            }
7233            first = false;
7234            if (clip) {
7235                b.append("clip={");
7236                mClipData.toShortString(b);
7237                b.append('}');
7238            } else {
7239                b.append("(has clip)");
7240            }
7241        }
7242        if (extras && mExtras != null) {
7243            if (!first) {
7244                b.append(' ');
7245            }
7246            first = false;
7247            b.append("(has extras)");
7248        }
7249        if (mContentUserHint != UserHandle.USER_CURRENT) {
7250            if (!first) {
7251                b.append(' ');
7252            }
7253            first = false;
7254            b.append("u=").append(mContentUserHint);
7255        }
7256        if (mSelector != null) {
7257            b.append(" sel=");
7258            mSelector.toShortString(b, secure, comp, extras, clip);
7259            b.append("}");
7260        }
7261    }
7262
7263    /**
7264     * Call {@link #toUri} with 0 flags.
7265     * @deprecated Use {@link #toUri} instead.
7266     */
7267    @Deprecated
7268    public String toURI() {
7269        return toUri(0);
7270    }
7271
7272    /**
7273     * Convert this Intent into a String holding a URI representation of it.
7274     * The returned URI string has been properly URI encoded, so it can be
7275     * used with {@link Uri#parse Uri.parse(String)}.  The URI contains the
7276     * Intent's data as the base URI, with an additional fragment describing
7277     * the action, categories, type, flags, package, component, and extras.
7278     *
7279     * <p>You can convert the returned string back to an Intent with
7280     * {@link #getIntent}.
7281     *
7282     * @param flags Additional operating flags.  Either 0,
7283     * {@link #URI_INTENT_SCHEME}, or {@link #URI_ANDROID_APP_SCHEME}.
7284     *
7285     * @return Returns a URI encoding URI string describing the entire contents
7286     * of the Intent.
7287     */
7288    public String toUri(int flags) {
7289        StringBuilder uri = new StringBuilder(128);
7290        if ((flags&URI_ANDROID_APP_SCHEME) != 0) {
7291            if (mPackage == null) {
7292                throw new IllegalArgumentException(
7293                        "Intent must include an explicit package name to build an android-app: "
7294                        + this);
7295            }
7296            uri.append("android-app://");
7297            uri.append(mPackage);
7298            String scheme = null;
7299            if (mData != null) {
7300                scheme = mData.getScheme();
7301                if (scheme != null) {
7302                    uri.append('/');
7303                    uri.append(scheme);
7304                    String authority = mData.getEncodedAuthority();
7305                    if (authority != null) {
7306                        uri.append('/');
7307                        uri.append(authority);
7308                        String path = mData.getEncodedPath();
7309                        if (path != null) {
7310                            uri.append(path);
7311                        }
7312                        String queryParams = mData.getEncodedQuery();
7313                        if (queryParams != null) {
7314                            uri.append('?');
7315                            uri.append(queryParams);
7316                        }
7317                        String fragment = mData.getEncodedFragment();
7318                        if (fragment != null) {
7319                            uri.append('#');
7320                            uri.append(fragment);
7321                        }
7322                    }
7323                }
7324            }
7325            toUriFragment(uri, null, scheme == null ? Intent.ACTION_MAIN : Intent.ACTION_VIEW,
7326                    mPackage, flags);
7327            return uri.toString();
7328        }
7329        String scheme = null;
7330        if (mData != null) {
7331            String data = mData.toString();
7332            if ((flags&URI_INTENT_SCHEME) != 0) {
7333                final int N = data.length();
7334                for (int i=0; i<N; i++) {
7335                    char c = data.charAt(i);
7336                    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
7337                            || c == '.' || c == '-') {
7338                        continue;
7339                    }
7340                    if (c == ':' && i > 0) {
7341                        // Valid scheme.
7342                        scheme = data.substring(0, i);
7343                        uri.append("intent:");
7344                        data = data.substring(i+1);
7345                        break;
7346                    }
7347
7348                    // No scheme.
7349                    break;
7350                }
7351            }
7352            uri.append(data);
7353
7354        } else if ((flags&URI_INTENT_SCHEME) != 0) {
7355            uri.append("intent:");
7356        }
7357
7358        toUriFragment(uri, scheme, Intent.ACTION_VIEW, null, flags);
7359
7360        return uri.toString();
7361    }
7362
7363    private void toUriFragment(StringBuilder uri, String scheme, String defAction,
7364            String defPackage, int flags) {
7365        StringBuilder frag = new StringBuilder(128);
7366
7367        toUriInner(frag, scheme, defAction, defPackage, flags);
7368        if (mSelector != null) {
7369            frag.append("SEL;");
7370            // Note that for now we are not going to try to handle the
7371            // data part; not clear how to represent this as a URI, and
7372            // not much utility in it.
7373            mSelector.toUriInner(frag, mSelector.mData != null ? mSelector.mData.getScheme() : null,
7374                    null, null, flags);
7375        }
7376
7377        if (frag.length() > 0) {
7378            uri.append("#Intent;");
7379            uri.append(frag);
7380            uri.append("end");
7381        }
7382    }
7383
7384    private void toUriInner(StringBuilder uri, String scheme, String defAction,
7385            String defPackage, int flags) {
7386        if (scheme != null) {
7387            uri.append("scheme=").append(scheme).append(';');
7388        }
7389        if (mAction != null && !mAction.equals(defAction)) {
7390            uri.append("action=").append(Uri.encode(mAction)).append(';');
7391        }
7392        if (mCategories != null) {
7393            for (int i=0; i<mCategories.size(); i++) {
7394                uri.append("category=").append(Uri.encode(mCategories.valueAt(i))).append(';');
7395            }
7396        }
7397        if (mType != null) {
7398            uri.append("type=").append(Uri.encode(mType, "/")).append(';');
7399        }
7400        if (mFlags != 0) {
7401            uri.append("launchFlags=0x").append(Integer.toHexString(mFlags)).append(';');
7402        }
7403        if (mPackage != null && !mPackage.equals(defPackage)) {
7404            uri.append("package=").append(Uri.encode(mPackage)).append(';');
7405        }
7406        if (mComponent != null) {
7407            uri.append("component=").append(Uri.encode(
7408                    mComponent.flattenToShortString(), "/")).append(';');
7409        }
7410        if (mSourceBounds != null) {
7411            uri.append("sourceBounds=")
7412                    .append(Uri.encode(mSourceBounds.flattenToString()))
7413                    .append(';');
7414        }
7415        if (mExtras != null) {
7416            for (String key : mExtras.keySet()) {
7417                final Object value = mExtras.get(key);
7418                char entryType =
7419                        value instanceof String    ? 'S' :
7420                        value instanceof Boolean   ? 'B' :
7421                        value instanceof Byte      ? 'b' :
7422                        value instanceof Character ? 'c' :
7423                        value instanceof Double    ? 'd' :
7424                        value instanceof Float     ? 'f' :
7425                        value instanceof Integer   ? 'i' :
7426                        value instanceof Long      ? 'l' :
7427                        value instanceof Short     ? 's' :
7428                        '\0';
7429
7430                if (entryType != '\0') {
7431                    uri.append(entryType);
7432                    uri.append('.');
7433                    uri.append(Uri.encode(key));
7434                    uri.append('=');
7435                    uri.append(Uri.encode(value.toString()));
7436                    uri.append(';');
7437                }
7438            }
7439        }
7440    }
7441
7442    public int describeContents() {
7443        return (mExtras != null) ? mExtras.describeContents() : 0;
7444    }
7445
7446    public void writeToParcel(Parcel out, int flags) {
7447        out.writeString(mAction);
7448        Uri.writeToParcel(out, mData);
7449        out.writeString(mType);
7450        out.writeInt(mFlags);
7451        out.writeString(mPackage);
7452        ComponentName.writeToParcel(mComponent, out);
7453
7454        if (mSourceBounds != null) {
7455            out.writeInt(1);
7456            mSourceBounds.writeToParcel(out, flags);
7457        } else {
7458            out.writeInt(0);
7459        }
7460
7461        if (mCategories != null) {
7462            final int N = mCategories.size();
7463            out.writeInt(N);
7464            for (int i=0; i<N; i++) {
7465                out.writeString(mCategories.valueAt(i));
7466            }
7467        } else {
7468            out.writeInt(0);
7469        }
7470
7471        if (mSelector != null) {
7472            out.writeInt(1);
7473            mSelector.writeToParcel(out, flags);
7474        } else {
7475            out.writeInt(0);
7476        }
7477
7478        if (mClipData != null) {
7479            out.writeInt(1);
7480            mClipData.writeToParcel(out, flags);
7481        } else {
7482            out.writeInt(0);
7483        }
7484        out.writeInt(mContentUserHint);
7485        out.writeBundle(mExtras);
7486    }
7487
7488    public static final Parcelable.Creator<Intent> CREATOR
7489            = new Parcelable.Creator<Intent>() {
7490        public Intent createFromParcel(Parcel in) {
7491            return new Intent(in);
7492        }
7493        public Intent[] newArray(int size) {
7494            return new Intent[size];
7495        }
7496    };
7497
7498    /** @hide */
7499    protected Intent(Parcel in) {
7500        readFromParcel(in);
7501    }
7502
7503    public void readFromParcel(Parcel in) {
7504        setAction(in.readString());
7505        mData = Uri.CREATOR.createFromParcel(in);
7506        mType = in.readString();
7507        mFlags = in.readInt();
7508        mPackage = in.readString();
7509        mComponent = ComponentName.readFromParcel(in);
7510
7511        if (in.readInt() != 0) {
7512            mSourceBounds = Rect.CREATOR.createFromParcel(in);
7513        }
7514
7515        int N = in.readInt();
7516        if (N > 0) {
7517            mCategories = new ArraySet<String>();
7518            int i;
7519            for (i=0; i<N; i++) {
7520                mCategories.add(in.readString().intern());
7521            }
7522        } else {
7523            mCategories = null;
7524        }
7525
7526        if (in.readInt() != 0) {
7527            mSelector = new Intent(in);
7528        }
7529
7530        if (in.readInt() != 0) {
7531            mClipData = new ClipData(in);
7532        }
7533        mContentUserHint = in.readInt();
7534        mExtras = in.readBundle();
7535    }
7536
7537    /**
7538     * Parses the "intent" element (and its children) from XML and instantiates
7539     * an Intent object.  The given XML parser should be located at the tag
7540     * where parsing should start (often named "intent"), from which the
7541     * basic action, data, type, and package and class name will be
7542     * retrieved.  The function will then parse in to any child elements,
7543     * looking for <category android:name="xxx"> tags to add categories and
7544     * <extra android:name="xxx" android:value="yyy"> to attach extra data
7545     * to the intent.
7546     *
7547     * @param resources The Resources to use when inflating resources.
7548     * @param parser The XML parser pointing at an "intent" tag.
7549     * @param attrs The AttributeSet interface for retrieving extended
7550     * attribute data at the current <var>parser</var> location.
7551     * @return An Intent object matching the XML data.
7552     * @throws XmlPullParserException If there was an XML parsing error.
7553     * @throws IOException If there was an I/O error.
7554     */
7555    public static Intent parseIntent(Resources resources, XmlPullParser parser, AttributeSet attrs)
7556            throws XmlPullParserException, IOException {
7557        Intent intent = new Intent();
7558
7559        TypedArray sa = resources.obtainAttributes(attrs,
7560                com.android.internal.R.styleable.Intent);
7561
7562        intent.setAction(sa.getString(com.android.internal.R.styleable.Intent_action));
7563
7564        String data = sa.getString(com.android.internal.R.styleable.Intent_data);
7565        String mimeType = sa.getString(com.android.internal.R.styleable.Intent_mimeType);
7566        intent.setDataAndType(data != null ? Uri.parse(data) : null, mimeType);
7567
7568        String packageName = sa.getString(com.android.internal.R.styleable.Intent_targetPackage);
7569        String className = sa.getString(com.android.internal.R.styleable.Intent_targetClass);
7570        if (packageName != null && className != null) {
7571            intent.setComponent(new ComponentName(packageName, className));
7572        }
7573
7574        sa.recycle();
7575
7576        int outerDepth = parser.getDepth();
7577        int type;
7578        while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
7579               && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
7580            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
7581                continue;
7582            }
7583
7584            String nodeName = parser.getName();
7585            if (nodeName.equals(TAG_CATEGORIES)) {
7586                sa = resources.obtainAttributes(attrs,
7587                        com.android.internal.R.styleable.IntentCategory);
7588                String cat = sa.getString(com.android.internal.R.styleable.IntentCategory_name);
7589                sa.recycle();
7590
7591                if (cat != null) {
7592                    intent.addCategory(cat);
7593                }
7594                XmlUtils.skipCurrentTag(parser);
7595
7596            } else if (nodeName.equals(TAG_EXTRA)) {
7597                if (intent.mExtras == null) {
7598                    intent.mExtras = new Bundle();
7599                }
7600                resources.parseBundleExtra(TAG_EXTRA, attrs, intent.mExtras);
7601                XmlUtils.skipCurrentTag(parser);
7602
7603            } else {
7604                XmlUtils.skipCurrentTag(parser);
7605            }
7606        }
7607
7608        return intent;
7609    }
7610
7611    /** @hide */
7612    public void saveToXml(XmlSerializer out) throws IOException {
7613        if (mAction != null) {
7614            out.attribute(null, ATTR_ACTION, mAction);
7615        }
7616        if (mData != null) {
7617            out.attribute(null, ATTR_DATA, mData.toString());
7618        }
7619        if (mType != null) {
7620            out.attribute(null, ATTR_TYPE, mType);
7621        }
7622        if (mComponent != null) {
7623            out.attribute(null, ATTR_COMPONENT, mComponent.flattenToShortString());
7624        }
7625        out.attribute(null, ATTR_FLAGS, Integer.toHexString(getFlags()));
7626
7627        if (mCategories != null) {
7628            out.startTag(null, TAG_CATEGORIES);
7629            for (int categoryNdx = mCategories.size() - 1; categoryNdx >= 0; --categoryNdx) {
7630                out.attribute(null, ATTR_CATEGORY, mCategories.valueAt(categoryNdx));
7631            }
7632            out.endTag(null, TAG_CATEGORIES);
7633        }
7634    }
7635
7636    /** @hide */
7637    public static Intent restoreFromXml(XmlPullParser in) throws IOException,
7638            XmlPullParserException {
7639        Intent intent = new Intent();
7640        final int outerDepth = in.getDepth();
7641
7642        int attrCount = in.getAttributeCount();
7643        for (int attrNdx = attrCount - 1; attrNdx >= 0; --attrNdx) {
7644            final String attrName = in.getAttributeName(attrNdx);
7645            final String attrValue = in.getAttributeValue(attrNdx);
7646            if (ATTR_ACTION.equals(attrName)) {
7647                intent.setAction(attrValue);
7648            } else if (ATTR_DATA.equals(attrName)) {
7649                intent.setData(Uri.parse(attrValue));
7650            } else if (ATTR_TYPE.equals(attrName)) {
7651                intent.setType(attrValue);
7652            } else if (ATTR_COMPONENT.equals(attrName)) {
7653                intent.setComponent(ComponentName.unflattenFromString(attrValue));
7654            } else if (ATTR_FLAGS.equals(attrName)) {
7655                intent.setFlags(Integer.valueOf(attrValue, 16));
7656            } else {
7657                Log.e("Intent", "restoreFromXml: unknown attribute=" + attrName);
7658            }
7659        }
7660
7661        int event;
7662        String name;
7663        while (((event = in.next()) != XmlPullParser.END_DOCUMENT) &&
7664                (event != XmlPullParser.END_TAG || in.getDepth() < outerDepth)) {
7665            if (event == XmlPullParser.START_TAG) {
7666                name = in.getName();
7667                if (TAG_CATEGORIES.equals(name)) {
7668                    attrCount = in.getAttributeCount();
7669                    for (int attrNdx = attrCount - 1; attrNdx >= 0; --attrNdx) {
7670                        intent.addCategory(in.getAttributeValue(attrNdx));
7671                    }
7672                } else {
7673                    Log.w("Intent", "restoreFromXml: unknown name=" + name);
7674                    XmlUtils.skipCurrentTag(in);
7675                }
7676            }
7677        }
7678
7679        return intent;
7680    }
7681
7682    /**
7683     * Normalize a MIME data type.
7684     *
7685     * <p>A normalized MIME type has white-space trimmed,
7686     * content-type parameters removed, and is lower-case.
7687     * This aligns the type with Android best practices for
7688     * intent filtering.
7689     *
7690     * <p>For example, "text/plain; charset=utf-8" becomes "text/plain".
7691     * "text/x-vCard" becomes "text/x-vcard".
7692     *
7693     * <p>All MIME types received from outside Android (such as user input,
7694     * or external sources like Bluetooth, NFC, or the Internet) should
7695     * be normalized before they are used to create an Intent.
7696     *
7697     * @param type MIME data type to normalize
7698     * @return normalized MIME data type, or null if the input was null
7699     * @see #setType
7700     * @see #setTypeAndNormalize
7701     */
7702    public static String normalizeMimeType(String type) {
7703        if (type == null) {
7704            return null;
7705        }
7706
7707        type = type.trim().toLowerCase(Locale.ROOT);
7708
7709        final int semicolonIndex = type.indexOf(';');
7710        if (semicolonIndex != -1) {
7711            type = type.substring(0, semicolonIndex);
7712        }
7713        return type;
7714    }
7715
7716    /**
7717     * Prepare this {@link Intent} to leave an app process.
7718     *
7719     * @hide
7720     */
7721    public void prepareToLeaveProcess() {
7722        setAllowFds(false);
7723
7724        if (mSelector != null) {
7725            mSelector.prepareToLeaveProcess();
7726        }
7727        if (mClipData != null) {
7728            mClipData.prepareToLeaveProcess();
7729        }
7730
7731        if (mData != null && StrictMode.vmFileUriExposureEnabled()) {
7732            // There are several ACTION_MEDIA_* broadcasts that send file://
7733            // Uris, so only check common actions.
7734            if (ACTION_VIEW.equals(mAction) ||
7735                    ACTION_EDIT.equals(mAction) ||
7736                    ACTION_ATTACH_DATA.equals(mAction)) {
7737                mData.checkFileUriExposed("Intent.getData()");
7738            }
7739        }
7740    }
7741
7742    /**
7743     * @hide
7744     */
7745    public void prepareToEnterProcess() {
7746        if (mContentUserHint != UserHandle.USER_CURRENT) {
7747            if (UserHandle.getAppId(Process.myUid()) != Process.SYSTEM_UID) {
7748                fixUris(mContentUserHint);
7749                mContentUserHint = UserHandle.USER_CURRENT;
7750            }
7751        }
7752    }
7753
7754    /**
7755     * @hide
7756     */
7757     public void fixUris(int contentUserHint) {
7758        Uri data = getData();
7759        if (data != null) {
7760            mData = maybeAddUserId(data, contentUserHint);
7761        }
7762        if (mClipData != null) {
7763            mClipData.fixUris(contentUserHint);
7764        }
7765        String action = getAction();
7766        if (ACTION_SEND.equals(action)) {
7767            final Uri stream = getParcelableExtra(EXTRA_STREAM);
7768            if (stream != null) {
7769                putExtra(EXTRA_STREAM, maybeAddUserId(stream, contentUserHint));
7770            }
7771        } else if (ACTION_SEND_MULTIPLE.equals(action)) {
7772            final ArrayList<Uri> streams = getParcelableArrayListExtra(EXTRA_STREAM);
7773            if (streams != null) {
7774                ArrayList<Uri> newStreams = new ArrayList<Uri>();
7775                for (int i = 0; i < streams.size(); i++) {
7776                    newStreams.add(maybeAddUserId(streams.get(i), contentUserHint));
7777                }
7778                putParcelableArrayListExtra(EXTRA_STREAM, newStreams);
7779            }
7780        } else if (MediaStore.ACTION_IMAGE_CAPTURE.equals(action)
7781                || MediaStore.ACTION_IMAGE_CAPTURE_SECURE.equals(action)
7782                || MediaStore.ACTION_VIDEO_CAPTURE.equals(action)) {
7783            final Uri output = getParcelableExtra(MediaStore.EXTRA_OUTPUT);
7784            if (output != null) {
7785                putExtra(MediaStore.EXTRA_OUTPUT, maybeAddUserId(output, contentUserHint));
7786            }
7787        }
7788     }
7789
7790    /**
7791     * Migrate any {@link #EXTRA_STREAM} in {@link #ACTION_SEND} and
7792     * {@link #ACTION_SEND_MULTIPLE} to {@link ClipData}. Also inspects nested
7793     * intents in {@link #ACTION_CHOOSER}.
7794     *
7795     * @return Whether any contents were migrated.
7796     * @hide
7797     */
7798    public boolean migrateExtraStreamToClipData() {
7799        // Refuse to touch if extras already parcelled
7800        if (mExtras != null && mExtras.isParcelled()) return false;
7801
7802        // Bail when someone already gave us ClipData
7803        if (getClipData() != null) return false;
7804
7805        final String action = getAction();
7806        if (ACTION_CHOOSER.equals(action)) {
7807            // Inspect contained intents to see if we need to migrate extras. We
7808            // don't promote ClipData to the parent, since ChooserActivity will
7809            // already start the picked item as the caller, and we can't combine
7810            // the flags in a safe way.
7811
7812            boolean migrated = false;
7813            try {
7814                final Intent intent = getParcelableExtra(EXTRA_INTENT);
7815                if (intent != null) {
7816                    migrated |= intent.migrateExtraStreamToClipData();
7817                }
7818            } catch (ClassCastException e) {
7819            }
7820            try {
7821                final Parcelable[] intents = getParcelableArrayExtra(EXTRA_INITIAL_INTENTS);
7822                if (intents != null) {
7823                    for (int i = 0; i < intents.length; i++) {
7824                        final Intent intent = (Intent) intents[i];
7825                        if (intent != null) {
7826                            migrated |= intent.migrateExtraStreamToClipData();
7827                        }
7828                    }
7829                }
7830            } catch (ClassCastException e) {
7831            }
7832            return migrated;
7833
7834        } else if (ACTION_SEND.equals(action)) {
7835            try {
7836                final Uri stream = getParcelableExtra(EXTRA_STREAM);
7837                final CharSequence text = getCharSequenceExtra(EXTRA_TEXT);
7838                final String htmlText = getStringExtra(EXTRA_HTML_TEXT);
7839                if (stream != null || text != null || htmlText != null) {
7840                    final ClipData clipData = new ClipData(
7841                            null, new String[] { getType() },
7842                            new ClipData.Item(text, htmlText, null, stream));
7843                    setClipData(clipData);
7844                    addFlags(FLAG_GRANT_READ_URI_PERMISSION);
7845                    return true;
7846                }
7847            } catch (ClassCastException e) {
7848            }
7849
7850        } else if (ACTION_SEND_MULTIPLE.equals(action)) {
7851            try {
7852                final ArrayList<Uri> streams = getParcelableArrayListExtra(EXTRA_STREAM);
7853                final ArrayList<CharSequence> texts = getCharSequenceArrayListExtra(EXTRA_TEXT);
7854                final ArrayList<String> htmlTexts = getStringArrayListExtra(EXTRA_HTML_TEXT);
7855                int num = -1;
7856                if (streams != null) {
7857                    num = streams.size();
7858                }
7859                if (texts != null) {
7860                    if (num >= 0 && num != texts.size()) {
7861                        // Wha...!  F- you.
7862                        return false;
7863                    }
7864                    num = texts.size();
7865                }
7866                if (htmlTexts != null) {
7867                    if (num >= 0 && num != htmlTexts.size()) {
7868                        // Wha...!  F- you.
7869                        return false;
7870                    }
7871                    num = htmlTexts.size();
7872                }
7873                if (num > 0) {
7874                    final ClipData clipData = new ClipData(
7875                            null, new String[] { getType() },
7876                            makeClipItem(streams, texts, htmlTexts, 0));
7877
7878                    for (int i = 1; i < num; i++) {
7879                        clipData.addItem(makeClipItem(streams, texts, htmlTexts, i));
7880                    }
7881
7882                    setClipData(clipData);
7883                    addFlags(FLAG_GRANT_READ_URI_PERMISSION);
7884                    return true;
7885                }
7886            } catch (ClassCastException e) {
7887            }
7888        } else if (MediaStore.ACTION_IMAGE_CAPTURE.equals(action)
7889                || MediaStore.ACTION_IMAGE_CAPTURE_SECURE.equals(action)
7890                || MediaStore.ACTION_VIDEO_CAPTURE.equals(action)) {
7891            final Uri output;
7892            try {
7893                output = getParcelableExtra(MediaStore.EXTRA_OUTPUT);
7894            } catch (ClassCastException e) {
7895                return false;
7896            }
7897            if (output != null) {
7898                setClipData(ClipData.newRawUri("", output));
7899                addFlags(FLAG_GRANT_WRITE_URI_PERMISSION|FLAG_GRANT_READ_URI_PERMISSION);
7900                return true;
7901            }
7902        }
7903
7904        return false;
7905    }
7906
7907    private static ClipData.Item makeClipItem(ArrayList<Uri> streams, ArrayList<CharSequence> texts,
7908            ArrayList<String> htmlTexts, int which) {
7909        Uri uri = streams != null ? streams.get(which) : null;
7910        CharSequence text = texts != null ? texts.get(which) : null;
7911        String htmlText = htmlTexts != null ? htmlTexts.get(which) : null;
7912        return new ClipData.Item(text, htmlText, null, uri);
7913    }
7914
7915    /** @hide */
7916    public boolean isDocument() {
7917        return (mFlags & FLAG_ACTIVITY_NEW_DOCUMENT) == FLAG_ACTIVITY_NEW_DOCUMENT;
7918    }
7919}
7920