Android SDK 1.0 Chn.

 

 

 

 

 

 

from www.androidin.com

 

 

 

 

 

 

 

 

 

 

 

Android SDK 中文1.0 版本

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

目录

来源:... 4

SDK 内容... 5

什么是 Android?. 5

特性... 5

Android 架构... 5

应用程序... 6

应用程序框架... 6

程序库... 7

Android 运行库... 7

Linux 内核... 8

Android新手入门... 8

其它介绍材料... 8

安装 SDK.. 10

系统和软件需求... 10

安装 SDK.. 11

安装 Eclipse 插件 (ADT) 11

安装注意事项... 14

更新SDK.. 15

安装新的SDK.. 15

更新ADT Eclipse插件... 16

建立应用程序签名... 16

移植您的应用程序... 17

开发和调试... 17

主要内容... 18

eclipse上开发Android应用程序... 18

利用其他IDEs和工具开发Android应用程序... 20

应用程序签名... 23

使用ApiDemo示例应用程序... 25

调试... 26

设备上的调试和测试设置... 27

顶端调试技巧... 27

编译安装Anroid应用程序... 28

移出一个Android应用程序... 29

Eclipse技巧... 29

Hello, Android! 30

创建工程... 31

建立UI 34

执行代码:HelloAndroid. 36

使用XML构建UI 40

调试工程... 43

不使用Eclipse创建工程... 46

Android 应用程序构成... 47

活动... 47

广播接收器... 48

服务... 48

内容提供器... 49

教程:一个记事本应用程序范例... 49

本教程目标读者... 49

练习前的准备... 50

练习... 50

其它资源及延伸学习... 51

开发工具... 51

Android 应用程序模块: 应用, 任务, 进程, 和线程... 53

任务... 54

进程... 56

线程... 56

Android应用程序的生命周期... 57

开发Android应用程序... 59

实现一个用户接口... 60

主题... 60

Android应用构成... 60

存、取、提供数据... 62

Android的安全与权限... 62

内容... 62

安全结构... 63

应用程序签名... 63

用户标识和文件访问... 63

权限命名... 64

权限的声明和支持... 65

URI权限... 69

资源管理和多国版本... 70

资源... 71

创建资源... 71

使用资源... 73

对于不同的语言和设置支持不同的资源... 79

术语... 83

资源引用... 84

国际化和本地化... 85

 

 

 

来源:

http://www.androidin.com/

 

SDK 内容

什么是 Android?

Android 是一个专门针对移动设备的软件集,它包括一个操作系统,中间件和一些重要的应用程序。Beta版的 Android SDK 提供了在Android平台上使用JaVa语言进行Android应用开发必须的工具和API接口。

·             应用程序框架 支持组件的重用与替换

·             Dalvik 虚拟机 专为移动设备优化

·             集成的浏览器 基于开源的WebKit 引擎

·             优化的图形库 包括定制的2D图形库,3D图形库基于OpenGL ES 1.0 (硬件加速可选)

·             SQLite 用作结构化的数据存储

·             多媒体支持 包括常见的音频、视频和静态图像格式 (如 MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, GIF

·             GSM 电话技术 (依赖于硬件)

·             蓝牙Bluetooth, EDGE, 3G, WiFi (依赖于硬件)

·             照相机,GPS,指南针,和加速度计(accelerometer (依赖于硬件)

·             丰富的开发环境 包括设备模拟器,调试工具,内存及性能分析图表,和Eclipse集成开发环境插件

Android 架构

下图显示的是Android操作系统的主要组件。每一部分将会在下面具体描述。

应用程序

Android会同一系列核心应用程序包一起发布,该应用程序包包括email客户端,SMS短消息程序,日历,地图,浏览器,联系人管理程序等。所有的应用程序都是使用JAVA语言编写的。

应用程序框架

开发人员也可以完全访问核心应用程序所使用的API框架。该应用程序的架构设计简化了组件的重用;任何一个应用程序都可以发布它的功能块并且任何其它的应用程序都可以使用其所发布的功能块(不过得遵循框架的安全性限制)。同样,该应用程序重用机制也使用户可以方便的替换程序组件。

隐藏在每个应用后面的是一系列的服务和系统, 其中包括;

·             丰富而又可扩展的视图(Views),可以用来构建应用程序, 它包括列表(lists),网格(grids),文本框(text boxes),按钮(buttons), 甚至可嵌入的web浏览器。

·             内容提供器(Content Providers)使得应用程序可以访问另一个应用程序的数据(如联系人数据库), 或者共享它们自己的数据

·             资源管理器(Resource Manager)提供 非代码资源的访问,如本地字符串,图形,和布局文件( layout files )。

·             通知管理器 Notification Manager 使得应用程序可以在状态栏中显示自定义的提示信息。

·             活动管理器( Activity Manager 用来管理应用程序生命周期并提供常用的导航回退功能。

有关更多的细节和怎样从头写一个应用程序,请参考 如何编写一个 Android 应用程序.

程序库

Android 包含一些C/C++库,这些库能被Android系统中不同的组件使用。它们通过 Android 应用程序框架为开发者提供服务。以下是一些核心库:

·             系统 C - 一个从 BSD 继承来的标准 C 系统函数库( libc ), 它是专门为基于 embedded linux 的设备定制的。

·             媒体库 - 基于 PacketVideo OpenCORE;该库支持多种常用的音频、视频格式回放和录制,同时支持静态图像文件。编码格式包括MPEG4, H.264, MP3, AAC, AMR, JPG, PNG

·             Surface Manager - 对显示子系统的管理,并且为多个应用程序提 供了2D3D图层的无缝融合。

·             LibWebCore - 一个最新的web浏览器引擎用,支持Android浏览器和一个可嵌入的web视图。

·             SGL - 底层的2D图形引擎

·             3D libraries - 基于OpenGL ES 1.0 APIs实现;该库可以使用硬件 3D加速(如果可用)或者使用高度优化的3D软加速。

·             FreeType -位图(bitmap)和矢量(vector)字体显示。

·             SQLite - 一个对于所有应用程序可用,功能强劲的轻型关系型数据库引擎。

Android 运行库

Android 包括了一个核心库,该核心库提供了JAVA编程语言核心库的大多数功能。

每一个Android应用程序都在它自己的进程中运行,都拥有一个独立的Dalvik虚拟 机实例。Dalvik被设计成一个设备可以同时高效地运行多个虚拟系统。 Dalvik虚拟机执行(.dex)的Dalvik可执行文件,该格式文件针对小内存使用做了 优化。同时虚拟机是基于寄存器的,所有的类都经由JAVA编译器编译,然后通过SDK "dx" 工具转化成.dex格式由虚拟机执行。

Dalvik虚拟机依赖于linux内核的一些功能,比如线程机制和底层内存管理机制。

Linux 内核

Android 的核心系统服务依赖于 Linux 2.6 内核,如安全性,内存管理,进程管理, 网络协议栈和驱动模型。 Linux 内核也同时作为硬件和软件栈之间的抽象层。

 

 

Android新手入门

如果想开始Android开发,请先读以下章节:

安装SDK和插件

如何安装 Android SDK Eclipse 插件。

开发和调试

介绍如何在Eclipse中开发和调试Android应用程序,以及其他集成开发环境。

Hello, Android

编写你首个Android程序,Android风格的Hello World

剖析Android程序

Android应用程序结构和架构介绍,此向导将会帮助你理解编写Android程序。

记事本程序手册

本手册指导你创建一个真实的 Android 应用: 记事本程序,它可以创建,编辑和删除内容, 该程序用实例对许多基本概念进行了讲解。

开发工具

介绍SDK中的命令行工具,包括其功能和如何使用。

应用程序模型

应用,任务,进程,线程指南。这些基本元素定义了你的程序在系统中如何运行,以及如何展示给用户。

应用程序生命周期

讲述应用程序以及程序中活动的生命周期。

阅读了上面的部分之后,以下的入门信息同样有用:

核心包

Android SDK提供了编写应用程序的一些基本包。这些包通过分层方式组织,以下按照从底层到高层的顺序列出。

android.util

包含有许多底层的工具类,例如专用容器类,XML工具等等。

android.os

提供基本的操作系统服务、消息传递和进程间通讯。

android.graphics

核心图形绘制包。

android.text, android.text.method, android.text.style, and android.text.util

提供丰富的文本处理工具、富文本支持以及输入法等等。

android.database

包含数据库相关的底层API

android.content

提供大量的访问存储在设备上的数据的服务:安装在设备上的应用及相关资源,用于持续的动态数据的内容提供器(content provider)。

android.view

核心用户界面框架。

android.widget

提供构建view包的标准用户界面元素(列表、按钮、布局管理器等等)。

android.app

提供高层应用模型,通过活动实现。

其它值得注意的包

这些包提供了Android平台的中领域相关的附加功能。对于基本应用程序的开发它们不是必须的。

android.provider

包括了平台内的各个内容提供器(content providers)的定义。

android.telephony

提供与设备的电话协议栈交互的API

android.webkit

包含各种用于web内容的API

 

 

 

安装 SDK

本页内容介绍如何安装Android SDK以及如何设置你的开发环境。如果你还没有下载SDK,你可以点下面的连接进行下载,然后阅读后续文档学习如何安装,配置,并使用该SDK来创建Android应用程序。

下载 SDK

升级?

如果你已经用更早的版本开发过程,可以跳过本页,并阅读升级 SDK文档.

Android sdk的代码和工具开发Android应用程序,你需要适合的开发电脑以及开发环境,如下描述:

所需操作系统:

·             Windows XP Vista

·             Mac OS X 10.4.8 或更高版本 (仅支持x86)

·             Linux ( Linux Ubuntu Dapper Drake 版本已测试)

所需开发环境:

·             Eclipse IDE

o                    Eclipse 3.3 (Europa), 3.4 (Ganymede)

§                            Eclipse JDT 插件 (大多数的 Eclipse IDE 包包含)

§                            WST (可选,Android编辑器的功能需要,它被包含在most Eclipse IDE packages 中)

o                    JDK 5 JDK 6 (只有JRE是不够的)

o                    Android Development Tools 插件 (可选 )

o                    兼容GNU Java编译器(gcj)

·             其他开发环境或 IDE

o                    JDK 5 JDK 6 (仅有JRE不够)

o                    Apache Ant 1.6.5 或更高版本( Linux Mac环境下), 1.7 或更高版本( Windows环境下)

o                    兼容GNU Java编译器(gcj)

: 如果你的电脑上已经安装了jdk,请确定它是上面所列的版本号。另外需要注意有些linux版本可能包含有jdk 1.4 或者 java gnu编译器,Adroid开发是不支持在这两种版本

安装 SDK

下载完SDK后,把.zip文件解压到你电脑上合适位置. 默认情况下, SDK文件被解压到 android_sdk_<platform>_<release>_<build>文件夹. 这个文件夹包含 tools/, samples/.

请注意系统里SDK解压后的文件夹的名字和位置当你安装Android插件和使用SDK工具时,你将需要引用这个文件夹。

你可以添加 SDK tools 的文件夹路径到你的环境变量中. 如上所述, tools/文件夹位于SDK文件夹中。

·             Linux环境下,修改~/.bash_profile或者 ~/.bashrc文件. 找到环境变量设置的地方,加入tools/的绝对路径。如果找不到该设置,你需要新添加一行:

export PATH=${PATH}:<your_sdk_dir>/tools

·             Mac环境下,在你的home文件夹里面查找.bash_profile,然后和linux一样处理。如果之前没有.bash_profile文件,你可以创建一个新的。

·             Windows环境下, 右击我的电脑, 并选择属性. 在标签页高级, 点击环境变量, 当对话框出现, 在系统变量栏目里双击路径 ( Path ) .并添加tools/ 文件夹的完整路径.

添加 tools 到你的环境变量里,这样你可以运行Android Debug Bridge (adb)和其他tools下命令,而不需要输入完整路径名。需要说明的是, 如果你升级你的SDK 需要将你的相应环境变量更新到新的位置。

安装 Eclipse 插件 (ADT)

如果你要使用 Eclipse IDE作为开发Android应用的环境,你可以安装支持Android工程和工具的通用插件Android Development Tools (ADT). ADT插件包含强大的扩张,使得创建,运行和调试Android 更快速,更简单。

如果你不使用 Eclipse IDE,就不必下载和安装ADT插件

下载和安装ADT插件,请按照你们各自Eclipse版本步骤安装。

Eclipse 3.3 (Europa)

Eclipse 3.4 (Ganymede)

1.           开始Eclipse,然后选择 Help > Software Updates > Find and Install....

2.           对话框出现后,选择 Search for new features to install 点击 Next.

3.           点击New Remote Site.

4.           在对话框中,输入远程站点的名字(如Android Plugin),输入站点如下:

https://dl-ssl.google.com/android/eclipse/

点击OK.

5.           你可以看到新的站点添加到搜索列表中(并检查),点击Finish.

6.           在下面的搜索结果对话框,选择复选框 Android Plugin > Developer Tools. 它将会检查特性: "Android Developer Tools", "Android Editors". Android 编辑器的特性是可选的,但我们推荐安装它,如果你选择安装,需要前面提到的WST插件。点击 Next.

7.           阅读许可协议,然后选择接受许可协议,点击 Next.

8.           点击 Finish.

9.           ADT插件没有签名,你可以点击Install All来安装所有东西。

10.       重启 Eclipse.

1.           启动 Eclipse, 选择 Help > Software Updates....

2.           在出现的对话框里,点击标签页 Available Software.

3.           点击 Add Site...

4.           输入下面的地址:

https://dl-ssl.google.com/android/eclipse/

点击 OK.

5.           返回可用软件的视图,你会看到这个插件. 选择下一步到 Developer Tools 并点击 Install...

6.           在接下来的安装窗口,选中"Android Developer Tools" "Android Editors"Android编辑器特性是可选的,但是我们推荐安装它,如果你选择安装,需要前面提到的WST插件。点击 Finish.

7.          重启 Eclipse

重启之后, update your Eclipse preferences 指向SDK文件夹:

1.           选择 Window > Preferences... 来打开属性面板。 (Mac OS X: Eclipse > Preferences)

2.           从左边面板选择 Android

3.           在主界面上定位SDK 点击 Browse... 然后定位 SDK文件夹。

4.           点击 Apply, 然后点击 OK

ADT 安装疑难解答

I你如果按照以上步骤下载ADT插件有疑问,这里是一些建议:

·             在第四步,尝试改变远程更新地址URLhttp,而非 https.

·             如果你在防火墙保护下(企业防火墙)请确定你的Eclipse的代理设置合适。在Eclipse 3.3/3.4,你可以从主Eclipse菜单中配置: Window ( Mac, Eclipse) > Preferences > General > Network Connections

如果无法安装下载的ADT插件到Eclipse,按照如下的步骤来从你的电脑下载和安装插件:

1.           下载ADT压缩文件 (不解压).

2.           按照默认安装的第一部和第二步(如上).

3.           Eclipse 3.3, 点击New Archive Site....
In Eclipse 3.4, click Add Site...,
然后点击Archive...

4.           浏览和选择已经下载的压缩文件。

5.           从第五步开始完成上面剩下的流程。

更新你的插件,你必须按照这些步骤代替默认的更行说明。

更新 ADT 插件

在某些情况下,你机器上的SDK可能和ADT插件是兼容的,你可以用以下步骤从Eclipse里更新ADT插件。

Eclipse 3.3 (Europa)

Eclipse 3.4 (Ganymede)

1.           选择 Help > Software Updates > Find and Install....

2.           选择Search for updates of the currently installed features 并点击 Finish.

3.           如果 ADT可以更新,选择并安装更新。

或:

1.           选择 Help > Software Updates > Manage Configuration.

2.           展开导航树并选择 Android Development Tools <version>

3.          Available Tasks 下选择 Scan for Updates

1.           选择 Help > Software Updates...

2.           选择标签页 Installed Software

3.           点击 Update...

4.          如果 ADT允许更新,选择它并点击 Finish.

安装注意事项

Ubuntu Linux 注意事项

·             如果你需要帮助安装和配置java在你的ubuntu机器上,下面资源可能对你有帮助:

o                    https://help.ubuntu.com/community/Java

o                    https://help.ubuntu.com/community/JavaInstallation

·             这里有javaEclipsed的安装步骤,先安装Android SDKADT 插件.

1.  如果你你开发机上使用64位版本,你需要用 apt-get安装 ia32-libs

apt-get install ia32-libs

2.   下一步,安装 Java:

apt-get install sun-java6-bin

3.   Ubuntu 包管理器现在没有提供Eclipse 3.3版本下载,因此我们推荐你从eclipse.org (http://www.eclipse.org/ downloads/)下载。 建议使用JavaRCP版本的Eclipse.

4.  按照前面部分的提供步骤来安装SDKADT插件.

其他版本 Linux 注意事项

·             如果你在安装EclipseADT插件遇到这个错误:

·                   An error occurred during provisioning.

·                   Cannot connect to keystore.

JKS

你的开发环境缺少适合的虚拟机,安装 Sun Java 6可以解决这个问题,然后你再重新安装ADT插件。

·             如果JDK已经安装到你的开发电脑上,请确定其版本在这页的顶部列表中已经列出,有些Linux包含jdk1.4或者javagnu编译器,以上二者Android不支持。

 

 

 

更新SDK

本指南将帮助您升级您的开发环境和应用程序到SDK的最新版暿 如果你已经应用了以前版本的Android SDK, 也需要使用本指南。

为了确保您的应用程序能够兼容android1.0系统,您需要安装新的SDK和用新的API移植现有的android应用程序,以下各节指导您完成这一进程。

下载SDK 并解压到一个安全的位置。

解压新的SDK以后 ,您应该完成下面的操作。

·             擦除你的模拟器的数据

由于新的SDK版本发布,一些数据格式改变了。因此任何以前保存的模拟器数据必须清除。打开一个控制台/终端和操作SDK中的/to ols目录。启动模拟器瘿wipe-data的选项

Windows: emulator -wipe-data
Mac/Linux:
./emulator -wipe-data

·             更新您的PATH变量(Mac/Linux;可选)

如果你以前设置PATH变量为指向的SDK tools目录,那么您必须更新以指向新的SDK的。E.g., .bashrc or .bash_profile file: export PATH=$PATH:<your_new_sdk_dir>/tools

更新ADT Eclipse插件

如果您在Eclipse上使用ADT插件开发,请按照下列步骤安装新的插件匹配新的SDK

Eclipse 3.3 (Europa)

Eclipse 3.4 (Ganymede)

1.           选择Help > Software Updates > Find and Install....

2.           选择Search for updates of the currently installed features 并点击Finish.

3.           如果任何ADT有效,选择并安装

4.          重启 Eclipse.

1.           选择Help > Software Updates...

2.           选择the Installed Software tab.

3.           点击 Update...

4.           如果任何ADT有效,选择并点击Finish

5.          重启 Eclipse

重新启动之后,更新您的Eclipse设置指向SDK目录。

1.           选择 Window > Preferences... to open the Preferences panel. (Mac OSX: Eclipse > Preferences)

2.           选择 Android from the left panel.

3.           对于在主面板中SDK的定位,点击Browse... 并找到SDK的目录。

4.           点击 Apply, 然后 OK.

所有应用程序在安装它们之前都必须被签名。ADT插件和ant为基础的开发工具都支持这一要求,它们通过带一个调试KEYapk文件来签发编译。为了做到这一点,编译工具使用包括在JDKKeytool去创造一个keystore和带着一个已知的别名和密码一个key带着一个已知的别名和密码。如需详细信息,请查阅 签名你的应用程序.

为了支持签签名,你应该首先确认Keytool对于SDK的编译工具是有效的。在大多数情况下,你可以告诉的SDK编译工具如何找到Keytool,通过设置你的J AVA_HOME环境变量设置和一个合适的JDK。另外,您也可以添加keytoolJDK版本到您的PATH变量

如果你正在开发Linux的一个版本,那原本使用的是GNUJAVA编译嗿,请确保该系统正在使用的KeytoolJDK版本,而不是使用gcj,如果keyt ool已经在您的路径,它可能是指向在一个符号链接是/usr/bin/keytool 。在这种情况下,检查符号链接的目标,以确保它指向正确的Keytool.

如果您使用的ant编译你的.apk文件ﺿ而不是ADT,你必须重新产生你的build.xml文件。为了做到这一点,请执行下列步骤:

1.           在您的android应用程序工程目录中,找到并删除目前的build.xml文件

2.           2. 运行activitycreator ,直接输出到包含您的应用程序项目的文件夹

3.              - exec activitycreator

--out  your.activity.YourActivity

运行这种方式ﺿactivityCreator不会擦出或创建新的Java文件(或manifest文件ﺿ,对于那些已经存在的activitypackage。重要的是,packageactivity是真实存在的。该工具创建一个新的build.xml文件,以及一个新的目录称libs"中,这个目录将放置第三方jar文件,这是你就能够使用ant脚本自动处理。

更新过您的SDK以后 ,您可能会遇到破损的代码,由于框架和API的变化。您需要更新您的代码以匹配变化的AndriodAPI

一种方法是用Eclipse打开您的项目和查看你的应用程序中ADT的标记错误。从这里,你可以查找对应的变势 变化预览 and API变化报告.

如果您更新您的代码有其他麻烦,请访问 android小组讨论 寻求帮助或者求助于其他android开发人员.

如果已经修改了一个ApiDemos应用程序,并希望移植到新的SDK的,请注意您将需要卸载模拟器中预装的ApiDemos版本。了解更多信息,或(运行或安装A piDemos)遇到一个重新安装"的错误,见疑难解答论頿 因为签名错误,我不能在我的IDE中安装ApiDemos应用程序 来获得解决这个问题的信息。

 

 

 

开发和调试

这一节将介绍在Android上开发调试应用程序。本节会教你如何创建,编译,运行以及调试android代码。当然,你也可以从Hello Android tutorial.开始。

1.               Eclipse上开发Android 应用程序

2.               用其他IDE和工具开发Android应用程序

3.               给应用程序签名

4.               ApiDemo 示例程序用法

5.               调试

6.               设备上的调试和测试设置

7.               顶级调试技巧

8.               编译安装一个Android应用程序

9.               移除Android程序

10.            Eclipse 技巧

eclipse上开发Android应用程序

在用Eclipse IDE开发android应用程序之前,你首先要创建一个Android工程,并且建立一个启动配置,在此之后你才可以开始编写,运行,以及调试你的应用程序。

以下章节是假设你已经在eclipse环境中安装了ADT插件,如果你没有安装,请安装之后再使用以下说明。参考 安装Eclipse 插件(ADT

创建一个android工程

ADT提供了一个新的工程向导,你可以快速的创建一个新的工程或者在现有代码上创建工程。创建工程的步骤如下:

选择File > New > Project

1.           选择 Android > Android Project, 然后按下 Next

2.           选择项目内容:

o                    选择 Create new project in workspace 为编码创建一个全新的工程。

输入工程名称(project name),基础软件包的名称(the base package name),以及Activity 类的名称。以创建stub .java文件等文件和程序名字。

o                    选择Create project from existing source ,为已有代码创建一个工程。如果你想编译运行SDK中提供的示例程序,可以使用这个选项。示例程序的存放在SDKsamples/目录下。

浏览到包含已有代码的目录,点击ok,如果目录中包含有可用的Android manifest 文件,ADT将为你填写合适的软件包,活动,和应用程序名称。

3.           按下Finish.

ADT插件会根据你的工程类型创建合适的文件和文件夹,如下:

·             src/   包含stub .java Activity文件的文件夹。

·             res/   资源文件夹。

·             AndroidManifest.xml   工程的Manifest文件。

创建一个启动项

能够在Eclipse上运行调试应用程序之前,你必须为它创建一个启动项。启动项指定哪个工程将被启动,哪个活动开始工作,以及使用哪些模拟器选项等。

按照以下步骤为Eclipse版本的应用程序创建合适的启动项:

1.           打开启动项管理工具。

o                    Eclipse 3.3 (Europa)的版本中,酌情选择 Run > Open Run Dialog... 或者 Run > Open Debug Dialog...

o                    Eclipse 3.4 (Ganymede)版本中,酌情选择 Run > Run Configurations... 或者 Run > Debug Configurations...

2.           在左边的工程类型列表选择Android Application选择,双击(或者点击右键选择new,创建一个新的启动项。

3.           输入启动项名称。

4.           Android标签中,浏览要开始的工程和活动

5.           Target标签中,设置想要显示的屏幕及网络属性,以及其他任何模拟器启动选项

6.           你可以在Common标签中设置更多的选项.

7.           按下Apply保存启动配置,或者按下RunDebug()。

运行和调试应用程序

一旦你设定了工程和工程启动配置,你就可以按照以下的说明运行和调试应用程序了。

Eclipse主菜单,根据情况选择Run>Run 或者 Run>Debug,运行或者调试活动的启动配置。

注意,这里活动启动项是在运行配置管理中最最近一次选中的那个。它不一定就是在Eclipse 导航 面板中选择的程序(如果有的话)

设置和修改活动启动项,可以使用启动项管理工具。如何使用启动项管理工具可以参考创建一个启动项

运行或调试应用程序将触发以下动作:

·             启动模拟器,如果他还没有开始运行。

·             编译工程, 如果在上次编译的基础上修改过代码,将重新编译。在模拟器上安装应用程序。

·             运行程序。

·             Debug "Wait for debugger "模式下启动程序,然后打开调试窗口并将Eclipse Java调试器和程序关联。

利用其他IDEs和工具开发Android应用程序

通常我们使用安装有ADT插件的eclipse Eclipse with the ADT plugin.来开发Android程序,这个插件将编辑,build和调试功能集成到IDE上。

然而,如果你想在其他的IDE上开发程序,例如IntelliJ,或者使用没有ADT插件的Eclipse也可以。SDK提供了安装,编译,调试应用程序所需要的工具。

创建一个Android工程

Android SDK包含一个activityCreator的程序,它将为工程产生多个stub文件和一个build文件。你可以用这个程序创建一个新的Android工程或者在现有代码上创建工程,如SDK中包含的例子。对于Linux Mac系统,SDK提供activityCreator.py,一个 Python脚本,Windows上则是activityCreator.bat一个批处理脚本。无论是哪种平台,用法是一样的。

按以下步骤运行activityCreator创建Android工程:

1.           在命令行下,切换到SDK下的tools/目录下,为你的工程文件新建一个目录。如果你是在现有代码上创建工程,切换到程序的根目录下。

2.           运行activityCreator。在命令行下,你必须指定完全有效的类名作为参数。如果你是创建一个全新的工程,这个类代表的与它同名的stub类和脚本文件。如果是在现有代码上创建工程,必须指定软件包中其中一个Activity类的名称。 命令选项的脚本包括:

o                    --out <folder> 设定输出目录。默认情况下输出目录为当前目录。如果你想为工程文件创建一个新的目录,可以使用这个选项来指向它。

o                    --ide intellij, 在一个新的项目中生成IntelliJ IDEA 工程文件。

这里有个例子:

~/android_linux_sdk/tools $ ./activityCreator.py --out myproject your.package.name.ActivityName
package: your.package.name
out_dir: myproject
activity_name: ActivityName
~/android_linux_sdk/tools $ 

activityCreator脚本生成以下文件和目录(但是不能覆盖已有文件):

·             AndroidManifest.xml 程序的清单文件,同时为工程指定Activity类。

·             build.xml 一个Ant文件,用来编译/打包应用程序。

·             src/your/package/name/ActivityName.java 你指定的输入Activity类。

·             your_activity.iml, your_activity.ipr, your_activity.iws    [only with the -ide intelliJ flag] intelliJ工程文件

·             res/   资源目录.

·             src/    源代码目录.

·             bin/    build脚本的输出目录.

现在你可以将开发文件夹移到任何地方,但是记住,必须使用tool/文件夹下的adb程序将文件导入到模拟器。因此你需要在你工作环境和tools/文件夹之间切换。

当然你需要避免移动SDK目录,因为它将打断编译脚本。(再重新build之前需要手动更新SDK的映射路径)

编译 Android应用程序

使用activityCreator生成的Ant文件build.xml来编译程序

1.           如果你没有,你可以通过Apache Ant home page得到Ant文件。安装它,并确定它在你的可执行文件路径下。

2.           呼叫Ant之前,你需声明JAVA_HOME环境变量,并将它设置为JDK的安装路径。

注意:在windows上,JDK默认的安装路径为"Program Files",这个路径将会引起Ant失败,因为路径中间有空格。解决这个问题,你可以像这样指定环境变量JAVA_HOMEJAVA_HOME=c:/Prora~1/Java/ 然而简单的解决方法是将JDK安装在没有空格的目录下。例如:c:/java/jdk1.6.0_02. 

3.           如果你还没有这么准备好,按照上面介绍来建立一个新的工程。

4.           现在你仅仅需要只是在build.xml同文件夹下输入Ant来运行Ant编译文件,每次修改代码或是资源,都需要重新运行Ant,它将把最新版的应用程序打包并部署使用。

运行Android程序

运行一个编译好的程序,你需要用adb工具将.apk文件加载到模拟器的/data/app/目录下,用法如下:

1.           启动模拟器(命令行下运行sdk目录下的/tools/emulator)。

2.           模拟器切换到主画面(最好不要在程序运行的时候向模拟器安装程序,可以按home键离开应用程序)。

3.           运行adb,安装myproject/bin./<appname>.apk文件。例如,安装Lunar Lander 示例,在命令行下,切换到SDK目录下的/sample/LunarLander子目录下,输入../../tools/adb install bin/LunarLander.apk

4.           在模拟器中,打开可执行程序列表,翻动屏幕,选中并启动你的应用程序。

注意:当你第一次安装一个活动时,你可能需要在启动项显示之前,或者其它程序调用它之前重新启动模拟器。因为软件包管理工具通常只有在模拟器启动时才能完全的审查manifests

为应用程序附加调试器

这一节我们介绍如何在屏幕上显示调试信息(例如CPU使用率),以及如何将IDE和模拟器上运行的程序关联起来。

使用Eclipse插件可以自动的生成调试器。但你也可以通过配置IDES来监听调试端口得到调试信息。

1.           启动Dalvik Debug Monitor Server (DDMS) 工具 ,它在IDE和模拟器之间进行端口数据传输。

2.           设置模拟器调试配置选项。例如,等到调试信息被加载后才启动应用程序。注意,很多调试选项无需DDMS也可以使用,例如模拟器上显示CPU的使用效率,或者屏幕的刷新频率。

3.           配置IDE,使得调试时IDE8700端口关联 how to set up Eclipse to debug your project包含这些信息。

配置IDE附加调试端口

DDMS将为每一个虚拟机分配一个特殊的调试端口,这个端口在模拟器上可以找到。你必须将你的IDE与此端口(虚拟机上信息栏中有列出这些端口)关联或者是默认的端口8700。这样可以使IDE 连接到模拟器上程序列表中的任一个程序。

你的IDE需要能够关联模拟器上正在运行的程序,显示它的线程,并允许你挂起它,检查它的状态,设置断点。如果你在开发设置面板选择了等待调试,应用程序将等到Eclipse连接后才运行,所以你需要在连接之前设置断点。

修改正在调试的程序,或者在当前程序运行时选择等待调试将引起系统杀死这个应用程序。如果你的程序处于一种不正常的状态,你可以使用这种方式杀死它,方法很简单,只需要在设置里钩掉复选框。

应用程序签名

Android系统要求所有的程序经过数字签名才能安装,如果没有可用的数字签名,系统将不许安装运行此程序。不管是模拟器还是真实设备,只要是Android系统,这都适用。鉴于此原因,在设备或者是模拟器上运行调试程序之前,你必须为你的应用程序设置数字签名。

理解Android程序签名的重要几点::

·             所有的程序都必须签名,没有被签名的程序,系统将不能安装。

·             你可使用自签署证书签署你的应用程序,就无须授权凭证。

·             系统仅仅会在安装的时候测试签名证书的有效期,如果应用程序的签名是在安装之后才到期,那么应用程序仍然可以正常启用。

·             你可以使用标准工具-Keytool and Jarsigner-生成密钥,来签名应用程序的.apk文件。

Android SDK 工具可以帮助你在调试时给应用程序签名。ADT插件和Ant编译工具都提供了两种签名模式-debug模式和release模式

·             debug模式下,编译工具使用JDK中的通用程序Keytool通过已知方法和密码创建秘锁和密钥。每次编译的时候,工具使用debug密钥签名应用程序的.apk文件。因为密码是已知的,工具不需要在每次编译的时候提示你输入密锁和密钥。

·             当你的应用程序已经准备release了,你可以在release 模式下编译。release模式下,工具编译时不会将.apk文件签名。你需要用Keytool生成密钥和密锁,再用JDK中的Jarsigner工具给.apk文件签名。

签名基本设置

为了支持生成密锁和密钥,你首先要确定KeytoolSDK编译工具中是有效的。在很多情况下,你可以设置JAVA_HOME环境变量,告诉SDK如何找到Keytool,或者你可以在PATH变量中添加KeytoolJDK版本。

如果你是在linux版本中开发,原本是来自Java GNU编译器,请确定系统用的是Keytool版本的JDK,而不是gcj版本的。如果Keytool已经在PATH中,它将指向符号连接/usr/bin/keytool。这种情况下,核实符号连接的目标是指向JDK下的Keytool

Eclipse/ADT中的签名

如果你是在Eclipse下开发,并已经按照上面所介绍的安装了Keytool,默认情况下是可以在debug模式下签名的。当你运行调试程序的时候ADK将给.apk文件签名,并安装到模拟器上。这部分不需要特殊的动作,ADT已经进入Keytool

release模式下编译程序,在Package面版上按project右键,选择Android Tools>Export Application Package.或者你可以点击Manifest Editor overview 页面上的“Exporting the unsigned .apk”连接 ,导出未签名apk文件。保存.apk文件之后,用Jarsigner及你自己的密钥给apk文件签名 ,如果没有密钥, 你可以用Keystore创建密钥和密锁。如果已经有一个密钥了,如公共密钥,就可以给.apk文件签名了。

Ant签名

如果用Ant编译.apk文件,假设你使用最新版的SDK中包含的activitycreator工具生成build.xml文件,默认情况下可以使用debug签名模式。当你运行Antbuild.xml编译程序,build脚本将生成密锁和密钥并签名.apk文件。这部分不需要做其它特殊的动作。

release模式下编译程序,你需要做的是在Ant命令中指定编译目标“release”。例如,如果是在bulid.xml所在目录下运行ant,输入以下命令:

ant release

build脚本编译程序时并没有签名。编译完.apk文件后,你需要用Jarsigner和你自己的密钥给.apk文件签名。如果没有密钥, 你可以用Keystore创建密钥和密锁。如果已经有一个密钥了,如公共密钥,你就可以给.apk文件签名了。

调试证书期限

自签名证书用于程序的debug模式下(默认情况下是Eclipse/ADT Ant builds,自它创建时间起有一年的期限。

当证书到期时,将会有编译错误。 And下错误显示如下:

debug:
[echo] Packaging bin/samples-debug.apk, and signing it with a debug key...
[exec] Debug Certificate expired on 8/4/08 3:43 PM

Eclipse/ADT下,你可以看到类似的错误。

解决这个问题的简单方法是删除debug.keystore文件。Linux/Mac OSX下这个文件保存在~/.android下,windows XP下,文件保存在 C:/Documents and Settings/<user>/Local Settings/Application Data/Androidwindows Vista下文件保存在 C:/Users/<user>/AppData/Local/Android

下次编译时,编译工具将生成新的密锁和密钥。

注意:如果你的开发设备使用的是non-Gregorian locale,编译工具经常错误的生成一个过期的调试证书,因此编译的时候你会得到错误提示。 对于解决信息,请参见疑难解答专题 I can't compile my app because the build tools generated an expired debug certificate.

使用ApiDemo示例应用程序

Android SDK包含了一套示例程序,他们验证了许多功能以及API的用法。ApiDemos软件包被提前安装在模拟器中,所以你可以启动模拟器,在主画面的应用程序抽屉里打开它。

你也可以在<SDK>/samples/ApiDemos中找到源码,可用看看它,学习Demo的实现方法。

如果你愿意,你还可以将ApiDemo的示例程序作为一个工程加载进来,修改并在模拟器上运行。然而,在这之前你首先要卸载之前已经安装的ApiDemos。如果你没有移除之前安装的版本而直接在开发环境中运行或修改ApiDemos,将会有安装错误。

关于如何卸载和重装ApiDemo,可以参考I can't install ApiDemos apps in my IDE because of a signing error.这样你就可以在你的开发环境中工作了。

调试

Android有相当广泛的一套工具帮助你调试你的应用程序:

·             DDMS -一个图形化工具,它支持端口调试(因此你可以在IDE中给代码设置断点),支持抓取模拟器屏幕,线程和堆栈信息,以及许多其他功能。你还可以运行logcat重新获得Log信息。点击连接的主题查看更多信息。

·             logcat- 转储系统信息,这些信息包括模拟器抛出错误时堆栈信息,以及运行过程的日志信息。运行logcat,查看相关的主题。

·                   ...

·                   I/MemoryDealer( 763): MemoryDealer (this=0x54bda0): Creating 2621440 bytes heap at 0x438db000

·                   I/Logger( 1858): getView() requesting item number 0

·                   I/Logger( 1858): getView() requesting item number 1

·                   I/Logger( 1858): getView() requesting item number 2

·                   D/ActivityManager( 763): Stopping: HistoryRecord{409dbb20 com.android.home.AllApps}

...

·             Android Log - 输出模拟器上log文件信息日志类。如果你在DDMS上运行了logcat,你可以实时阅读这些信息。在你的代码中添加logging方法的调用。使用log类,你可以根据你想获得信息的重要程度不同调用Log.v(verbose),Log.d()(debug),Log.i()(information),Log.w()(warning)或者Log.e(error).来分派log信息Log.i("MyActivity", "MyClass.getView() — Requesting item number " + position)

你可以用logcat阅读这些信息。

·             Traceview - Android可以将函数的调用情况以及调用时间保存到一个log文件中,你可以用图形阅读器Traceview查看详细内容。更多信息查看这个连接下的主题。

·             Eclipse plugin -Eclipse插件整合了相当数量的工具(ADBDDMSlogcat output, 以及其它功能),点击此连接查看更多信息。

·             Debug and Test Device Settings -Android提供了很多有用的设定,例如CPU使用率和帧速率,参看下面的 Debug and Test Settings on the Emulator

此外,参看疑难解答这一节文档,以找出您的应用程序为什么没有出现在模拟器上,或为什么不开始。

Android允许你设置多个设定以便你测试和调试程序。获得模拟器的开发设置,可以选择Dev Tools>Development Settings 按照以下选项将打开开发设置页(或其中之一):

·             Debug app  选择要被调试的程序,你不需要设置这个来关联调试器,但是这个变量有两个作用:

o                    防止Android在调试的断点处长时间停留而抛出错误。

o                    允许你选择Wait for Debugger选项来暂停程序启动,直到调试器被关联上(如下介绍)

·             Wait for debugger    阻塞程序加载直到关联上调试器。这样你可以在onCreate()中设置端点,这在调试Activity的启动进程时很重要。当你改变这个选项,任何当前运行的程序实例将被杀死。为选中此框,你必须如上面介绍的选择一个调试程序。这和在代码中添加waitForDebugger()是一样的。

·             Immediately destroy activities   告诉系统只要activity停止了就销毁它。 ( Android必须回收内存). 这个在测试 onSaveInstanceState(Bundle) / onCreate(android.os.Bundle)代码路径 时非常有用, 否则将难以生效.选择这个选项可能带来很多问题,因为他们没有保存程序的状态。

·             Show screen updates  选中这个选项时,屏幕上任何被重绘的矩形区域会闪现粉红色。这对于发现屏幕不必要的绘图很有用。

·             Show CPU usage   在屏幕顶端显示一个CPU进度,显示CPU的使用情况。 上面红色栏显示总的CPU使用率,下方绿色栏显示目前画面的CPU使用时间。注意:一旦打开次功能就不能关掉,除非重新启动模拟器。

·             Show background   没有activity屏幕显示时显示背景面板,这个通常在调试的时候才会发生。

模拟器重起后这些设置仍被记忆。

顶端调试技巧

快速堆栈转储

从模拟器上获得堆转储,你可以登录adb shell,用"ps"命令找到你想要的进程,然后用"kill-3",堆栈使用轨迹将显示在log文件中。

在模拟器屏幕上显示有用信息

设备可以显示一些有用信息,例如CPU使用率,以及高亮显示重绘区域。可以在开发设定窗口打开和关闭这些功能。Setting debug and test configurations on the emulator中有详细介绍。

你可以通过Dalvik Debug Monitor Service工具获得转储状态信息。请参考adb中介绍的dumpsys and dumpstate

获得模拟器中应用程序状态信息(dumpsys)

你可以通过Dalvik Debug Monitor Service工具获得dumpsys信息。参考adb中介绍的dumpsys and dumpstate

获得无线连接信息

你可以通过Dalvik Debug Monitor Service工具获得无线连接信息。在Device菜单中选择"Dump radio state"

记录跟踪数据

你可以在activity中通过调用android.os.Debug.startMethodTracing()来记录函数的调用以及其它跟踪数据。详细的参考Running the Traceview Debugging Program

记录无线数据

默认情况下系统不记录无线数据(数据很多)。然而,你可以用下面的命令记录无线数据:

adb shell
logcat -b radio

运行adb

Android adb工具,他提供了许多功能,包括移动和同步文件到模拟器上,改变端口,在模拟器上运行 UNIX shell 详见Using adb

获得模拟器屏幕截图

Dalvik Debug Monitor Server (DDMS)可以抓取模拟器屏幕截图。

使用调试帮助类

Android为方便使用提供了调试帮助类,例如util.Log Debug

编译安装Anroid应用程序

Android要求专门的编译工具可以正确的编译资源文件和应用程序的其他部分,因此,你必须为你的应用程序建立一个专门的编译环境。

专门Android编译器编译步骤包括,编译XML和其他资源文件并创建合适的输出格式。编译好的Android应用程序是一个.apk压缩文件,它含有.dex文件,资源文件,原data文件,以及其他文件。你可以通过scratch,或者源文件构造一个合适的Android工程。

Android目前不支持的在本地代码上开发第三方应用程序。

比较推荐的Andriod应用程序开发方法是use Eclipse with the Android plugin,它支持编译,运行,调试Android应用程序。

如果你还有其他IDEAndroid provides tools for other IDEs 可以编译运行Android应用程序,但是他们不是很完整。

移出一个Android应用程序

移出一个安装在模拟器上的应用程序,你需要运行adb删除.apk文件。.apk文件是在安装的时候发送到模拟器上的。使用adb shell进入设备的shell,切换到data/app目录下,用rm命令删除apk文件 rm your_app.apk。用法在相关的主题介绍。

Eclipse技巧

Eclipse上执行任意java代码

Eclipse上,当程序停在断点处时你可以执行任意代码。例如,在一个含有“zip”字符串参数的函数中,你可以获得软件包信息,调用类方法。你也可以执行任意静态方法:如,输入 android.os.Debug.startMethodTracing() ,启动 dmTrace

打开代码执行窗口,主菜单中选择Window>Show View>Display,打开显示窗口,一个简单的文本编辑器。输入你的代码,高亮显示文字,单击'J'图标(或者CTRL + SHIFT + D)运行代码。代码在被选线程的上下文中运行, 而这个线程必须是停在断点处或者单步停止点。(如果你手动挂去线程,你必须单步执行。线程停在Object.wait()是没有用的)。

如果你目前是停在断点,你可以简单的按下(CTRL + SHIFT + D)高亮并执行一段代码。

你可以高亮同一选中区域的文字,通过按下 ALT +SHIFT + 向上/向下箭头来改变所选区域的大小

下面是一些例子,输入内容和eclipse 显示窗口的回应信息。

Input

Response

zip

(java.lang.String) /work/device/out/linux-x86-debug/android/app/android_sdk.zip

zip.endsWith(".zip")

(boolean) true

zip.endsWith(".jar")

(boolean) false

你也可以利用剪贴板在不调试时插入执行代码。在eclipse文档中查找"scrapbook"相关。

手动运行DDMS

虽然推荐用ADT插件调试程序,但是你也可以手动运行DDMS,配置Eclipse以便在8700端口上调试程序(注意:首先确定你启动了DDMS)。

增加JUnit测试类

Eclipse/ADT ,你可以在程序中添加JUnit测试类,然而,测试运行正常之前你需要设置专门的JUnit 配置,

关于如何设置JUnit配置的详细细节,参看请参见疑难解答专题I can't run a Junit test class in Eclipse

 

 

 

Hello, Android!

作为开发者,你对一个系统的第一感觉,是你拿到开发框架写“Hello, World!”程序时的难易程度给你留下的。 当然,在Android里,这个非常容易,下面我给你演示:

·             创建一个工程

·             创建UI

·             运行代码: Hello, Android

下面的章节将详细描述

·             使用XML构建UI

·             调试工程

·             不使Eclipse创建一个工程

让我们开始吧!

创建工程

创建一个尽可能简单的工程,Eclipse的插件可以使Android的开发变得简单。

你需要一台装有 Eclipse IDE (参考系统和软件需求), 你还需要安装 Android Eclipse 插件 (ADT) 如果你都准备好了, 继续看这里。

首先,你需要对如何创建“Hello, World!”有个大概的了解:

1.           在菜单中 File > New > Project 中创建一个新的Android 项目。

2.           在创建Android项目的对话框里填写项目的详细信息。

3.           编辑自动生成代码的模板去显示一些输出。

这样就可以了,下面,我们将详细讲解每一步。

1.           创建一个新的Android项目

打开Eclipse, 选择File > New > Project如果AndroidEclipse的插件正确安装了,弹出的对话框里就会有一项“Android”,这一项有唯一的子项 “Android Project”

选中“Android Project”,点下一步。

2.           填写工程的详细信息

下一步需要你填写项目的详细信息,这里有个例子:

每一项具体的意思:

工程名

在机器上包含你工程的目录或者路径名字

包(package)名

包的命名空间(需要遵循java编程语言的命名规则),你的所有代码都会在这个命名空间下。这也会生成包的名称从而活动自动生成。你使用的这个包的名字必须和其他安装在你机器上的包名字不冲突,所以,使用一个标准规则的包名字是非常重要的。如上例,我们使用包的名字为“com.android”, 但你需要根据你的组织使用一个不同的类型。

活动(Activity)名

这是插件为你自动生成类的名字。它也会是Android活动类的一个子类。一个活动仅仅是一个包含一些功能并能执行的类。如果选择它,可以创建用户界面,但这不是必须的。

程序Application

这是最后生成应用程序的名字。

可选框里"Use default location" 允许你选择其他目录保存项目产生的文件。

3.           编辑自动生成代码

运行插件后,会自动生成一个类“HelloAndroid ”(可以在程序包里 HelloAndroid > src > com.android.hello找到) 像这样:

public class HelloAndroid extends Activity {

    /** 活动第一次被创建后调用。 **/

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

    }

}

现在,你可以执行程序了。不过我们还可以进一步研究下,这样我们能更好得理解程序。所以,下一步我们可以改一些代码

建立UI

看下面我们修改的代码,你可以在你的HelloAndroid.java文件里做相同的修改,我们来逐行分析:

package com.android.hello;
 
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
 
public class HelloAndroid extends Activity {
   /** 活动第一次被创建后调用 */
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       TextView tv = new TextView(this);
       tv.setText("Hello, Android");
       setContentView(tv);
   }
}

小提示: 如果你忘记引入 TextView的包,可以尝试 Ctrl-Shift-O (如果是Mac系统Cmd-Shift-O) 这是Eclipse管理应用的快捷方式-它会显示没有找到的包然后自动为你加上。

Android里,用户接口由一些称之为视图的不同层次的类组成。 一个视图就是一个简单的对象。如单选框,动画控件,一个文本框(我们的例子里的),我们称处理文本的这样一个子视图就叫TextView。这里教你如何创建 TextView

这里教你如何创建TextView:

TextView tv = new TextView(this);

TextView构造器的引入参数就是Android上下文的实例,这个上下文仅仅是指向系统的一个句柄,它提供像资源处理之类的服务。包含一些进入资料库以及参数选择的入口。这个活动也是继承于上下文。 HelloAndroid类是活动的一个子类,它也是一个上下文,我们能通过 this 操作TextView

创建TextView后,加入需要显示的内容:

tv.setText("Hello, Android");

这里很简单。

我们创建一个TextView,然后告诉它显示的内容。最后一步就是让TextView在屏幕上显示出来,像这样:

setContentView(tv);

活动里setContentView()的方法表明哪个视图需要被附加在当前UI上被显示。如果某个活动不能调用这个方法,那么当前就没有界面,系统显示为一个空白屏幕。我们仅仅想显示一些文本,所以我们将刚才创建的TextView附加上。

这就是Android平台里的“HelloWorld”,当然,我们可以看下运行情况。

执行代码:HelloAndroid

Eclipse的插件使得你的程序很容易运行。选择Run>->Open Run Dialog菜单。(Eclipse3.4版本中,菜单为Run->Run Configurations)可以看到这样的对话框

下一步,选择“Android Application”,点击在左上角(按钮像一张纸上有个“+”号)或者双击“Android Application” 有个新的选项“New_configuration”

将名字改得更形象一点,如“HelloAndroid”,然后按Browse按钮选择你的项目,(如果你Eclipse里有多个Android项目需要打开,确定要选择正确)插件会会自动扫描你项目里的活动子类,然后在活动的下拉菜单里加载。如果你的“HelloAndroid”项目只有一个,它将被设置为默认项目,然后你可以继续。

点击“Apply”按钮,这里有个例子:

这样就可以了,点击“Run”按钮,Android的模拟器启动。一启动你的程序就会出现,当一切OK,你可以看到:

这就是Android“Hello, World”,是不是非常简单呢?下一章节我们将提供更详细的信息。当你接触更多的Android时,你会发现它非常有价值。

使用XML构建UI

你刚刚完成的“Hello, World”的例子使用的是我们称为可编程UI层,意思是你通过编写代码来组建UI层。当你开发了足够多的UI程序,你会发现一些很糟糕的现象: 一些小的变化需要你做大量的代码改动。你常常会忘记将View连接起来,这样会导致一些错误,浪费你很多时间去调试代码。

这就是Android为什么提供一个可变化的UI开发模块:基于XML的文件。最简单解释这个概念就是演示个例子。这里有个XML的文件,它能达到和你刚才完成代码同样的效果:

<?xml version="10" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:text="Hello, Android"/>

通常AndroidXML文件结构是很简单的。只是一些标记的树形集合,每个标记就是一个视图类。在这个例子中,它就是一个简单的TextView元素的树,你可以在XML文件里使用任何扩展类的名字作为你的标记,这也包括你在你的自己的代码里定义的名字。这个结构使得你能使用简单结构和语法快速的组建UI,这种模型就像网站的开发模型,你能够将UI和程序逻辑分开,单独获取或者填充数据。

在这个例子里,有4XML属性,下面是属性的大概意思:

属性

描述

xmlns:android

这是一个XML命名空间,告诉Android开发工具你准备使用Android命名空间里的一些通用属性。在所有Android XML设计文件中最外层的标记必须使用这个属性。

android:layout_width

这个属性定义了这个视图需要占用的屏幕宽度。在这个例子中,我们仅有的一个视图可以占用整个屏幕,那就是“fill_parent”的意思。

android:layout_height

这个和“layout_width”差不多,表示占用屏幕的高度。

android:text

这个设置文本显示内容,在这个例子里,我们使用“HelloAndroid”

这就是XML的布局,你需要把这个文件放在什么位置? 放在你的工程/res/layout下就可以。“res”“resource”的简称,这个目录包含了所有应用程序需要的非代码部分。比如图片、字符串、XML文件。

Eclipse插件为你创建了一个XML文件。在我们上面的范例,我们根本没有使用过它。在包的管理器里,展开目录/res/layout,编辑main.xml文件,替换上面的文本然后保存修改。

在从代码目录里打开 R.java文件,你可以看到它们像这样:

public final class R {
    public static final class attr {
    };
    public static final class drawable {
        public static final int icon=0x7f020000;
    };
    public static final class layout {
        public static final int main=0x7f030000;
    };
    public static final class string {
        public static final int app_name=0x7f040000;
    };
};

R.java是文件中所有资源的索引界定值定义。你在代码中使用这个类,就像在你的项目里使用一个简洁的方法表示你的资源。在Eclipse这样的IDE工具里,这个方式对于代码自动完成功能还是非常有效的,因为这能让你快速得定位你要寻找的东西。

有个重要点需要注意的是有个内部类“layout”,“main”的成员类。Eclipse插件提醒你加了一个新的XML文件,然后生成R.java文件,当你加入其他资源到你的工程里,你可以看到R.java在同步更改。

最后要做的就是使用你最新版本的XML修改你的HelloAndroid代码去代替以前的编码。 这个有例子说明重新写过的类的模型,你可以看到,代码变得非常简单:

package com.android.hello;
 
import android.app.Activity;
import android.os.Bundle;
 
public class HelloAndroid extends Activity {
    /** Called when the activity is first created */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

当你做这些修改的时,你只需要拷贝、复制。在那个R的类里你可以使用代码自动完成功能,你会发现那确实很有帮助。

现在你已经完成了这些修改,继续执行你的程序-你需要做的就是按下绿色的“Run”按钮,或者在菜单中选择Run->Run History->Hello,Android 你可以看到哇哦,和之前看到的一样!这点表明两种不同的构建方式都能达到同样的结果。

还有很多方法去创建XML文件,在你想做之前。 读一下 实现用户接口 可以获得更多信息。

AndroidEclipse开发的插件和Eclipse的调试工具结合得也很好。 为了演示一下,我们在代码里加入一个bug。你可以像下面的代码一样修改你的代码:

package com.android.hello;
 
import android.app.Activity;
import android.os.Bundle;
 
public class HelloAndroid extends Activity {
    /** 活动第一次被创建后调用 */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Object o = null;
        o.toString();
        setContentView(R.layout.main);
    }
}

这个修改仅仅引入了一个NullPointerException到你的代码里。 如果你再次运行程序,最后你会看到:

“Force Quit”终止程序并关掉模拟器窗口。

为了寻找错误的原因,设置一个断点在 Object o = null; (在代码行旁边的标记栏双击); 然后从菜单选择Run->Debug History->Hello,Android进入调试模式。你的应用程序会在模拟器里重新启动,但这次会在你设的断点处停住。 你可以在Eclipse’s Debug Perspective里单步执行代码,就像你调试其他程序一样。

不使用Eclipse创建工程

如果你不使用Eclipse(比如你喜欢其他IDE工具,或者仅仅使用文本编辑器或者命令行工具),那么Eclipse的插件对你没有作用。别担心-它不会因为你不使用Eclipse而使用失去任何功能。

AndroidEclipse的插件仅仅是Android SDK外围的一个工具。(这些工具如: 模拟器,aapt, adb, ddms等等 相关文档) 因此,将这些工具和其他工具如“ant”编译文件结合也是有可能的。

Android SDK里包含一个Python的脚本“activitycreator.py”,它可以为你的项目创建所有的代码以及目录。就像ant中的“build.xml”文件。这允许你使用命令行编译你的工程或者使用你自己的IDE工具集成。

例如,就像我们刚使用Eclipse创建的HelloAndroid项目,你可以使用命令:

activitycreator.py --out HelloAndroid com.android.hello.HelloAndroid

编译工程的时候,你运行“ant”命令,当命令成功执行后,将在“bin”目录里产生一个 “HelloAndroid.apk”的文件,“apk”文件是Android的一个包,你可以使用“adb”工具安装或者执行。

如果想获得更多信息,请阅读网站提供的替他文档。

 

 

Android 应用程序构成

一般情况Android应用程序是由以下四种组件构造而成的:

·             活动

·             广播接收器

·             服务

·             内容提供器

需要注意的是,并不是每个Andorid应用程序都必须构建这4个组件,有些可能由这些组件的组合而成。

一旦你确定了你的应用程序中需要的组件,那么你就应该在AndroidManifest.xml中列出他们。 这是一个XML配置文件,它用于定义应用程序中需要的组件、组件的功能及必要条件等。这个文件是必须的。 详情参见Android manifest file documentation

四种组件说明如下:

活动是最基本的Andorid应用程序组件,应用程序中,一个活动通常就是一个单独的屏幕。每一个活动都被实现为一个独立的类,并且从活动基类中继承而来, 活动类将会显示由视图控件组成的用户接口,并对事件做出响应。 大多数的应用是由多屏幕显示组成。例如,一个文本信息的应用也许有一个显示发送消息的联系人列表屏幕, 第二个屏幕用来写文本消息和选择收件人, 再来一个屏幕查看消息历史或者消息设置操作等。这里每一个这样的屏幕就是一个活动,很容易实现从一个屏幕到一个新的屏幕并且完成新的活动。 在某些情况下当前的屏幕也许需要向上一个屏幕动提供返回值--比如让用户从手机中挑选一张照片返回通讯录做为电话拨入者的头像。

当打开一个新的屏幕时,之前一个屏幕会被置为暂停状态并且压入历史堆栈中。用户可以通过回退操回到以前打开过的屏幕。我们可以选择性的移除一些没有必要保留的屏幕,因为Android会把每个从桌面打开的程序保留在堆栈中。

Intent Intent Filters

调用Android专有类 Intent 进行构屏幕之间的切换。 Intent是描述应用想要做什么。Intent数据结构两最重要的部分是动作和动作对应的数据。典型的动作类型有:MAIN(活动的门户)、VIEWPICKEDIT等。而动作对应的数据则以URI的形式进行表示。例如:要查看某一个人的联系方式,你需要创建一个动作类型为VIEWintent,以及一个表示这个人的URI

与之有关系的一个类叫IntentFilter。当intent被要求做某事的时候,intent filter用于描述一个活动(或者BroadcastReceiver,看下面)能够操作哪些intent。一个活动如果要显示一个人的联系方式时,需要声明一个IntentFilter,这个IntentFilter要知道怎么去处理VIEW动作和表示一个人的URI IntentFilter需要在AndroidManifest.xml中定义。

通过解析各种intent,从一个屏幕切换到另一个屏幕是很简单的。当向前导航时,活动将会调用startActivity(myIntent)方法。然后,系统会在所有安装的应用程序定义的IntentFilter中查找,找到最匹配myIntentIntent对应的活动。新的活动接收到myIntent的通知后,开始运行。当start活动方法被调用将触发解析myIntent的动作,这个机制提供了两个关键好处:

·             活动能够重复利用从其它组件中以Intent的形式产生的一个请求

·             活动可以在任何时候被一个具有相同IntentFilter的新的活动取代

你可以使用BroadcastReceiver来让你的应用对一个外部的事件做出响应。比如:当电话呼入时,数据网络可用时,或者到了晚上时。BroadcastReceivers不能显示UI,它只能通过 NotificationManager 来通知用户这些有趣的事情发生了。BroadcastReceivers既可以在AndroidManifest.xml中注册,也可以在代码中使用Context.registerReceiver()进行注册。但这些有趣的事情发生时,你的应用不必对请求调用BroadcastReceivers,系统会在需要的时候启动你的应用,并在必要情况下触发BroadcastReceivers。各种应用还可以通过使用Context.sendBroadcast() 将它们自己的intent broadcasts广播给其它应用程序。

一个服务是具有一段较长生命周期且没有用户界面的程序。比较好的一个例子就是一个正在从播放列表中播放歌曲的媒体播放器。在一个媒体播放器的应用中,应该会有多个活动,让使用者可以选择歌曲并播放歌曲。 然而,音乐重放这个功能并没有对应的活动,因为使用者当然会认为在导航到其它屏幕时音乐应该还在播放的。在这个例子中,媒体播放器这个活动会使用Context.startService() 来启动一个服务,从而可以在后台保持音乐的播放。同时,系统也将保持这个服务一直执行,直到这个service运行结束。(你可以通过阅读Life Cycle of an Android Application 获取更多关于服务的介绍). 另外,我们还可以通过使用Context.bindService() 方法,连接到一个服务上(如果这个服务还没有运行将启动它)。当连接到一个服务之后,我们还可以通过服务提供的接口与它进行通讯。拿媒体播放器这个例子来说,我们还可以进行暂停、重播等操作。

应用程序能够将它们的数据保存到文件、SQLite数据库中,甚至是任何有效的设备中。当你想将你的应用数据与其它的应用共享时,内容提供其将会很有用。一个内容提供器类实现了一组标准的方法,从而能够让其它的应用保存或读取此内容提供器处理的各种数据类型。 更详细的内容提供器资料,可以参考附带文档中的 Accessing Content Providers

 

 

教程:一个记事本应用程序范例

本教程通过手把手教你的方式,讲解如何利用Android框架和诸多工具建立自己的手机应用。从一个预先配置好的工程文件开始,该教程通过一个简单记事本应用程序完整的开发过程,并辅以贯穿始终的详尽例子,指导你如何搭建工程、组织应用逻辑以及UI,乃至接下来的编译及运行可执行程序等等。

该教程将这个记事本应用的开发过程视作一组练习(见如下),每一个练习都由若干步骤组成。你可以亦步亦趋地完成每个练习步骤,逐步建立并完善自己的应用程序。这些练习提供了你实现此应用所需的——细到每一步骤的——具体范例代码。

当你完成此教程后,一个具有实际功能的Android应用就从你手上诞生了,并且你对Android应用开发中的一些极为重要的概念也会有更加深刻的理解。若你想为你这个简单的记事本应用添加更多复杂功能的话,你可以用另一方式实现的记事本程序比照你的练习代码,具体可参看 Sample Code 文档部分。

本教程目标读者

该教程主要是面向有一定经验,尤其是那些具备一定Java编程语言知识的开发者。如果你之前从未写过一个Java应用程序的话,仍可以使用此教程,只是学习进度稍稍慢一点罢了。

本教程假定你已熟悉了一些基本的Android应用概念和术语。如果你对这些还不够熟稔的话,你得将 Overview of an Android Application 好好温故一下,才能继续下面的学习。

同时需注意的时,该教程的集成开发环境是预装Android插件的Eclipse。如果你不用Eclipse,仍可做下面的这些练习和建立应用,但你届时将不得不面对一些涉及Eclipse的步骤在非Eclipse IDE中如何实现的问题。

练习前的准备

有关此教程中涉及搭建Android应用程序工程的相关信息已在Installing the SDK Hello Android 这两份文档中做了详细说明。这两份文档详细地解释了为建立Android应用,搭建自己的开发环境所必需的知识。在你开始学习本教程之前,两份文档、SDK安装以及开发环境搭建你得确保都已万事俱备,只欠东风了。

为此节训练所需的准备工作: project exercises archive (.zip) 2.解压至你本地的某一目录下 3.打开NotepadCodeLab文件夹

1.           下载 project exercises archive (.zip)

2.           解压至你本地的某一目录下

3.           打开 NotepadCodeLab 文件夹

NotepadCodeLab 这一文件夹下共有六个工程文件,具体分别是:Notepadv1, Notepadv2, Notepadv3, Notepadv1Solution, Notepadv2Solution Notepadv3Solution。其中诸如Notepadv#的工程目录是每个练习的起点,而Notepadv#Solution则是对应的答案。如果你在某一练习中遇到问题,你可以通过将你本地工程的代码与对应的答案对比一下来自我解答。

练习

下表列出了本教程的一些练习,并描述每一练习所涵盖的开发训练内容。每一练习都是基于你已完成之前的任一练习这一前提来展开的。

练习 1

一个简单记事本应用程序的开发过程起始于此。构建一个可以添加新便笺,但不能编辑的简单便笺列表。演示ListActivity 的基本方面以及如何创建和控制菜单项,以及如何用一个SQLite数据库存储便笺内容。

练习 2

为记事本应用程序添加第二个Activity。演示如何构造一个新ActivityAndroid 操作系统,在不同Activity之间传输数据,使用更多高级的屏幕布局,并演示如何通过调用startActivityForResult()这个API来激活另一窗口并返回一个结果。

练习 3

为应用程序添加对Event生命周期的控制,以得到应用程序在整个生命周期中的状态。

额外学习

演示如何使用Eclipse的调试器及通过调试器查看Event产生后的整个生命周期。此节非必读,但仍极力推荐一读。

其它资源及延伸学习

·             对本教程未涉及的一些轻微但更广博的概念请参阅 Common Android Tasks.

·             Android SDK已包含了适合进一步学习,功能完整的绝佳范例。具体范例可以在你下载的SDK中的samples目录中找到。

·             尽管本教程与SDK samples目录下的完整记事本应用程序并非完全一致,但还是脱胎于此。当你学习本教程时,强烈建议你细细揣摩SDK Sample目录下的记事本应用程序。其中包含了一些较之个人学习应用程序更为有趣的附加信息,诸如:

o                    建立一个有条纹的自定义便笺列表

o                    创建一个自定义的便笺文本编辑窗口,该窗口覆写 draw() 方法,使其看起来像一个真正的有下划线的便笺记事本

o                    ContentProvider()方法的一个完整实现

o                    撤销和放弃编辑操作而非自动保存该编辑操作的结果

 

 

开发工具

Android SDK包括各种各样的定制工具,可以帮助你在Android平台上开发移动应用程序。其中最重要的工具是Android模拟器和EclipseAndroid开发工具插件,但SDK也包含了各种在模拟器上用于调试,打包和安装的工具


Android
模拟器(Android Emulator
它是在你的计算机上运行的一个虚拟移动设备。你可以使用模拟器来在一个实际的Android运行环境下设计,调试和测试你的应用程序。


层级观察器 Hierarchy Viewer New!
层级观察器工具允许你调试和优化你的用户界面。它用可视的方法把你的视图(view)的布局层次展现出来,此外还给当前界面提供了一个具有像素栅格(grid)的放大镜观察器,这样你就可以正确地布局了。


Draw 9-patch
New!
Draw 9-patch
工具允许你使用所见即所得(WYSIWYG)的编辑器轻松地创建NinePatch图形。它也可以预览经过拉伸的图像,高亮显示内容区域。


Eclipse IDE Android
开发工具插件(Android Development Tools Plugin for the Eclipse IDE

ADT插件大大扩展了Eclipse集成环境功能,使得生成和调试你的Android应用程序既容易又迅速。如果你使用EclipseADT插件可以让你难以置信地加快开发Android应用程序的 速度。

·             你可以从Eclipse IDE内部访问其它Android开发工具。例如,ADT可以让你直接从Eclipse访问DDMS工具的很多功能屏幕截图,管理端口转发(port-forwarding,设置断点,观察线程和进程信息。

·             它提供了一个新的项目向导(New Project Wizard),帮助你快速生成和建立起新Android应用程序所需的最基本的文件。

·             它使得构建Android应用程序的过程变得自动化以及简单易行。

·             它提供了一个android代码编辑器,可以帮助你为Android manifest和资源文件编写有效的XML

有关ADT插件的更多详细信息,包括安装指令,可参考Installing the ADT Plugin for Eclipse。如果你想看一个用法范例的屏幕截图,可参考Hello Android


Dalvik
调试监视器服务(Dalvik Debug Monitor Service (ddms)
这个工具集成了Dalvik(为Android 平台定制的虚拟机(VM)),能够让你在模拟器或者设备上管理进程并协助调试。你可以使用它杀死进程,选择某个特定的进程来调试,产生跟踪数据,观察堆(heap)和线程信息,截取模拟器或设备的屏幕画面,还有更多的功能。


Android
调试桥(Android Debug Bridge (adb)
Adb
工具可以让你在模拟器或设备上安装应用程序的.apk文件,并从命令行访问模拟器或设备。你也可以用它把Android模拟器或设备上的应用程序代码和一个标准的调试器连接在一起。


Android Asset Packaging Tool (aapt)
Aapt
工具可以让你创建包含Android应用程序二进制文件和资源文件的.apk文件。


Android
接口描述语言(Android Interface Description Language (aidl)
可以让你生成进程间的接口的代码,诸如service可能使用的接口。


sqlite3
这个工具能够让你方便地访问SQLite 数据文件。这些数据文件是由Android 应用程序创建并使用的。


Traceview
这个工具可以将你的Android 应用程序产生的跟踪日志(trace log)转换为图形化的分析视图。


mksdcard
帮助你创建磁盘映像(disk image),你可以在模拟器环境下使用磁盘映像来模拟外部存储卡(例如SD 卡)。


dx
Dx gongju
.class字节码(bytecode)转换为Android字节码(保存在.dex文件中)


UI/Application Exerciser Monkey
Monkey
是在模拟器上或设备上运行的一个小程序,它能够产生为随机的用户事件流,例如点击(click),触摸(touch),挥手(gestures),还有一系列的系统级事件。你可以使用Monkey来给你正在开发的程序做随机的,但可重复的压力测试


activitycreator
一个可以产生Ant build 文件的脚本,你可以使用它编译你的android 应用程序。如果你正在Eclipse上开发,并使用ADT插件,你不必使用这个脚本。

 

 

Android 应用程序模块: 应用, 任务, 进程, 和线程

在大多数操作系统里,存在独立的一个11的可执行文件(如Windows里的exe文件), 它可以产生进程,用户能操作界面图标并和应用进行交互。但在Android里,这是不固定的,理解将这些分散的部分组合到一起是非常重要的。

由于Android这种可灵活变通的特性,你在实现一个应用不同部分时需要理解一些基础技术:

·             Android (简称 .apk ) ,里面包含应用程序的代码以及资源。这是一个用户能下载并安装他们设备上的文件。

·             任务 ,一般情况下用户能当它为一个应用程序来启动:通常在桌面上会有一个图标可以来启动任务,这是一个上层的应用,可以将你的任务切换到前台来,放在其他应用的上面。

·             进程 是一个代码运行的核心过程。通常.apk包里所有代码运行在一个进程里,一个进程对应一个.apk包;然而, 进程 标签常用来改变代码运行的位置,可以是 全部的.apk 或者是独立的 活动, 接收器, 服务, 或者 提供器组件。

记住关键的一点:当用户看到的应用,无论实际是如何处理的,它都是一个任务。如果你仅仅通过一些活动来创建一个.apk包,其中有一个肯定是上层入口(通过动作的intent-filter 以及分类android.intent.category.LAUNCHER),然后你的.apk包就创建了一个单独任务,无论你启动哪个活动都会是这个任务的一部分。

任务如果从使用者的观点来看,它是一个应用程序;对开发者来讲,它是贯穿活动着任务的一个或者多个视图,或者一个活动栈。当设置Intent.FLAG_ACTIVITY_NEW_TASK标志启动一个活动意图时,任务就被创建了;这个意图被用作任务的根意图(root Intent),定义区分哪个任务。如果活动启动时没有这个标记,它将被运行在同一个任务里(除非你的活动以特殊模式被启动,这个后面会讨论)。如果你使用 FLAG_ACTIVITY_NEW_TASK标记并且这个意图的任务已经启动,任务将被切换到前台而不是重新加载。

FLAG_ACTIVITY_NEW_TASK必须小心使用:在用户看来,一个新的应用程序由此启动。如果这不是你期望的,你将不会创建一个新的任务。另外,如果用户需要从桌面退出到他原来的地方然后使用同样的意图打开一个新的任务,你需要使用新的任务标记。否则,如果用户在你刚启动的任务里按桌面(HOME)键,而不是退出(BACK)键,你的任务以及任务的活动将被放在桌面程序的后面,没有办法再切换过去。

任务亲和力(Affinities

一些情况下Android需要知道哪个任务的活动附属于一个特殊的任务,即使该任务还没有被启动。这通过任务亲和力来完成,它为任务中一个或多个可能要运行的活动提供一个独一无二的静态名字。默认为活动命名的任务亲和力的名字,就是实现该活动.apk包的名字。这提供一种通用的特性,对用户来说,所有在.apk包里的活动都是单一应用的一部分。

当不带 Intent.FLAG_ACTIVITY_NEW_TASK 标记启动一个新的活动,任务亲和力对新启动的活动将没有影响作用:它将一直运行在它启动的那个任务里。然而,如果使用NEW_TASK标记,亲和力会检测已经存在的任务是否具有相同的亲和力。如果是,该任务会被切换到前台,新的活动会在任务的最上面被启动。

你可以在你的表现文件里的应用程序标签里为.apk包里所有的活动设置你自己的任务亲和力,当然也可以为单独的活动设置标签。这里有些例子演示如何使用:

·             如果你的.apk包里包含多个用户可启动的上层应用程序,那么你可能想要为每个活动分配不同的亲和力。这里有一个不错的协定,你可以将不同的名字字串加上冒号附加在.apk包名字的后面 例如,"com.android.contacts"的亲和力命名可以是"com.android.contacts:Dialer" and "com.android.contacts:ContactsList"

·  如果你想替换一个通知,快捷键,或者其它能从外部启动的应用程序的内部活动,你需要在你想替换的活动里明确的设置任务亲和力(taskAffinity)。例如,如果你想替换联系人详细信息浏览界面(用户可以直接操作或者通过快捷方式调用),你需要设置任务亲和力(taskAffinity)“com.android.contacts”

启动模式以及启动标记

你控制活动和任务通信的最主要的方法是通过设置启动模式的属性以及意图相应的标记。这两个参数能以不同的组合来共同控制活动的启动结果,这在相应的文档里有描述。这里我们只描述一些通用的用法以及几种不同的组合方式。

你最通常使用的模式是singleTop(除了默认为standard模式)。这不会对任务产生什么影响;仅仅是防止在栈顶多次启动同一个活动。

singleTask模式对任务有一些影响:它能使得活动总是在新的任务里被打开(或者将已经打开的任务切换到前台来)。使用这个模式需要加倍小心该进程是如何和系统其他部分交互的,它可能影响所有的活动。这个模式最好被用于应用程序入口活动的标记中。(支持MAIN活动和LAUNCHER分类)。

singleInstance启动模式更加特殊,该模式只能当整个应用只有一个活动时使用。

有一种情况你会经常遇到,其它实体(如搜索管理器SearchManager 或者 通知管理器NotificationManager)会启动你的活动。这种情况下,你需要使用 Intent.FLAG_ACTIVITY_NEW_TASK 标记,因为活动在任务(这个应用/任务还没有被启动)之外被启动。就像之前描述的一样, 这种情况下标准特性就是当前和任务和新的活动的亲和性匹配的任务将会切换到前台,然后在最顶端启动一个新的活动。当然,你也可以实现其它类型的特性。

一个常用的做法就是将Intent.FLAG_ACTIVITY_CLEAR_TOP NEW_TASK一起使用。这样做,如果你的任务已经处于运行中,任务将会被切换到前台来, 在栈里的所有的活动除了根活动,都将被清空,根活动的onNewIntent(Intent) 方法传入意图参数后被调用。当使用这种方法的时候 singleTop 或者 singleTask启动模式经常被使用,这样当前实例会被置入一个新的意图,而不是销毁原先的任务然后启动一个新的实例。

另外你可以使用的一个方法是设置活动的任务亲和力为空字串(表示没有亲和力),然后设置finishOnBackground属性。 如果你想让用户给你提供一个单独的活动描述的通知,倒不如返回到应用的任务里,这个比较管用。要指定这个属性,不管用户使用BACK还是HOME,活动都会结束;如果这个属性没有指定,按HOME键将会导致活动以及任务还留在系统里,并且没有办法返回到该任务里。

请确保阅读过文档启动模式属性launchMode attribute 以及 意图标记(Intent flags ,关注这些选项的详细信息。

Android中,进程是应用程序的完整实现,而不是用户通常了解的那样。他们主要用途很简单:

·               提高稳定性和安全性,将不信任或者不稳定的代码移动到其他进程。

·               可将多个.apk包运行在同一个进程里减少系统开销。

·               帮助系统管理资源,将重要的代码放在一个单独的进程里,这样就可以单独销毁应用程序的其他部分。

像前面描述的一样,进程的属性被用来控制那些有特殊应用组件运行的进程。注意这个属性不能违反系统安全: 如果两个.apk包不能共享同一个用户ID,却试图运行在通一个进程里,这种情况是不被允许的,事实上系统将会创建两个不同的进程。

请查看安全相关文档以获取更多关于安全限制方面的信息。

每个进程包含一个或多个线程。多数情况下,Android 避免在进程里创建多余的线程,除非它创建它自己的线程,我们应保持应用程序的单线程性。一个重要的结论就是所有呼叫实例, 广播接收器, 以及 服务的实例都是由这个进程里运行的主线程创建的。

注意新的线程不是为活动,广播接收器,服务或者内容提供器实例创建:这些应用程序的组件在进程里被实例化(除非另有说明,都在同一个进程处理),实际上是进程的主线程。这说明当系统调用时这些组件(包括服务)不需要进程远距离或者封锁操作(就像网络呼叫或者计算循环),因为这将阻止进程中的所有其他组件。你可以使用标准的线程 类或者AndroidHandlerThread 类去对其它线程执行远程操作。

这里有一些关于创建线程规则的例外:

·               呼叫IBinder或者IBinder实现的接口,如果该呼叫来自其他进程,你可以通过线程发送的IBinder或者本地进程中的线程池呼叫它们,从进程的主线程呼叫是不可以的。特殊情况下,,呼叫一个服务 IBinder可以这样处理。(虽然在服务里呼叫方法在主线程里已经完成。)这意味着IBinder接口的实现必须要有一种线程安全的方法,这样任意线程才能同时访问它。

·               呼叫由正在被调用的线程或者主线程以及IBinder派发的内容提供器 的主方法。被指定的方法在内容提供器的类里有记录。这意味着实现这些方法必须要有一种线程安全的模式,这样任意其它线程同时可以访问它。

·               呼叫视图以及由视图里正在运行的线程组成的子类。通常情况下,这会被作为进程的主线程,如果你创建一个线程并显示一个窗口,那么继承的窗口视图将从那个线程里启动。

 

 

Android应用程序的生命周期

在大多数情况下,每个Android应用程序都运行在自己的Linux进程中。当应用程序的某些代码需要运行时,这个进程就被创建并一直运行下去,直到系统认为该进程不再有用为止。然后系统将回收进程占用的内存以便分配给其它的应用程序。

应用程序的开发人员必须理解不同的应用程序组件(尤其是Activity, Service, BroadcastReceiver)是如何影响应用程序进程生命周期的,这是很重要的一件事情。不正确地使用这些组件可能会导致系统杀死正在执行重要任务的应用程序进程。


一个常见的进程生命周期bug的例子是BroadcastReceiver BroadcastReceiverBroadcastReceiver.onReceive()方法中接收到一个Intent时,它会启动一个线程,然后返回。一旦它返回,系统将认为BroadcastReceiver不再处于活动状态,因而BroadcastReceiver所在的进程也就不再有用了(除非该进程中还有其它的组件处于活动状态)。因此,系统可能会在任意时刻杀死进程以回收内存。这样做的话,进程中创建(spawned)出的那个线程也将被终止。对这个问题的解决方法是从BroadcastReceiver启动一个服务,让系统知道进程中还有处于活动状态的工作。为了决定在内存不足时让系统杀死哪个进程,Android 根据每个进程中运行的组件以及组件的状态把进程放入一个重要性分级(importance hierarchy)”中。进程的类型包括(按重要程度排序):

1.           前台(foreground)进程,与用户当前正在做的事情密切相关。不同的应用程序组件能够通过不同的方法使它的宿主进程移到前台。当下面任何一个条件满足时,可以考虑将进程移到前台:

1.                  进程正在屏幕的最前端运行一个与用户交互的Activity (它的onResume()方法被调用)

2.                  进程有一正在运行的BroadcastReceiver (它的BroadcastReceiver.onReceive()方法正在执行)

3.                  进程有一个Service,并且在Service的某个回调函数(Service.onCreate(), Service.onStart(), Service.onDestroy())内有正在执行的代码。

1.           可见(visible)进程,它有一个可以被用户从屏幕上看到的Activity,但不在前台(它的onPause()方法被调用)。举例来说,如果前台的Activity是一个对话框,以前的Activity隐藏在对话框之后,就可能出现这种进程。这样的进程特别重要,一般不允许被杀死,除非为了保证前台进程的运行不得不这样做。

2.           服务(service进程,有一个已经用startService() 方法启动的Service。虽然这些进程用户无法直接看到,但它们做的事情却是用户所关心的(例如后台MP3回放或后台网络数据的上传下载)。因此,系统将一直运行这些进程除非内存不足以维持所有的前台进程和可见进程。

3.           后台(background)进程, 拥有一个当前用户看不到的Activity(它的onStop()方法被调用)。这些进程对用户体验没有直接的影响。如果它们正确执行了Activity生命期(详细信息可参考Activity),系统可以在任意时刻杀死进程来回收内存,并提供给前面三种类型的进程使用。系统中通常有很多个这样的进程在运行,因此要将这些进程保存在LRU 列表中,以确保当内存不足时用户最近看到的进程最后一个被杀掉。

4.           空(empty)进程,不包含任何处于活动状态的应用程序组件。保留这种进程的唯一原因是,当下次应用程序的某个组件需要运行时,不需要重新创建进程,这样可以提高启动速度。

系统将以进程中当前处于活动状态组件的重要程度为基础对进程进行分类。请参考Activity, Service BroadcastReceiver文档来获得有关这些组件在进程整个生命期中是如何起作用的详细信息。每个进程类别的文档详细描述了它们是怎样影响应用程序整个生命周期的。进程的优先级可能也会根据该进程与其它进程的依赖关系而增长。例如,如果进程A 通过在进程B中设置Context.BIND_AUTO_CREATE标记或使用ContentProvider被绑定到一个服务(Service),那么进程B在分类时至少要被看成与进程A同等重要。

 

翻译: 杨武学 yangwuxue@tom.com)

 

 

开发Android应用程序

你可以使用高质量的开发工具来开发Android应用程序,这些工具和你开发Java应用程序时使用的工具相同. Android 核心库提供了必要的功能,能够让你创建出丰富的令人惊讶的应用程序。Android的开发工具让程序的运行,调试和测试变成了一项非常轻松的工作。 这一节详细描述了开发Android应用程序的各项细节.。它简要阐述了系统的设计理念, 然后详细描述了每一个关键的子系统。 阅读完本节内容后,你将会获得必要的知识并且有信心开始将你头脑中的想法编写为真实的Android应用程序。


阅读本节之前,你应该先阅读Getting Started Guide. Getting Started Guide可以帮助你将Android SDK运行起来并向你演示如何构建一个基本的应用程序. 本节的内容将以Getting Started Guide提供的信息为基础。
下面是本节的内容:


实现一个用户界面 (Implementing a UI)
解释了如何为Android应用程序构建用户界面(UI)以及如何与用户界面进行交互.阅读完这一页的内容后,你将会深刻地理解Android 布局(layout)是如何构建出来的,是如何运转的,以及怎样才能使它们更漂亮。


结构描述(Building Blocks
Android
组件的详细描述。 它覆盖了 ”Android 应用程序剖析中涉及到的组件的细节, 还有更多的内容.本节将逐一详述Android的每一个关键组件(Intents, Activities, Views, events)


存取数据(Storing and Retrieving Data
怎样使用Android提供的各种各样的存储机制来读写数据,以及怎样使用网络服务存取数据。 有几种不同的方法从/Android 应用程序读/写数据, 每种方法对应不同的需求。这一页将描述所有的方法并解释如何根据你的需求选择正确的方法。


安全模型(Security Model
获得访问权限可以保证系统资源和功能模块(feature)的安全, 声明自己的权限可以对外界访问你自己功能模块的行为进行控制。权限可以控制是否允许一个应用程序访问另外一个应用程序提供的功能(例如,哪个程序可以通过手机拨电话)。这一页描述了权限是如何工作的, 如何请求权限,以及如何定义自己的权限。


资源和国际化(Resources and i18n
Android 应用程序资源管理系统的详细描述, 包括如何把它应用于国际化和本地化. “资源是应用程序的资产(例如图像, 本地化字符串, XML 布局), 它们在运行的时候被解析。这一页描述了Android是如何从资源集合中解析出它需要加载的资源,以及如何创建和使用资源。

 

翻译:杨武学 yangwuxue@tom.com)

 

 

实现一个用户接口

这个章节描述如何实现Android界面用户接口的一些基础内容。这包括组成一个屏幕的基本元素,如何使用XML定义屏幕,如何载入你的代码,以及定义接口时要处理的其他一些任务。

·             屏幕元素体系

·             通用布局对象

·             AdapterViews一起工作(结合数据)

·             XML文件设计你的界面

·             连接到一个屏幕元素

·             监听界面的通知

·             应用主题到应用程序

·             界面元素和术语

 

 

Android应用构成

Android应用是由各种各样的组件来构成。 这些组件大部分都是松散连接的,准确 的说你可以把它们看成组件的联合而非是一个单一的应用。

通常,这些组件运行在同一个系统进程里面。你也可以在这个进程里面创建多个线程 (这是很常见的),如果必要你也可以创建独立的子进程。不过这种情况是非常少见的, 因为Android尽力使代码进程间透明。

以下部分是很重要的Android APIs

AndroidManifest.xml

AndroidManifest.xml 是系统的控制文件,它告诉系统如何处理你所创建的所有 顶层组件(尤其是activities,服务,Intent接收器和后面描述的内容管理器)。举例 来说,控制文件就是把你的活动(Activities)要接收的Intents连接在一起的胶水

活动(Activities

活动(Activity)就是一个有生命周期的对象。 一个Activity就是完成某些工作的代码块, 如必要的话,这部分工作还可能包括对用户UI界面的显示。不过这不是必须的,有些活 动从不显示UI界面。典型地,你将会指定你的应用程序中的一个活动为整个程序的入口点。

视图(Views

视图(Views)可以将其自身绘制到屏幕上。Android的用户界面由一系列的视图树 trees of views)构成。接口都是由一组以树的形式出现的视图组成的。开发者可 以通过创建一个新的视图的方法来使用自定义的图形处理技术(比如开发游戏,或者是 使用了不常用的用户图形(UI)窗口界面(widget))

Intents

Intents是一个简单的消息对象,它表示程序想做某事的意图intention)。比 如如果你的应用程序想要显示一个网页,那么它通过创建一个Intent实例并将其传递给 系统来表示意图浏览这个URI。系统将定位于知道如何能处理这一Intent的代码(在当 前情况下就是浏览器),并运行之。Intents也可以用于广播系统范围内的有效事件 (例如通知事件)

服务(Services

服务是运行在后台的一段代码。它可以运行在它自己的进程,也可以运行在其他应用程 序进程的上下文(context)里面,这取决于自身的需要.。其它的组件可以绑定到一个服 务(Service)上面,通过远程过程调用(RPC)来调用这个方法。例如媒体播放器的服务, 当用户退出媒体选择用户界面,她仍然希望音乐依然可以继续播放,这时就是由服务 service)来保证当用户界面关闭时音乐继续播放的。

通知(Notifications

通知将以小图标的形式呈现在状态栏里,用户通过与图标的交互式操来接收消息。最常见 的通知包括短信息,通话记录,语音邮件,但是应用程序也可以创建它们自己的通知事件。 我们推荐采用通知事件实现提醒用户的注意。

内容管理器(ContentProviders

内容管理器(ContentProvider)提供对设备上数据进行访问的数据仓库。典型的例子就 是使用内容管理器来访问联系人列表。你的应用程序也可以使用其它程序通过内容管理器提 供的数据,同时你也可以定义你自己的内容管理器来向其它应用提供数据访问服务。

 

 

存、取、提供数据

典型的桌面操作系统一般能提供一种通用的文件系统,所有应用程序都能储存和读文件,并且其他应用程序也能访问该文件(可能需要一些访问控制设置). Android使用不同的方式:在平台上,所有应用程序的数据(包括文件),对该应用程序是私有的。当然,Android也提供一种标准方法将自己的私有数据提供给其他应用程序访问。这一章节讲了很多方法,描述应用如何存取数据,以及将数据提供给其他程序访问,当然,你也可以向其他应用程序请求并获得它的数据。

Android提供下面的方式来存取数据:

参数选择

使用一个轻量级机制来存取基本数据类型的数据对,这是典型应用程序参数的存储模式。

文件

你可以将你的文件存储在设备上或者其他移动媒介上,默认情况下,其他应用程序是不能访问这些文件的。

数据库

Android有直接SQLite数据库的API。应用程序可以创建以及使用SQLite数据库。 每个包创建的数据库都是私有的。

数据提供

数据提供是应用程序的一个可选组件,它可以提供读/写应用程序私有数据的方法。内容提供组件实现了一种标准请求数据的语法,和一种标准处理返回值的机制。Android提供很多标准数据的提供方式,例如私有联系人。

 

网络

不要忘记,我们还可以使用网络存取数据。

 

 

Android的安全与权限

Android是一个多进程系统,每一个应用程序(和系统的组成部分)都运行在自己的进程中。在应用程序和系统间的安全通过标准的Linux设备在进程级被执行,例如被分配给应用程序的用户和组ID。额外的细粒度安全特性通过许可机制来提供,该机制能够对一个指定进程可实现的特定操作进行约束。

安全结构

应用程序签名

用户标识和文件访问

权限命名

权限的声明和支持

AndroidManifest.xml文件中支持权限

发送广播时支持权限