Android开发者入门指南：工具与API详解

需积分: 10 2 浏览量更新于2024-07-21 收藏 24.1MB PDF 举报

"Android Developer Guide" 是一份全面的开发指南，针对Android平台提供了详尽的教程和资源。这份PDF文件旨在帮助Android开发者深入理解并掌握Android技术。Android是一个专为移动设备设计的软件堆栈，包括操作系统、中间件和核心应用程序，其基础是Java编程语言。 1. **Android定义**: Android不仅仅是一个操作系统，它是一个完整的平台，包含了一套用于构建应用程序的框架，允许开发者复用和替换组件，提高了代码的可重用性和灵活性。 2. **Android SDK**: Android Software Development Kit (SDK) 提供了开发工具和API集，是开发者进行Android应用开发的关键。通过这个工具包，开发者可以利用Java语言来构建功能丰富的应用，包括但不限于 Dalvik虚拟机，这是一个专为移动设备优化的轻量级运行时环境。 3. **特性亮点**: - **应用程序框架**：支持组件化开发，使开发者可以轻松地构建模块化的应用结构。 - ** Dalvik虚拟机**：采用特殊的优化，适合资源受限的移动设备，支持硬件加速。 - **内置浏览器**：基于开源的WebKit引擎，提供网页浏览功能。 - **图形处理**：定制的2D图形库，以及基于OpenGL ES 1.0的3D图形支持（硬件加速选项可选）。 - **数据库支持**：SQLite用于结构化数据存储，简化数据管理。 - **多媒体支持**：涵盖常见的音频（如MP3、AAC）、视频（MPEG4、H.264）、图片（JPG、PNG、GIF）格式。 - **通信功能**：包括GSM电话功能（取决于硬件），以及蓝牙、EDGE、3G和Wi-Fi网络连接。 - **硬件接口**：相机、GPS、指南针和加速度计等传感器，依赖于设备硬件支持。 4. **开发环境**: Android提供了强大的开发环境，包括设备模拟器，用于在没有实际设备的情况下测试应用；调试工具，帮助开发者查找和修复问题；内存和性能分析工具，确保应用的高效运行。总结起来，这份"Android Developer Guide" 是一个宝贵的资源，涵盖了Android开发的方方面面，无论是初学者还是经验丰富的开发者，都可以从中找到所需的信息，提升他们的Android应用开发技能。

29.04.09 0:33Application Fundamentals | Android Developers

Page 13 of 19http://developer.android.com/guide/topics/fundamentals.html

The following table describes each of these methods in more detail and locates it within the activity's overall lifecycle:

Method Description Killable? Next

onCreate() Called when the activity is first

created. This is where you

should do all of your normal

static set up — create views,

bind data to lists, and so on.

This method is passed a Bundle

object containing the activity's

No onStart()

29.04.09 0:33Application Fundamentals | Android Developers

Page 15 of 19http://developer.android.com/guide/topics/fundamentals.html

onDestroy() Called before the activity is

destroyed. This is the final call

that the activity will receive. It

could be called either because

the activity is finishing

(someone called finish() on

it), or because the system is

temporarily destroying this

instance of the activity to save

space. You can distinguish

between these two scenarios

with the isFinishing()

method.

Yes nothing

Note the Killable column in the table above. It indicates whether or not the system can kill the process hosting the

activity at any time after the method returns, without executing another line of the activity's code. Three methods

(onPause(), onStop(), and onDestroy()) are marked "Yes." Because onPause() is the first of the three, it's the

only one that's guaranteed to be called before the process is killed — onStop() and onDestroy() may not be.

Therefore, you should use onPause() to write any persistent data (such as user edits) to storage.

Methods that are marked "No" in the Killable column protect the process hosting the activity from being killed from the

moment they are called. Thus an activity is in a killable state, for example, from the time onPause() returns to the

time onResume() is called. It will not again be killable until onPause() again returns.

As noted in a later section, Processes and lifecycle, an activity that's not technically "killable" by this definition might

still be killed by the system — but that would happen only in extreme and dire circumstances when there is no other

recourse.

Saving activity state

When the system, rather than the user, shuts down an activity to conserve memory, the user may expect to return to

the activity and find it in its previous state.

To capture that state before the activity is killed, you can implement an onSaveInstanceState() method for the

activity. Android calls this method before making the activity vulnerable to being destroyed — that is, before

onPause() is called. It passes the method a Bundle object where you can record the dynamic state of the activity as

name-value pairs. When the activity is again started, the Bundle is passed both to onCreate() and to a method

that's called after onStart(), onRestoreInstanceState(), so that either or both of them can recreate the

captured state.

Unlike onPause() and the other methods discussed earlier, onSaveInstanceState() and

onRestoreInstanceState() are not lifecycle methods. They are not always called. For example, Android calls

onSaveInstanceState() before the activity becomes vulnerable to being destroyed by the system, but does not

bother calling it when the instance is actually being destroyed by a user action (such as pressing the BACK key). In

that case, the user won't expect to return to the activity, so there's no reason to save its state.

Because onSaveInstanceState() is not always called, you should use it only to record the transient state of the

activity, not to store persistent data. Use onPause() for that purpose instead.

Coordinating activities

When one activity starts another, they both experience lifecycle transitions. One pauses and may stop, while the other

starts up. On occasion, you may need to coordinate these activities, one with the other.

The order of lifecycle callbacks is well defined, particularly when the two activities are in the same process:

1. The current activity's onPause() method is called.

2. Next, the starting activity's onCreate(), onStart(), and onResume() methods are called in sequence.

3. Then, if the starting activity is no longer visible on screen, its onStop() method is called.

29.04.09 0:33Application Fundamentals | Android Developers

Page 16 of 19http://developer.android.com/guide/topics/fundamentals.html

Service lifecycle

A service can be used in two ways:

It can be started and allowed to run until someone stops it or it stops itself. In this mode, it's started by calling

Context.startService() and stopped by calling Context.stopService(). It can stop itself by calling

Service.stopSelf() or Service.stopSelfResult(). Only one stopService() call is needed to stop

the service, no matter how many times startService() was called.

It can be operated programmatically using an interface that it defines and exports. Clients establish a connection

to the Service object and use that connection to call into the service. The connection is established by calling

Context.bindService(), and is closed by calling Context.unbindService(). Multiple clients can bind to

the same service. If the service has not already been launched, bindService() can optionally launch it.

The two modes are not entirely separate. You can bind to a service that was started with startService(). For

example, a background music service could be started by calling startService() with an Intent object that

identifies the music to play. Only later, possibly when the user wants to exercise some control over the player or get

information about the current song, would an activity establish a connection to the service by calling bindService().

In cases like this, stopService() will not actually stop the service until the last binding is closed.

Like an activity, a service has lifecycle methods that you can implement to monitor changes in its state. But they are

fewer than the activity methods — only three — and they are public, not protected:

void onCreate()

void onStart(Intent intent)

void onDestroy()

By implementing these methods, you can monitor two nested loops of the service's lifecycle:

The entire lifetime of a service happens between the time onCreate() is called and the time onDestroy()

returns. Like an activity, a service does its initial setup in onCreate(), and releases all remaining resources in

onDestroy(). For example, a music playback service could create the thread where the music will be played in

onCreate(), and then stop the thread in onDestroy().

The active lifetime of a service begins with a call to onStart(). This method is handed the Intent object that

was passed to startService(). The music service would open the Intent to discover which music to play, and

begin the playback.

There's no equivalent callback for when the service stops — no onStop() method.

The onCreate() and onDestroy() methods are called for all services, whether they're started by

Context.startService() or Context.bindService(). However, onStart() is called only for services started

by startService().

If a service permits others to bind to it, there are additional callback methods for it to implement:

IBinder onBind(Intent intent)

boolean onUnbind(Intent intent)

void onRebind(Intent intent)

The onBind() callback is passed the Intent object that was passed to bindService and onUnbind() is handed

the intent that was passed to unbindService(). If the service permits the binding, onBind() returns the

communications channel that clients use to interact with the service. The onUnbind() method can ask for

onRebind() to be called if a new client connects to the service.

The following diagram illustrates the callback methods for a service. Although, it separates services that are created via

startService from those created by bindService(), keep in mind that any service, no matter how it's started,

can potentially allow clients to bind to it, so any service may receive onBind() and onUnbind() calls.

剩余361页未读，继续阅读

WiliamJiang

粉丝: 63
资源: 4

Android开发者入门指南：工具与API详解

Android_Developer_Guide PDF版

Android Developer Guide - In-app Billing

深入探索：Android Developer Guide 的技术精华

Capers Android pdf+ Snorkel Developer Guide pdf

Android_Developer_Guide.pdf 1

AndroidCoreApp:Android Core App是一个Android应用程序，其创建目的是为了练习在《 Associate Android Developer Study Guide》中阅读的材料。 Android核心是学习指南中的章节之一。 此应用程序将使用以下功能

Qualcomm Platform Developer Guide

Oculus Unity Developer Guide

android-guide:与 Google Developer Group Android Study Jam 配套的数字指南

Android Platform Developer‘s Guide.doc

最新资源

AndroidCoreApp:Android Core App是一个Android应用程序，其创建目的是为了练习在《 Associate Android Developer Study Guide》中阅读的材料。 Android核心是学习指南中的章节之一。此应用程序将使用以下功能