Three of the core components of an application — activities, services, and
broadcast receivers — are activated through messages, called intents.
Intent messaging is a facility for late run-time binding between components in the same
or different applications. The intent itself, an Intent
object, is a passive data structure holding an abstract description of an operation
to be performed — or, in the case of broadcasts, a description of something
that has happened and is being announced. There are separate mechanisms for
delivering intents to each type of component:
In each case, the Android system finds the appropriate activity, service, or set
of broadcast receivers to respond to the intent, instantiating them if necessary.
There is no overlap within these messaging systems: Broadcast intents are delivered
only to broadcast receivers, never to activities or services. An intent passed to
startActivity() is delivered only to an activity, never to a service or
broadcast receiver, and so on.
This document begins with a description of Intent objects. It then describes the
rules Android uses to map intents to components — how it resolves which
component should receive an intent message. For intents that don't explicitly
name a target component, this process involves testing the Intent object against
intent filters associated with potential targets.
An Intent object is a bundle of information. It
contains information of interest to the component that receives the intent
(such as the action to be taken and the data to act on) plus information
of interest to the Android system (such as the category of component that
should handle the intent and instructions on how to launch a target activity).
Principally, it can contain the following:
- Component name
- The name of the component that should handle the intent. This field is
a ComponentName object — a combination of the
fully qualified class name of the target component (for example "
com.example.project.app.FreneticActivity") and the package name set
in the manifest file of the application where the component resides (for
com.example.project"). The package part of the component
name and the package name set in the manifest do not necessarily have to match.
The component name is optional. If it is set, the Intent object is
delivered to an instance of the designated class. If it is not set,
Android uses other information in the Intent object to locate a suitable
target — see
Intent Resolution, later in this
The component name is set by
setClassName() and read by
- A string naming the action to be performed — or, in the case of broadcast
intents, the action that took place and is being reported. The Intent class defines
a number of action constants, including these:
|Initiate a phone call.
|Display data for the user to edit.
|Start up as the initial activity of a task, with no data input and no returned output.
|Synchronize data on a server with data on the mobile device.
|A warning that the battery is low.
|A headset has been plugged into the device, or unplugged from it.
|The screen has been turned on.
|The setting for the time zone has changed.
See the Intent class description for a list of
pre-defined constants for generic actions. Other actions are defined
elsewhere in the Android API.
You can also define your own action strings for activating the components
in your application. Those you invent should include the application
package as a prefix — for example:
The action largely determines how the rest of the intent is structured
— particularly the
extras fields —
much as a method name determines a set of arguments and a return value.
For this reason, it's a good idea to use action names that are
as specific as possible, and to couple them tightly to the other fields of
the intent. In other words, instead of defining an action in isolation,
define an entire protocol for the Intent objects your components can handle.
The action in an Intent object is set by the
method and read by
- The URI of the data to be acted on and the MIME type of that data. Different
actions are paired with different kinds of data specifications. For example, if
the action field is
the data field would contain the URI of the document to be displayed for editing.
If the action is
ACTION_CALL, the data field would be a
with the number to call. Similarly, if the action is
ACTION_VIEW and the
data field is an
https: URI, the receiving activity would be called upon
to download and display whatever data the URI refers to.
When matching an intent to a component that is capable of handling the data,
it's often important to know the type of data (its MIME type) in addition to its URI.
For example, a component able to display image data should not be called
upon to play an audio file.
In many cases, the data type can be inferred from the URI — particularly
content: URIs, which indicate that the data is located on the device and
controlled by a content provider (see the
discussion on content providers). But the type can also be explicitly set
in the Intent object.
setData() method specifies
data only as a URI,
specifies it only as a MIME type, and
setDataAndType() specifies it as both
a URI and a MIME type. The URI is read by
getData() and the type by
- A string containing additional information about the kind of component
that should handle the intent. Any number of category descriptions can be
placed in an Intent object. As it does for actions, the Intent class defines
several category constants, including these:
|The target activity can be safely invoked by the browser to display data
referenced by a link — for example, an image or an e-mail message.
|The activity can be embedded inside of another activity that hosts gadgets.
|The activity displays the home screen, the first screen the user sees when
the device is turned on or when the HOME key is pressed.
|The activity can be the initial activity of a task and is listed in
the top-level application launcher.
|The target activity is a preference panel.
See the Intent class description for the full list of
places a category in an Intent object,
removeCategory() deletes a category previously added, and
getCategories() gets the set of all
categories currently in the object.
- Key-value pairs for additional information that should be delivered to the
component handling the intent. Just as some actions are paired with particular
kinds of data URIs, some are paired with particular extras. For example, an
ACTION_TIMEZONE_CHANGED intent has a "
time-zone" extra that
identifies the new time zone, and
ACTION_HEADSET_PLUG has a
state" extra indicating whether the headset is now plugged in or
unplugged, as well as a "
name" extra for the type of headset.
If you were to invent a
SHOW_COLOR action, the color value would
be set in an extra key-value pair.
The Intent object has a series of
put...() methods for inserting various
types of extra data and a similar set of
get...() methods for reading
the data. These methods parallel those for Bundle objects.
In fact, the extras can be installed and read as a Bundle using the
- Flags of various sorts. Many instruct the Android system how to launch an
activity (for example, which task the activity should belong to) and how to treat
it after it's launched (for example, whether it belongs in the list of recent
activities). All these flags are defined in the Intent class.
The Android system and the applications that come with the platform employ
Intent objects both to send out system-originated broadcasts and to activate
system-defined components. To see how to structure an intent to activate a
system component, consult the
list of intents
in the reference.
Intents can be divided into two groups:
Android delivers an explicit intent to an instance of the designated
target class. Nothing in the Intent object other than the component
name matters for determining which component should get the intent.
A different strategy is needed for implicit intents. In the absence of a
designated target, the Android system must find the best component (or
components) to handle the intent — a single activity or service to
perform the requested action or the set of broadcast receivers to respond
to the broadcast announcement. It does so by comparing the contents of
the Intent object to intent filters, structures associated with
components that can potentially receive intents. Filters advertise the
capabilities of a component and delimit the intents it can handle. They
open the component to the possibility of receiving implicit intents of
the advertised type. If a component does not have any intent filters,
it can receive only explicit intents. A component with filters can
receive both explicit and implicit intents.
Only three aspects of an Intent object are consulted when the object
is tested against an intent filter:
data (both URI and data type)
The extras and flags play no part in resolving which component receives
To inform the system which implicit intents they can handle, activities,
services, and broadcast receivers can have one or more intent filters.
Each filter describes a capability of the component, a set of intents that
the component is willing to receive. It, in effect, filters in
intents of a desired type, while filtering out unwanted
intents — but only unwanted implicit intents (those that don't name
a target class). An explicit intent is always delivered to its target,
no matter what it contains; the filter is not consulted. But an implicit
intent is delivered to a component only if it can pass through one of the
A component has separate filters for each job it can do, each face it can
present to the user. For example, the principal activity of the sample
NotePad application has three filters — one for starting up with a
blank slate, another for starting with an assigned directory of notes
that the user can view, edit, or select from, and a third for finding a
particular note without an initial specification of its directory.
An intent filter is an instance of the IntentFilter class.
However, since the Android system must know about the capabilities of a component
before it can launch that component, intent filters are generally not set up in
Java code, but in the application's manifest file (AndroidManifest.xml) as
<intent-filter> elements. (The one exception would be filters for
broadcast receivers that are registered dynamically by calling
Context.registerReceiver(); they are directly created as
Filters and security
An intent filter cannot be relied on for security. While it opens a
component to receiving only certain kinds of implicit intents, it does
nothing to prevent explicit intents from targeting the component. Even
though a filter restricts the intents a component will be asked to handle
to certain actions and data sources, someone could always put
together an explicit intent with a different action and data source, and
name the component as the target.
A filter has fields that parallel the action, data, and category fields of an
Intent object. An implicit intent is tested against the filter in all three areas.
To be delivered to the component that owns the filter, it must pass all three tests.
If it fails even one of them, the Android system won't deliver it to the
component — at least not on the basis of that filter. However, since a
component can have multiple intent filters, an intent that does not pass
through one of a component's filters might make it through on another.
Each of the three tests is described in detail below:
- Action test
<intent-filter> element in the manifest file lists actions
<action> subelements. For example:
<intent-filter . . . >
<action android:name="com.example.project.SHOW_CURRENT" />
<action android:name="com.example.project.SHOW_RECENT" />
<action android:name="com.example.project.SHOW_PENDING" />
. . .
As the example shows, while an Intent object names just a single action,
a filter may list more than one. The list cannot be empty; a filter must
contain at least one
<action> element, or it
will block all intents.
To pass this test, the action specified in the Intent object must match
one of the actions listed in the filter. If the object or the filter
does not specify an action, the results are as follows:
- Category test
<intent-filter> element also lists categories as subelements.
<intent-filter . . . >
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
. . .
Note that the constants described earlier for actions and categories are not
used in the manifest file. The full string values are used instead. For
instance, the "
android.intent.category.BROWSABLE" string in the example
above corresponds to the
CATEGORY_BROWSABLE constant mentioned earlier
in this document. Similarly, the string "
corresponds to the
For an intent to pass the category test, every category in the Intent object
must match a category in the filter. The filter can list additional categories,
but it cannot omit any that are in the intent.
In principle, therefore, an Intent object with no categories should always pass
this test, regardless of what's in the filter. That's mostly true. However,
with one exception, Android treats all implicit intents passed to startActivity() as if they contained
at least one category: "
Therefore, activities that are willing to receive implicit intents must
android.intent.category.DEFAULT" in their intent filters.
(Filters with "
android.intent.category.LAUNCHER" settings are the exception.
They mark activities that begin new tasks and that are represented on the
launcher screen. They can include "
in the list of categories, but don't need to.) See
intent matching, later, for more on these filters.)
- Data test
- Like the action and categories, the data specification for an intent filter
is contained in a subelement. And, as in those cases, the subelement can appear
multiple times, or not at all. For example:
<intent-filter . . . >
<data android:type="video/mpeg" android:scheme="http" . . . />
<data android:type="audio/mpeg" android:scheme="http" . . . />
. . .
<data> element can specify a URI and a data type (MIME media type).
There are separate attributes —
path — for each part of the URI:
For example, in the following URI,
the scheme is "
content", the host is "
the port is "
200", and the path is "
The host and port together constitute the URI authority; if a host is
not specified, the port is ignored.
Each of these attributes is optional, but they are not independent of each other:
For an authority to be meaningful, a scheme must also be specified.
For a path to be meaningful, both a scheme and an authority must be specified.
When the URI in an Intent object is compared to a URI specification in a filter,
it's compared only to the parts of the URI actually mentioned in the filter.
For example, if a filter specifies only a scheme, all URIs with that scheme match
the filter. If a filter specifies a scheme and an authority but no path, all URIs
with the same scheme and authority match, regardless of their paths. If a filter
specifies a scheme, an authority, and a path, only URIs with the same scheme,
authority, and path match. However, a path specification in the filter can
contain wildcards to require only a partial match of the path.
type attribute of a
<data> element specifies the MIME type
of the data. It's more common in filters than a URI. Both the Intent object and
the filter can use a "*" wildcard for the subtype field — for example,
text/*" or "
audio/*" — indicating any subtype matches.
The data test compares both the URI and the data type in the Intent object to a URI
and data type specified in the filter. The rules are as follows:
- An Intent object that contains neither a URI nor a data type passes the
test only if the filter likewise does not specify any URIs or data types.
An Intent object that contains a URI but no data type (and a type cannot
be inferred from the URI) passes the test only if its URI matches a URI in the
filter and the filter likewise does not specify a type. This will be the case
only for URIs like
tel: that do not refer to actual data.
An Intent object that contains a data type but not a URI passes the test
only if the filter lists the same data type and similarly does not specify a URI.
An Intent object that contains both a URI and a data type (or a data type
can be inferred from the URI) passes the data type part of the test only if its
type matches a type listed in the filter. It passes the URI part of the test
either if its URI matches a URI in the filter or if it has a
file: URI and the filter does not specify a URI. In other words,
a component is presumed to support
file: data if
its filter lists only a data type.
If an intent can pass through the filters of more than one activity or service,
the user may be asked which component to activate. An exception is raised if
no target can be found.
The last rule shown above for the data test, rule (d), reflects the expectation
that components are able to get local data from a file or content provider.
Therefore, their filters can list just a data type and do not need to explicitly
This is a typical case. A
<data> element like the following,
for example, tells Android that the component can get image data from a content
provider and display it:
<data android:type="image/*" />
Since most available data is dispensed by content providers, filters that
specify a data type but not a URI are perhaps the most common.
Another common configuration is filters with a scheme and a data type. For
<data> element like the following tells Android that
the component can get video data from the network and display it:
<data android:scheme="http" android:type="video/*" />
Consider, for example, what the browser application does when
the user follows a link on a web page. It first tries to display the data
(as it could if the link was to an HTML page). If it can't display the data,
it puts together an implicit intent with the scheme and data type and tries
to start an activity that can do the job. If there are no takers, it asks the
download manager to download the data. That puts it under the control
of a content provider, so a potentially larger pool of activities
(those with filters that just name a data type) can respond.
Most applications also have a way to start fresh, without a reference
to any particular data. Activities that can initiate applications
have filters with "
android.intent.action.MAIN" specified as
the action. If they are to be represented in the application launcher,
they also specify the "
<intent-filter . . . >
<action android:name="code android.intent.action.MAIN" />
<category android:name="code android.intent.category.LAUNCHER" />
Using intent matching
Intents are matched against intent filters not only to discover a target
component to activate, but also to discover something about the set of
components on the device. For example, the Android system populates the
application launcher, the top-level screen that shows the applications
that are available for the user to launch, by finding all the activities
with intent filters that specify the "
action and "
(as illustrated in the previous section). It then displays the icons and
labels of those activities in the launcher. Similarly, it discovers the
home screen by looking for the activity with
android.intent.category.HOME" in its filter.
Your application can use intent matching is a similar way.
The PackageManager has a set of
methods that return all components that can accept a particular intent, and
a similar series of
resolve...() methods that determine the best
component to respond to an intent. For example,
queryIntentActivities() returns a list of all activities that can perform
the intent passed as an argument, and queryIntentServices() returns a similar list of services.
Neither method activates the components; they just list the ones that
can respond. There's a similar method,
queryBroadcastReceivers(), for broadcast receivers.