"Android开发资料（一）：简介和关键特性"

版权申诉

95 浏览量更新于2024-04-06 收藏 958KB DOC 举报

Android is a powerful software stack designed specifically for mobile devices, offering an operating system, middleware, and key applications. The Android SDK, which stands for Software Development Kit, provides developers with the necessary tools and APIs to create applications on the Android platform using the popular Java programming language. One of the key features of Android is its application framework, which allows for the reuse and replacement of components, making it easier for developers to build and customize their apps. The platform also utilizes the Dalvik virtual machine, which is optimized for mobile devices, ensuring smooth performance and efficient resource management. Another standout feature of Android is its integrated browser, which is built on the open-source WebKit engine. This browser provides users with a seamless and responsive web browsing experience, allowing them to access online content with ease. Additionally, Android boasts optimized graphics capabilities, powered by a cutting-edge graphics processing unit (GPU), enabling stunning visuals and smooth animations in apps and games. Overall, Android offers a comprehensive and flexible platform for mobile app development, with a wide range of tools and features that empower developers to create innovative and engaging applications. Whether you are a beginner or an experienced developer, Android provides the resources and support needed to bring your ideas to life and reach a global audience of mobile users. With its vibrant ecosystem and ongoing updates, Android continues to lead the way in mobile technology, shaping the future of mobile development and innovation.

stack. The root activity in the stack is the one that began the task — typically, it's an activity the

user selected in the application launcher. The activity at the top of the stack is one that's

currently running — the one that is the focus for user actions. When one activity starts another,

the new activity is pushed on the stack; it becomes the running activity. The previous activity

remains in the stack. When the user presses the BACK key, the current activity is popped from

the stack, and the previous one resumes as the running activity.

The stack contains objects, so if a task has more than one instance of the same Activity

subclass open — multiple map viewers, for example — the stack has a separate entry for each

instance. Activities in the stack are never rearranged, only pushed and popped.

A task is a stack of activities, not a class or an element in the manifest file. So there's no way to

set values for a task independently of its activities. Values for the task as a whole are set in the

root activity. For example, the next section will talk about the "affinity of a task"; that value is

read from the affinity set for the task's root activity.

All the activities in a task move together as a unit. The entire task (the entire activity stack) can

be brought to the foreground or sent to the background. Suppose, for instance, that the current

task has four activities in its stack — three under the current activity. The user presses the

HOME key, goes to the application launcher, and selects a new application (actually, a new

task). The current task goes into the background and the root activity for the new task is

displayed. Then, after a short period, the user goes back to the home screen and again selects

the previous application (the previous task). That task, with all four activities in the stack,

comes forward. When the user presses the BACK key, the screen does not display the activity

the user just left (the root activity of the previous task). Rather, the activity on the top of the

stack is removed and the previous activity in the same task is displayed.

The behavior just described is the default behavior for activities and tasks. But there are ways

to modify almost all aspects of it. The association of activities with tasks, and the behavior of

an activity within a task, is controlled by the interaction between flags set in the Intent object

that started the activity and attributes set in the activity's <activity> element in the

manifest. Both requester and respondent have a say in what happens.

In this regard, the principal Intent flags are:

FLAG_ACTIVITY_NEW_TASK

FLAG_ACTIVITY_CLEAR_TOP

FLAG_ACTIVITY_RESET_TASK_IF_NEEDED

FLAG_ACTIVITY_SINGLE_TOP

The principal <activity> attributes are:

taskAffinity

launchMode

allowTaskReparenting

clearTaskOnLaunch

alwaysRetainTaskState

finishOnTaskLaunch

The following sections describe what some of these flags and attributes do, how they interact,

and what considerations should govern their use.

Affinities and new tasks

By default, all the activities in an application have an affinity for each other — that is, there's a

preference for them all to belong to the same task. However, an individual affinity can be set

for each activity with the taskAffinity attribute of the <activity> element.

Activities defined in different applications can share an affinity, or activities defined in the same

application can be assigned different affinities. The affinity comes into play in two

circumstances: When the Intent object that launches an activity contains the

FLAG_ACTIVITY_NEW_TASK flag, and when an activity has its

allowTaskReparenting attribute set to "true".

The FLAG_ACTIVITY_NEW_TASK flag

As described earlier, a new activity is, by default, launched into the task of the activity

that called startActivity(). It's pushed onto the same stack as the caller.

However, if the Intent object passed to startActivity() contains the

FLAG_ACTIVITY_NEW_TASK flag, the system looks for a different task to house

the new activity. Often, as the name of the flag implies, it's a new task. However, it

doesn't have to be. If there's already an existing task with the same affinity as the new

activity, the activity is launched into that task. If not, it begins a new task.

The allowTaskReparenting attribute

If an activity has its allowTaskReparenting attribute set to "true", it can

move from the task it starts in to the task it has an affinity for when that task comes to

the fore. For example, suppose that an activity that reports weather conditions in

selected cities is defined as part of a travel application. It has the same affinity as other

activities in the same application (the default affinity) and it allows reparenting. One of

your activities starts the weather reporter, so it initially belongs to the same task as

your activity. However, when the travel application next comes forward, the weather

reporter will be reassigned to and displayed with that task.

If an .apk file contains more than one "application" from the user's point of view, you will

probably want to assign different affinities to the activities associated with each of them.

Launch modes

There are four different launch modes that can be assigned to an <activity> element's

launchMode attribute:

"standard" (the default mode)

"singleTop"

"singleTask"

"singleInstance"

The modes differ from each other on these four points:

� Which task will hold the activity that responds to the intent. For the

"standard" and "singleTop" modes, it's the task that originated the intent (and called

startActivity()) — unless the Intent object contains the FLAG_ACTIVITY_NEW_TASK

flag. In that case, a different task is chosen as described in the previous section, Affinities and

new tasks.

In contrast, the "singleTask" and "singleInstance" modes mark activities that are

always at the root of a task. They define a task; they're never launched into another task.

� Whether there can be multiple instances of the activity. A "standard" or

"singleTop" activity can be instantiated many times. They can belong to multiple tasks,

and a given task can have multiple instances of the same activity.

In contrast, "singleTask" and "singleInstance" activities are limited to just one

instance. Since these activities are at the root of a task, this limitation means that there is

never more than a single instance of the task on the device at one time.

� Whether the instance can have other activities in its task. A

"singleInstance" activity stands alone as the only activity in its task. If it starts another

activity, that activity will be launched into a different task regardless of its launch mode — as if

FLAG_ACTIVITY_NEW_TASK was in the intent. In all other respects, the

"singleInstance" mode is identical to "singleTask".

The other three modes permit multiple activities to belong to the task. A "singleTask"

activity will always be the root activity of the task, but it can start other activities that will be

assigned to its task. Instances of "standard" and "singleTop" activities can appear

anywhere in a stack.

� Whether a new instance of the class will be launched to handle a new intent. For

the default "standard" mode, a new instance is created to respond to every new intent.

Each instance handles just one intent. For the "singleTop" mode, an existing instance of

the class is re-used to handle a new intent if it resides at the top of the activity stack of the

target task. If it does not reside at the top, it is not re-used. Instead, a new instance is created

for the new intent and pushed on the stack.

For example, suppose a task's activity stack consists of root activity A with activities B, C, and

D on top in that order, so the stack is A-B-C-D. An intent arrives for an activity of type D. If D

has the default "standard" launch mode, a new instance of the class is launched and the

stack becomes A-B-C-D-D. However, if D's launch mode is "singleTop", the existing

instance is expected to handle the new intent (since it's at the top of the stack) and the stack

剩余69页未读，继续阅读

老帽爬新坡

粉丝: 93
资源: 2万+

"Android开发资料（一）：简介和关键特性"

android开发资料1

Android开发资料

Android开发入门.doc

Android开发环境搭建.doc - 博客.doc

android开发环境搭建.doc

Android开发以及教程.doc

android开发环境安装.doc

Android开发教程入门.doc

Android开发简单教程.doc

android开发关键技术.doc

最新资源