51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译

Android基础知识详解

wuliming

wuliming_sc@qq.com

wuliming_sc@hotmail.com

92

2010.08
参考书目
目录

TOC \o "1-2" \z \u HYPERLINK \l "_Toc290755614" 参考书目 290755614 2

HYPERLINK \l "_Toc290755615" 目录 290755615 3

HYPERLINK \l "_Toc290755616" Android的系统架构 290755616 6

HYPERLINK \l "_Toc290755617" 一、应用程序 290755617 6

HYPERLINK \l "_Toc290755618" 二、应用程序框架 290755618 6

HYPERLINK \l "_Toc290755619" 三、Android Runtime 290755619 7

HYPERLINK \l "_Toc290755620" 四、系统库 290755620 7

HYPERLINK \l "_Toc290755621" 五、Linux 内核 290755621 8

HYPERLINK \l "_Toc290755622" Webkit浏览器引擎简介 290755622 9

HYPERLINK \l "_Toc290755623" Dalvik虚拟机简介 290755623 11

HYPERLINK \l "_Toc290755624" 什么是Dalvik虚拟机 290755624 11

HYPERLINK \l "_Toc290755625" Dalvik和Android系统 290755625 11

HYPERLINK \l "_Toc290755626" Dalvik虚拟机的主要特征 290755626 12

HYPERLINK \l "_Toc290755627" Android应用开发和Dalvik虚拟机 290755627 15

HYPERLINK \l "_Toc290755628" Activity生命周期 290755628 16

HYPERLINK \l "_Toc290755629" 一、Activity栈 290755629 16

HYPERLINK \l "_Toc290755630" 二、Activity的4种状态 290755630 16

HYPERLINK \l "_Toc290755631" 三、Activity的生命周期 290755631 17

HYPERLINK \l "_Toc290755632" 四、实例说明 290755632 18

HYPERLINK \l "_Toc290755633" Android控件的继承关系 290755633 22

HYPERLINK \l "_Toc290755634" 一、View与ViewGroup关系 290755634 22

HYPERLINK \l "_Toc290755635" 二、各控件的继承关系 290755635 23

HYPERLINK \l "_Toc290755636" 界面布局 290755636 25

HYPERLINK \l "_Toc290755637" LinearLayout(线性布局) 290755637 25

HYPERLINK \l "_Toc290755638" TableLayout(表格布局) 290755638 28

HYPERLINK \l "_Toc290755639" RelativeLayout(相对布局) 290755639 31

HYPERLINK \l "_Toc290755640" AbsoluteLayout(绝对布局) 290755640 34

HYPERLINK \l "_Toc290755641" FrameLayout(框架布局) 290755641 34

HYPERLINK \l "_Toc290755642" Toast 290755642 36

HYPERLINK \l "_Toc290755643" Notification 290755643 38

HYPERLINK \l "_Toc290755644" 对话框 290755644 42

HYPERLINK \l "_Toc290755645" 一、带三个按钮的对话框 290755645 42

HYPERLINK \l "_Toc290755646" 二、简单列表对话框、单选列表对话框、多选列表对话框 290755646 44

HYPERLINK \l "_Toc290755647" 三、水平进度对话框和圆形进度对话框 290755647 47

HYPERLINK \l "_Toc290755648" 四、自定义对话框 290755648 49

HYPERLINK \l "_Toc290755649" Menu菜单 290755649 52

HYPERLINK \l "_Toc290755650" 选项菜单 290755650 52

HYPERLINK \l "_Toc290755651" 上下文菜单 290755651 53

HYPERLINK \l "_Toc290755652" 三、子菜单 290755652 54

HYPERLINK \l "_Toc290755653" 4种响应菜单项单击事件的方式 290755653 56

HYPERLINK \l "_Toc290755654" 显示和编辑文本的控件 290755654 57

HYPERLINK \l "_Toc290755655" TextView 290755655 57

HYPERLINK \l "_Toc290755656" CheckedTextView 290755656 60

HYPERLINK \l "_Toc290755657" EditText 290755657 60

HYPERLINK \l "_Toc290755658" ExtraEditText 290755658 61

HYPERLINK \l "_Toc290755659" AutoComplteteTextView、MultiAutoCompleteTextView (自动完成输入内容) 290755659 61

HYPERLINK \l "_Toc290755660" Button 290755660 63

HYPERLINK \l "_Toc290755661" ImageButton 290755661 65

HYPERLINK \l "_Toc290755662" ZoomButton 290755662 65

HYPERLINK \l "_Toc290755663" 日期和时间控件 290755663 66

HYPERLINK \l "_Toc290755664" DatePicker、TimePicker 290755664 66

HYPERLINK \l "_Toc290755665" AnalogClock、DigitalClock 290755665 68

HYPERLINK \l "_Toc290755666" 单选框、复选框、开关状态按钮 290755666 69

HYPERLINK \l "_Toc290755667" 单项选择(RadioGroup、RadioButton) 290755667 69

HYPERLINK \l "_Toc290755668" 复选框(CheckBox) 290755668 71

HYPERLINK \l "_Toc290755669" 开关状态按钮(ToggleButton) 290755669 73

HYPERLINK \l "_Toc290755670" 下拉列表框Spinner 290755670 74

HYPERLINK \l "_Toc290755671" ScrollView、HorizontalScrollView 290755671 77

HYPERLINK \l "_Toc290755672" 垂直滚动（ScrollView） 290755672 77

HYPERLINK \l "_Toc290755673" 水平滚动（HorizontalScrollView） 290755673 78

HYPERLINK \l "_Toc290755674" 两个方向均可滚动 290755674 78

HYPERLINK \l "_Toc290755675" TabHost 290755675 79

HYPERLINK \l "_Toc290755676" ProgressBar、SeekBar、RatingBar 290755676 81

HYPERLINK \l "_Toc290755677" 进度条(ProgressBar) 290755677 81

HYPERLINK \l "_Toc290755678" 拖动条(SeekBar) 290755678 83

HYPERLINK \l "_Toc290755679" 评分组件(RatingBar) 290755679 86

HYPERLINK \l "_Toc290755680" GridView、Gallery和ImageSwitcher 290755680 88

HYPERLINK \l "_Toc290755681" GridView 290755681 88

HYPERLINK \l "_Toc290755682" Gallery和ImageSwitcher 290755682 91

HYPERLINK \l "_Toc290755683" ListView 290755683 94

HYPERLINK \l "_Toc290755684" 一、普通的ListView 290755684 94

HYPERLINK \l "_Toc290755685" 可以单选和多选的ListView 290755685 95

HYPERLINK \l "_Toc290755686" 使用SimpleAdapter建立复杂的列表项 290755686 97

HYPERLINK \l "_Toc290755687" 自定义Adapter来建立复杂的列表项 290755687 99

HYPERLINK \l "_Toc290755688" 动态添加、删除ListView列表项 290755688 102

HYPERLINK \l "_Toc290755689" 改变ListView列表项选中状态的背景颜色 290755689 102

HYPERLINK \l "_Toc290755690" 可展开的列表组件 290755690 102

HYPERLINK \l "_Toc290755691" 数据的存取 290755691 103

HYPERLINK \l "_Toc290755692" SharePreferences 6.1 290755692 103

HYPERLINK \l "_Toc290755693" 文件的存储6.2 290755693 103

HYPERLINK \l "_Toc290755694" SQLite数据库6.4 290755694 103

HYPERLINK \l "_Toc290755695" ContentProvider、ContentResolver 6.5 290755695 105

HYPERLINK \l "_Toc290755696" Intent 290755696 106

HYPERLINK \l "_Toc290755697" 用Intent启动Activity，并在Activity之间传递数据 290755697 106

HYPERLINK \l "_Toc290755698" 调用其他应用程序中的Activity(打电话、浏览网页、发Email等) 290755698 109

HYPERLINK \l "_Toc290755699" 接收和发送广播 290755699 113

HYPERLINK \l "_Toc290755700" 接收系统广播 290755700 113

HYPERLINK \l "_Toc290755701" 在自己的应用程序中发送广播 290755701 117

HYPERLINK \l "_Toc290755702" Android服务 290755702 118

HYPERLINK \l "_Toc290755703" 系统服务 8.2 290755703 118

HYPERLINK \l "_Toc290755704" 时间服务 8.3 290755704 118

HYPERLINK \l "_Toc290755705" 跨进程访问 8.4 290755705 118

HYPERLINK \l "_Toc290755706" 网络 290755706 119

HYPERLINK \l "_Toc290755707" 图形、音频、视频 290755707 120

HYPERLINK \l "_Toc290755708" 图形 10.1 290755708 120

HYPERLINK \l "_Toc290755709" 音频、视频 10.2 290755709 120

HYPERLINK \l "_Toc290755710" 2D动画 290755710 121

HYPERLINK \l "_Toc290755711" 帧动画 290755711 121

HYPERLINK \l "_Toc290755712" 补间动画 290755712 121

HYPERLINK \l "_Toc290755713" OpenGL ES编程 290755713 122

HYPERLINK \l "_Toc290755714" Android支持的各种资源 290755714 123

HYPERLINK \l "_Toc290755715" 窗口小部件(App Widget) 290755715 124

HYPERLINK \l "_Toc290755716" NDK编程 290755716 125

Android的系统架构

Android的系统架构和其操作系统一样，采用了分层的架构。从架构图看，android分为四个层，从上层到低层分别是应用程序层、应用程序框架层、Android运行时和库、linux内核：

一、应用程序

Android会同一系列核心应用程序包一起发布，该应用程序包包括电子邮件，短信，日历，地图，浏览器，联系人管理程序等。所有的应用程序都是使用JAVA语言编写的。当然，你也可以自己用自己编写的应用程序来替换Android提供的应用程序。

二、应用程序框架

应用程序框架是我们进行Android开发的基础，开发人员大部分情况下也是在和应用程序框架层打交道。应用程序框架层包括了活动管理器、窗口管理器、内容提供器、视图系统、包管理器、电话管理器、资源管理器、位置管理器、通知管理器九大部分，如上图所示。各部分的具体功能如下：

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

窗口管理器(Window Manager)：管理所有的窗口程序

内容提供器(Content Providers)：内容提供器使得应用程序可以访问另一个应用程序的数据，或者共享出它自己的数据

视图系统(View System)：丰富而又可扩展的各种视图，是构建应用程序的基本组件。 它包括列表，网格，文本框，按钮， 甚至是可嵌入的web浏览器等等

包管理器(Package Manager)：Android系统内的程序管理

电话管理器(Telephony Manager)：用来管理所有的移动设备的功能

资源管理器(Resource Manager)：提供各种资源让应用程序去使用，比如本地化字符串、图片、布局文件、视频文件等等

位置管理器(Location Manager)：用来提供位置服务

通知管理器(Notification Manager)：使应用程序可以在状态栏中显示警告信息。状态栏通常在手机的顶部，短信、邮件等的提示信息就会出现在这里

在Android平台上，开发人员可以完全访问核心应用程序所使用的API框架。并且，任何一个应用程序都可以发布自身的功能模块，而其他应用程序则可以使用这些已发布的功能模块。基于这样的重用机制，用户就可以方便地替换平台本身的各种应用程序组件。

三、Android Runtime

Android运行时包括核心库和Dalvik虚拟机两部分，这两部分的具体功能如下所示：

核心库：核心库包含两部分内容：一部分为绝大多数java语言所需要调用的功能函数，另一部分为Android的核心库，比如android.os、android.net、android.media等等。与标准java不一样的是，每个Android应用程序都有一个自有的进程，Android不是用一个Dalvik虚拟机来同时执行多个Android应用程序，而是每个Android应用程序都用一个自有的Dalvik虚拟机来执行。

Dalvik虚拟机：Dalvik是一种基于寄存器的java虚拟机，Dalvik虚拟机主要是完成对象生命周期的管理，堆栈的管理，线程管理，安全和异常的管理，以及垃圾回收等等重要功能。基于寄存器的虚拟机的一个优点就是所需要的资源相对较少，用硬件实现虚拟机比较容易一些。Dalvik虚拟机是专门为移动设备设计的，它在开发的时候就考虑到用最少的内存资源来执行，以及支持同时执行多个虚拟机的特性。Dalvik虚拟机所执行的中间码并非是java虚拟机所执行的java字节码，而是依靠转换工具dx将java字节码转换成 .dex 格式由虚拟机执行。Dalvik虚拟机与java虚拟机最大的不同在于java虚拟机基于栈，而Dalvik基于寄存器。

四、系统库

系统库各部分功能如下所示：

Surface Manager：对显示子系统进行管理，并且为多个应用程序提供了2D和3D图层的无缝融合

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

SQLite：一个对于所有应用程序可用，功能强劲的轻量级关系型数据库引擎

OpenGL ES：Android是依据OpenGL ES 1.0 API标准来实现其3D绘图函数库的，该函数库可以用软件方式执行，也可以用硬件加速方式执行，其中3D软件光栅处理方面已进行高度优化

FreeType：提供点阵字、向量字的描绘显示

WebKit：Wekbit是一个开源的Web浏览器引擎。Apple的Safari, Google的Chrome, Nokia S60平台的默认浏览器，Apple手机和Android手机的默认浏览器，都采用的是Webkit作为浏览器的引擎。另外两个浏览器引擎分别是Gecko和Trident，大名鼎鼎的Firefox便是使用的Gecko，而微软的IE系列则使用的是Trident。WebKit引擎比其它引擎更受程序员欢迎的原因，除了其引擎的高效稳定，兼容性好外，其源码结构清晰，易于维护，是一个很重要的原因。近年来，google的加入更是让Webkit有所升温，从 Goole Chrome浏览器, Goole Anroid手机操作系统内置浏览器均采用Webkit作为内核。

SGL： 2D绘图方面的绘图引擎

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

SSL：………………………………
五、Linux 内核

Android 的核心系统服务依赖于 Linux 2.6 内核，如安全性，内存管理，进程管理，网络协议栈和驱动模型。Linux内核也同时作为硬件和软件栈之间的抽象层。Linux内核中包含如下一些驱动：显示驱动、摄像头驱动、flash内存驱动、Binder(IPC)驱动、键盘驱动、Wifi驱动、Audio驱动、电源管理等等

WebKit简介参照其它总结材料

Dalvik虚拟机简介参照其它总结材料Webkit浏览器引擎简介

HYPERLINK "http://www.cnblogs.com/jyli/archive/2010/01/31/1660355.html" http://www.cnblogs.com/jyli/archive/2010/01/31/1660355.html
什么是Webkit

Wekbit是一个开源的Web浏览器引擎。Apple的Safari, Google的Chrome, Nokia S60平台的默认浏览器，Apple手机和Android手机的默认浏览器，都采用的是Webkit作为浏览器的引擎。另外两个浏览器引擎分别是Gecko和Trident，大名鼎鼎的Firefox便是使用的Gecko，而微软的IE系列则使用的是Trident。WebKit引擎比其它引擎更受程序员欢迎的原因，除了其引擎的高效稳定，兼容性好外，其源码结构清晰，易于维护，是一个很重要的原因。近年来，google的加入更是让Webkit有所升温，从 Goole Chrome浏览器, Goole Anroid手机操作系统内置浏览器均采用Webkit作为内核。

Wekbit做了什么？

作为浏览器的内核，Webkit做了哪些工作？为了了解这些，先让我们来看下一个Web浏览器究竟做了什么。我们可以从输入输出的角度来看一个Web浏览器为我们做了哪些工作。先看一个简单的例子，Web浏览器的输入是一个HTML文档，输出则是一个我们用眼睛所看到的一个Web页面, 就普通用户而言它的输入和输出就是这么简单，如下图所示：

INCLUDEPICTURE "http://images.cnblogs.com/cnblogs_com/jyli/webkit/browser_fun.jpg" \* MERGEFORMATINET

那么Webkit的输入和输出又是什么呢？如果能明白这个，那我们就能很清楚的知道Webkit到底是做什么的了。不过现在要说清楚这个还有点困难，因为Webkit的输出就要复杂些了，因为它的输出本来就非直接面向用户，简单点来说，Webkit的输入是web文档，输出是一些看不见的模型，浏览器上层借助于这些模型来绘制出我们所看到的实际页面。

 Webkit组成

Webkit实际上包含三大部分，至少从代码结构上来说是这样的，当然，如果细分的话还能够划分出更多的模块。如下所示

INCLUDEPICTURE "http://images.cnblogs.com/cnblogs_com/jyli/webkit/webkit_overview.jpg" \* MERGEFORMATINET

其中，WebCore是Webkit的核心部分，它实现了对文档的模型化，包括了CSS, DOM, Render等的实现；JavaSript Core显然是对JavaSript支持的实现(WebCore和JSCore来自于KDE项目的KHTML和KJS开源项目)。而橘黄色标注的Webkit部分包含了很多不同平台对Webkit封装的实现，即抽象出了与浏览器所能直接对应的一些概念的实现，比如WebView,WebPage, WebFrame等等。这三部分共同构成了Webkit, 在源码中，它们分别对应三个目录，即Webkit三大部分为WebCore, JavaSript Core,Webkit。

 

更多关于Webkit的介绍，搜索相关的资料…
Dalvik虚拟机简介

HYPERLINK "http://www.ophonesdn.com/article/show/15" http://www.ophonesdn.com/article/show/15
什么是Dalvik虚拟机

Google于2007年底正式发布了Android SDK, 作为 Android系统的重要特性，Dalvik虚拟机也第一次进入了人们的视野。它对内存的高效使用，和在低速CPU上表现出的高性能，确实令人刮目相看。依赖于底层Posix兼容的操作系统，它可以简单的完成进程隔离和线程管理。每一个Android应用在底层都会对应一个独立的Dalvik虚拟机实例，其代码在虚拟机的解释下得以执行。很多人认为Dalvik虚拟机是一个Java虚拟机，因为Android的编程语言恰恰就是Java语言。但是这种说法并不准确，因为Dalvik虚拟机并不是按照Java虚拟机的规范来实现的，两者并不兼容，同时还有两个明显的不同：

1、Java虚拟机运行的是Java字节码，而Dalvik虚拟机运行的则是其专有的文件格式DEX（Dalvik Executable）。

2、在Java SE程序中的Java类会被编译成一个或者多个字节码文件（.class）然后打包到JAR文件，而后Java虚拟机会从相应的CLASS文件和JAR文件中获取相应的字节码；Android应用虽然也是使用Java语言进行编程，但是在编译成CLASS文件后，还会通过一个工具（dx）将应用所有的CLASS文件转换成一个DEX文件，而后Dalvik虚拟机会从其中读取指令和数据。

Dalvik和Android系统

Android的系统架构和其操作系统一样，采用了分层的架构。从架构图看，android分为四个层，从上层到低层分别是应用程序层、应用程序框架层、Android运行时和库、linux内核：
如图所示，Android RunTime包括两部分：核心库和Dalvik虚拟机。核心库包括了最基本的类库，如data structure, network, Utilities, File system等的，很多实现代码都是来自 HYPERLINK "http://harmony.apache.org/" Apache Harmony项目，主要目的是保证虚拟机的类库能够和Java SE的类库最大可能的兼容，从而降低应用开发者从Java SE阵营转移到Android开发阵营的难度，增加其可用性。Dalvik虚拟机主要是完成对象生命周期的管理，堆栈的管理，线程管理，安全和异常的管理，以及垃圾回收等等重要功能。

Dalvik虚拟机的主要特征

Dalvik虚拟机非常适合在移动终端上使用，相对于在桌面系统和服务器系统运行的虚拟机而言，它不需要很快的CPU速度和大量的内存空间。根据Google的测算，64M的RAM已经能够令系统正常运转了。其中24M被用于底层系统的初始化和启动，另外20M被用于高层启动高层服务。当然，随着系统服务的增多和应用功能的扩展，其所消耗的内存也势必越来越大。归纳起来，Dalvik虚拟机有如下几个主要特征:

一、专有的DEX文件格式

DEX是Dalvik虚拟机专用的文件格式，而为什么弃用已有的字节码文件（CLASS文件）而采用新的格式呢?

1、一个应用中会定义很多类，编译完成后即会有很多相应的CLASS文件，CLASS文件间会有不少冗余的信息；而DEX文件格式会把所有的CLASS文件内容整合到一个文件中。这样，除了减少整体的文件尺寸，I/O操作，也提高了类的查找速度。原来每个类文件中的常量池，在DEX文件中由一个常量池来管理，具体方式如下图：2、增加了新的操作码的支持

3、文件结构尽量简洁，使用等长的指令，借以提高解析速度

4、尽量扩大只读结构的大小，借以提高跨进程的数据共享

如何生成DEX文件呢？Android系统和Dalvik虚拟机提供了工具（DX）,在把Java源代码编译成CLASS文件后，使用DX工具。
二、DEX的优化

DEX文件的结构是紧凑的，如果我们还想要求运行时的性能有进一步提高，我们就仍然需要对DEX文件进行进一步优化。优化主要是针对以下几个方面：

1、调整所有字段的字节序（LITTLE_ENDIAN）和对齐结构中的每一个域

2、验证DEX文件中的所有类

3、对一些特定的类进行优化，对方法里的操作码进行优化。

优化后的文件大小会有所增加，应该是原DEX文件的1-4倍。优化发生的时机有两个：对于预置应用，可以在系统编译后，生成优化文件，以ODEX结尾。这样在发布时除APK文件（不包含DEX）以外，还有一个相应的ODEX文件；对于非预置应用，包含在APK文件里的DEX文件会在运行时被优化，优化后的文件将被保存在缓存中。
三、基于寄存器

相对于基于堆栈的虚拟机实现，基于寄存器的虚拟机实现虽然在硬件通用性上要差一些，但是它在代码的执行效率上却更胜一筹。一般来讲，虚拟机中指令的解释执行时间主要花在以下三个方面：

1、分发指令

2、访问运算数

3、执行运算

其中“分发指令”这个环节对性能的影响最大。在基于寄存器的虚拟机里，可以更为有效的减少冗余指令的分发和减少内存的读写访问，如：
虽然Dalvik虚拟机并没有使用目前流行的虚拟机技术，如JIT，但是根据Google的报告，这个功能的缺失并没有让Dalvik虚拟机在性能上有所损失。我们也相信，Dalvik虚拟机的性能还有进一步提高的空间。 
四、一个应用，一个虚拟机，一个进程

每一个Android应用都运行在一个Dalvik虚拟机实例里，而每一个虚拟机实例都是一个独立的进程空间。虚拟机的线程机制，内存分配和管理，Mutex等等都是依赖底层操作系统而实现的。所有Android应用的线程都对应一个Linux线程，虚拟机因而可以更多的依赖操作系统的线程调度和管理机制。

不同的应用在不同的进程空间里运行，加之对不同来源的应用都使用不同的Linux用户来运行，可以最大程度的保护应用的安全和独立运行。

Zygote是一个虚拟机进程，同时也是一个虚拟机实例的孵化器，每当系统要求执行一个Android应用程序，Zygote就会FORK出一个子进程来执行该应用程序。这样做的好处显而易见：Zygote进程是在系统启动时产生的，它会完成虚拟机的初始化，库的加载，预置类库的加载和初始化等等操作，而在系统需要一个新的虚拟机实例时，Zygote通过复制自身，最快速的提供个系统。另外，对于一些只读的系统库，所有虚拟机实例都和Zygote共享一块内存区域，大大节省了内存开销。
      应用程序包（APK）被发布到手机上后，运行前会对其中的DEX文件进行优化，优化后的文件被保存到缓存区域（优化后的格式被称为DEY），虚拟机会直接执行该文件。如果应用包文件不发生变化，DEY文件不会被重新生成。Android应用开发和Dalvik虚拟机

Android应用所使用的编程语言是Java语言，和Java SE一样，编译时使用Sun JDK将Java源程序编程成标准的Java字节码文件（.class文件），而后通过工具软件DX把所有的字节码文件转成DEX文件（classes.dex）。最后使用Android打包工具（aapt）将DEX文件，资源文件以及AndroidManifest.xml文件（二进制格式）组合成一个应用程序包（APK）。应用程序包可以被发布到手机上运行。

Activity生命周期

一、Activity栈

Android系统中，所有Acitivity被保存在Activity栈中。当启动一个新的Activity时，这个Activity就被压入Activity栈的顶部。如果用户通过返回键回到上一个Activity的画面，则栈顶的Activity将被弹出，下一个Activity就变成新的栈顶Activity，并显示在屏幕上。下图显示了Activity栈的运作方式：
二、Activity的4种状态

Activity状态的变化完全由Android的内存管理器决定，变化顺序是不确定的，用户无法预知。Activity从创建到关闭，可能经历下面的4种状态：

1、活跃状态：当一个Activity位于Activity栈的顶部时，它所代表的用户界面位于屏幕的最前端。也就是说，此时Activity代表的界面对用户来说是可见的，同时用户还可以在这个界面上进行操作。Android会尽可能维持处于活跃状态的Activity，采取的措施包括中止位于Activity栈上其他的Activity，以便释放资源。此时如果另一个Activity的状态变为活跃，之前活跃的Activity将变为暂停。

2、暂停状态：有一种特殊情况，Activity对用户来说是可见的，但是它并不拥有用户输入的焦点，如果Activity处于这种状态，我们就称之为暂停的Activity。这种情况发生的场景通常是：在应用程序的前端有一个透明的、或者非全屏显示的Activity，处于暂停状态的Activity的界面位于这个透明的、或者非全屏显示的界面下面。一般情况下，Android也不会结束处于暂停状态的Activity，但是如果资源极其匮乏，系统也有可能结束暂停的Activity。[在程序中模拟这样的情况]

3、结束状态：Activity所显示的界面在屏幕上不可见，那么它的状态就是结束状态。系统会在内存中保存处于结束状态的Activity的状态信息，以便该Activity重新变为可见的时候，状态能够迅速切换。当系统内存不足需要释放内存资源时，处于结束状态的Activity是首选对象。

4、销毁状态：当Activity彻底结束或者关闭后，它的状态就变为非活跃状态，这时Activity已经从Activity栈上移除。
 

三、Activity的生命周期
从上图可以看到，有3个比较关键的生命周期循环：

   1、activity完整的生命周期 自第一次调用 onCreate()开始，直至调用onDestroy()为止。activity在onCreate()中初始化Activity，而在onDestroy()中释放所有系统资源。比如说，如果activity有一个线程在后台运行以从网络上下载数据，它会以 onCreate()创建那个线程，而以 onDestroy()销毁那个线程。

    2. activity的可见生命周期 自onStart() 调用开始直到对应的onStop()调用。当Activity运行到onStart()时，用户可以在屏幕上看到此Activity，当Activity运行到onStop()时，这个Activity就从屏幕上消失。在此期间，Activity对用户来说是可见的，虽然有时候Activity并不拥有对用户的输入焦点。

   3. activity的活跃生命周期 自onResume()调用起，到对应的onPause()调用为止。在此期间，用户不仅能够看到Activity，还能够通过屏幕获得输入的焦点。和可见生命周期类似，在Activity完整的生命周期中可能经历多个活跃生命周期。尽可能保持onPouse()和 onResume()的简洁，这样能够使得应用程序切换的时候响应迅速（需要注意的是，在内存不足的时候，onPause()、onStop()这两种状态是可以被系统直接kill的）

四、实例说明

当activity从一个状态转变到另一个状态时，Activity类中对应于该状态的方法将被调用：

onCreate()

onStart()

onResume()

onPause()

onStop()

onDestroy()

 我们可以重载所有这些方法以便在状态改变时做一些合适的工作。所有的activity都必须实现onCreate()用以当对象第一次实例化时进行初始化设置。很多activity会实现 onPause()以提交数据变化或准备停止与用户的交互。
 具体代码参见附件，这里仅仅列出重要的部分：

AndroidManifest.xml




package="com.studio.android"

android:versionCode="1"

android:versionName="1.0">




android:label="@string/app_name">


















ActivityLifeCycle.java

package com.studio.android;
import android.app.Activity;

import android.app.AlertDialog;

import android.content.DialogInterface;

import android.content.Intent;

import android.content.DialogInterface.OnClickListener;

import android.os.Bundle;

import android.util.Log;

import android.view.View;

import android.widget.Button;
public class ActivityLifeCycle extends Activity {



private static final String TAG = "[LifeCycle]";

private Button btnOpenDialog;

private Button btnOtherActivity;



@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);



initialView();//对控件进行各种初始化操作



Log.i(TAG, "onCreate");

}



@Override

public void onRestart()

{

super.onRestart();

Log.i(TAG, "onRestart");

}



@Override

public void onStart()

{

super.onStart();

Log.i(TAG, "onStart");

}



@Override

public void onResume()

{

super.onResume();

Log.i(TAG, "onResume");

}



@Override

public void onPause()

{

super.onPause();

Log.i(TAG, "onPause");

}



@Override

public void onStop()

{

super.onStop();

Log.i(TAG, "onStop");

}



@Override

public void onDestroy()

{

super.onDestroy();

Log.i(TAG, "onDestroy");

}



private void initialView()

{

btnOpenDialog = (Button)this.findViewById(R.id.btnOpenDialog);

btnOtherActivity = (Button)this.findViewById(R.id.btnOtherActivity);



Button.OnClickListener btnOpenDialogListener = new Button.OnClickListener(){

public void onClick(View v) {

new AlertDialog.Builder(ActivityLifeCycle.this)

.setIcon(android.R.drawable.ic_dialog_info)

.setTitle("欢迎")

.setMessage("欢迎使用本程序,Activity生命周期测试.")

.setPositiveButton("确定", new OnClickListener(){

public void onClick(DialogInterface dialog, int which) {

// TODO Auto-generated method stub

}

}).create().show();

}

};



Button.OnClickListener btnOtherActivityListener = new Button.OnClickListener(){

public void onClick(View v) {

Intent intent = new Intent(ActivityLifeCycle.this,OtherActivity.class);

startActivity(intent);

}

};



btnOpenDialog.setOnClickListener(btnOpenDialogListener);

btnOtherActivity.setOnClickListener(btnOtherActivityListener);

}

}
运行后模拟器的界面如下：

五、根据log信息，详细分析Activity的生命周期

1、启动该程序：

 

Activity的启动顺序是onCreate -> onStart -> onResume
2、启动然后退出该程序：
退出当前Activity时，onPause -> onStop -> onDestory
3、启动改程序，然后点击“open dialog”按钮，打开一个新的按钮：
我们发现打开或者关闭对话框时log信息无任何变化，这说明打开对话框不会影响当前activity的状态变化。
4、预留问题：用非全屏显示的Activity，或者透明的Activity，模拟那种从运行到暂停的状态变化
5、先启动ActivityLifeCycle，然后启动另外一个Activity1，最后返回ActivityLifeCycle：

INCLUDEPICTURE "C:\\DOCUME~1\\reanow\\LOCALS~1\\Temp\\}DB9$2C[($U%E4UK0W)53SR.jpg" \* MERGEFORMATINET

注意，这里所打印出来的log信息，都是ActivityLifeCycle这个Activity里面的，进入另外的Activity1时相关的log信息未成打印出来。
6、启动改程序，然后按Ctrl+F12切换屏幕方向，然后按返回键退出该程序：保存activity状态

protected void onSaveInstanceState (Bundle outState)

protected void onRestoreInstanceState (Bundle savedInstanceState)Android控件的继承关系

一、View与ViewGroup关系

View：View是可视化控件的基类，它主要提供了控件描绘和事件处理的方法。而可视化控件，是指重新实现了View的绘制和事件处理方法并最终与用户交互的对象，如文本显示、按钮等等。

ViewGroup：ViewGroup类也是继承自View类，ViewGroup的作用就是作为View的容器，它负责对添加进ViewGroup的这些View进行管理和布局。一个ViewGroup还可以加入到另外一个ViewGroup里面。布局相关的控件并不直接显示给用户，其主要功能在于控制子控件在屏幕上的摆放位置。

ViewGroup的嵌套关系：ViewGroup的继承关系图：
二、各控件的继承关系三、视图的显示控制

《Android/Ophone开发完全讲义》P34~38

使用XML布局文件控制视图 《Android/Ophone开发完全讲义》4.2.2

在代码中控制视图 《Android/Ophone开发完全讲义》4.2.3界面布局

为了适应各式各样的界面风格，Android系统提供了5种布局，这5种布局分别是：

LinearLayout(线性布局)

TableLayout(表格布局)

RelativeLayout(相对布局)

AbsoluteLayout(绝对布局)

FrameLayout(框架布局)

利用这五种布局，可以在屏幕上将控件随心所欲的摆放，而且控件的大小和位置会随着屏幕大小的变化作出相应的调整。下面是这五个布局在View的继承体系中的关系：
LinearLayout(线性布局)

线性布局是程序中最常见的一种布局方式，线性布局可以分为水平线性布局和垂直线性布局两种，通过android:orientation属性可以设置线性布局的方向。下面是一个简单的线性布局的例子：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

>


android:layout_width="fill_parent"

android:layout_height="wrap_content" />


android:orientation="horizontal"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:gravity="right">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="确定"/>


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="取消" />





对应的模拟器上的布局效果以及框架图如下所示：
最外层布局为垂直线性布局，宽度为整个屏幕(fill_parent)，高度为刚好适合子控件(wrap_content)。然后依次添加一个EditText，一个水平布局的LinearLayout，在这个线性布局里面，摆放两个Button，该线性布局的gravity属性设置为”right”，所以里面的两个Button靠右显示。

android:gravity

LinearLayout标签有一个非常重要的属性gravity，该属性用于控制布局中控件的对齐方式。如果是没有子控件的控件设置此属性，表示其内容的对齐方式，比如说TextView里面文字的对齐方式；若是有子控件的控件设置此属性，则表示其子控件的对齐方式，比如上面例子里面的两个Button的对齐方式。gravity可以取以下值，如果需要设置多个属性值，需要使用“|”进行组合：
android:gravity与android:layout_gravity的区别：android:gravity定义了这个元素内所有子元素对于这个元素的布局，比如一个TextView内部文字的对齐方式；android:layout_gravity定义了这个元素相对于父元素(比如Layout)的布局，比如一个TextView在整个Layout中的位置。这两个属性对应的常量值都是一样的，如上表所示。

2、android: layout_weight

首先需要注意的是，没有android:weight这样的属性，这个与上面的android:gravity不一样。我们可以通过设置控件的layout_weight属性以控制各个控件在布局中的相对大小。layout_weight属性是一个非负整数值。线性布局会根据该控件layout_weight值与其所处布局中所有控件layout_weight值之和的比值为该控件分配占用的区域。例如，在水平布局的LinearLayout中有两个Button，这两个Button的layout_weight属性值都为1，那么这两个按钮都会被拉伸到整个屏幕宽度的一半。如果layout_weight指为0，控件会按原大小显示，不会被拉伸；对于其余layout_weight属性值大于0的控件，系统将会减去layout_weight属性值为0的控件的宽度或者高度，再用剩余的宽度或高度按相应的比例来分配每一个控件显示的宽度或高度。下例简要说明该属性的用法：




android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_weight="1">


android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_weight="1">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="左上按钮"

android:layout_gravity="left" />




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_weight="1">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="右上按钮"

android:layout_gravity="right" />







android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_weight="1"

android:gravity="center">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="中心按钮" />





android:orientation="horizontal"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_weight="1">


android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_weight="1"

android:gravity="left|bottom">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="左下按钮" />




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_weight="1"

android:gravity="right|bottom">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="右下按钮"/>







对应的模拟器上的布局效果以及框架图如下所示：

INCLUDEPICTURE "C:\\DOCUME~1\\reanow\\LOCALS~1\\Temp\\%GGHL0NUXRWF(}26U2_H_~X.jpg" \* MERGEFORMATINET

TableLayout(表格布局)

表格布局模型以行列的形式管理子控件，每一行为一个TableRow的对象，当然也可以是一个View的对象。TableRow可以添加子控件，每添加一个为一列。

android:layout_colum官方解释：The index of the column in which this child should be，也即是设置该控件在TableRow中所处的列。

android:layout_span官方解释：Defines how many columns this child should span，也即是设置该控件所跨越的列数。

android:collapseColumns官方解释：The 0 based index of the columns to collapse. The column indices must be separated by a comma: 1, 2, 5.也即是将TableLayout里面指定的列隐藏，若有多列需要隐藏，请用逗号将需要隐藏的列序号隔开。

android:stretchColumns官方解释：The 0 based index of the columns to stretch. The column indices must be separated by a comma: 1, 2, 5. You can stretch all columns by using the value "*" instead. Note that a column can be marked stretchable and shrinkable at the same time.也即是设置指定的列为可伸展的列，可伸展的列会尽量伸展以填满所有可用的空间，若有多列需要设置为可伸展，请用逗号将需要伸展的列序号隔开。

android:shrinkColumns官方解释：The 0 based index of the columns to shrink. The column indices must be separated by a comma: 1, 2, 5. You can shrink all columns by using the value "*" instead. 设置指定的列为可收缩的列。当可收缩的列太宽以至于让其他列显示不全时，会纵向延伸空间。当需要设置多列为可收缩时，将列序号用逗号隔开。



下面用一个例子简单说明TableLayout的用法：




android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:stretchColumns="1">



android:layout_column="1"

android:text="打开..."

android:padding="3dip" />


android:text="Ctrl-O"

android:gravity="right"

android:padding="3dip" />






android:layout_column="1"

android:text="保存..."

android:padding="3dip" />


android:text="Ctrl-S"

android:gravity="right"

android:padding="3dip" />






android:layout_column="1"

android:text="另存为..."

android:padding="3dip" />


android:text="Ctrl-Shift-S"

android:gravity="right"

android:padding="3dip" />



android:layout_height="2dip"

android:background="#FF909090" />



android:text="*"

android:padding="3dip" />


android:text="导入..."

android:padding="3dip" />





android:text="*"

android:padding="3dip" />


android:text="导出..."

android:padding="3dip" />


android:text="Ctrl-E"

android:gravity="right"

android:padding="3dip" />



android:layout_height="2dip"

android:background="#FF909090" />



android:layout_column="1"

android:text="退出"

android:padding="3dip" />




对应的模拟器效果图如下所示：

INCLUDEPICTURE "C:\\DOCUME~1\\reanow\\LOCALS~1\\Temp\\~`O8M5B1_0{1OCM[]ZEGYNP.jpg" \* MERGEFORMATINET

从效果图可以看出，该布局总共有三列，第一个TableRow里面的控件，从第1列开始布局。如果去掉所有控件的属性” android:layout_column="1"”，显示效果如下所示(总共3列，也即第0、1、2列，每一列都用虚线框标示)：

INCLUDEPICTURE "C:\\DOCUME~1\\reanow\\LOCALS~1\\Temp\\C}9O%4OPA{0FW$OS0(19421.jpg" \* MERGEFORMATINET
另外一个例子

布局文件如下所示：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

>


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:collapseColumns="1" >


android:text="表一"

android:gravity="center"

/>




android:text="列0"

android:background="@drawable/dot"/>


android:text="列1"

android:background="@drawable/dot"/>








android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:stretchColumns="1">
将列序号用逗号隔开，例如：android:stretchColumns=“0,1”-->


android:text="表二"

android:gravity="center" />




android:text="列0不能伸展"

android:background="@drawable/dot"/>


android:text="列1可以伸展"

android:gravity="right"

android:background="@drawable/dot"/>





android:layout_width="fill_parent"

android:layout_height="wrap_content" >


android:text="表三"

android:gravity="center" />




android:text="这一列很长，将会造成下一列无法显示或显示不全"

android:background="@drawable/dot" />


android:text="这一列被挤到了屏幕外"

android:background="@drawable/dot"/>





android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:shrinkColumns="0">
当需要设置多列为可收缩时，将列序号用逗号隔开，例如：android:shrinkColumns=“0,1”-->


android:text="表四"

android:gravity="center"

/>




android:text="由于设置成了可收缩，所以这一列不管有多长都不会把其他列挤出去"

android:background="@drawable/dot" />


android:text="这一列会被显示完全"

android:background="@drawable/dot" />







对应的模拟器效果图如下所示：

INCLUDEPICTURE "C:\\DOCUME~1\\reanow\\LOCALS~1\\Temp\\XN{5@X)SJ8I9C9P[X7YF9B5.jpg" \* MERGEFORMATINET

布局分析：最外层用了一个垂直的linearLayout来放置里面的4个TableLayout，每个TableLayout由两行构成，分别是一个TextView和一个TableRow，每一个TableRow都由两个TextView组成了两列。

RelativeLayout(相对布局)

相对布局的子控件会根据它们所设置的参照控件和参数进行相对布局。参照控件可以是父控件，也可以是其它子控件，但是被参照的控件必须要在参照它的控件之前定义。下面是一个简单的例子：




android:layout_width="fill_parent"

android:layout_height="fill_parent"

>


android:id="@+id/aclock"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_centerInParent="true" />


android:id="@+id/dclock"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_below="@id/aclock"
该数字时钟会顶到左屏幕边显示-->

android:layout_alignLeft="@id/aclock"
如果没有设置marginLeft 属性的话-->

android:layout_marginLeft="40px" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="当前时间："

android:layout_toLeftOf="@id/dclock"

android:layout_alignTop="@id/aclock"/>



对应的模拟器效果图如下所示：另外一个相对布局的例子：




android:layout_width="fill_parent" android:layout_height="fill_parent" >


android:layout_height="wrap_content" android:textSize="20dp"

android:text="按钮1"/>


android:layout_height="wrap_content" android:textSize="20dp"

android:text="按钮2" android:layout_toRightOf="@id/button1"

android:layout_below="@id/button1" />


android:layout_height="wrap_content" android:textSize="20dp"

android:text="按钮3" android:layout_toLeftOf="@id/button2"

android:layout_below="@id/button2" />


android:layout_height="wrap_content" android:textSize="20dp"

android:text="按钮4" android:layout_toRightOf="@id/button2"

android:layout_above="@id/button2" />


android:layout_height="wrap_content" android:textSize="20dp"

android:text="按钮5" android:layout_toRightOf="@id/button2"

android:layout_below="@id/button2" />



对应的模拟器效果图如下所示：
AbsoluteLayout(绝对布局)

绝对布局的子控件需要指定相对于此坐标布局的横纵坐标值，否则将会像框架布局那样被排在左上角。手机应用需要适应不同的屏幕大小，而这种布局模型不能自适应屏幕尺寸大小，所以应用的相对较少。下面以一个例子简单说明绝对布局：



android:layout_width="fill_parent"

android:layout_height="fill_parent"

>


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="语文"

android:layout_x="10px"

android:layout_y="10px" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="数学"

android:layout_x="30px"

android:layout_y="30px" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="英语"

android:layout_x="50px"

android:layout_y="50px" />



FrameLayout(框架布局)

框架布局是最简单的布局形式。所有添加到这个布局中的视图都以层叠的方式显示。第一个添加的控件被放在最底层，最后一个添加到框架布局中的视图显示在最顶层，上一层的控件会覆盖下一层的控件。这种显示方式有些类似于堆栈。




android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="300dp"

android:layout_height="300dp"

android:layout_gravity="center"

android:background="#FF33ffff" />


android:layout_width="240dp"

android:layout_height="240dp"

android:layout_gravity="center"

android:background="#FF33ccff" />


android:layout_width="180dp"

android:layout_height="180dp"

android:layout_gravity="center"

android:background="#FF3399ff" />


android:layout_width="120dp"

android:layout_height="120dp"

android:layout_gravity="center"

android:background="#FF3366ff" />


android:layout_width="60dp"

android:layout_height="60dp"

android:layout_gravity="center"

android:background="#FF3300ff" />



Toast

我们可以用对话框显示各种信息来提示用户应用程序处于某个状态，或者完成了某项任务。但是对话框是以独占方式显示的，也就是说，如果不关闭对话框，就无法做其他的事情。Android提供了Toast来解决这个问题。通过Toast显示提示信息，就算提示信息还未关闭，用户也可以做其他的事情。如果只想在Toast上面显示文本信息，可以使用如下所示的代码：

Toast textToast = Toast.makeText(this, "这里是用Toast显示的提示信息... ", Toast.LENGTH_LONG);

textToast.show();

该段代码使用Toast类的静态方法创建了一个Toast对象。该方法的第二个参数表示要显示的文本信息，第三个参数表示Toast提示信息显示的时间长短。该参数可以设置为Toast.LENGTH_SHORT（提示框在较短时间内关闭）或者Toast.LENGTH_LONG（提示框在较长时间内关闭）。Toast信息提示框没有按钮，也无法通过手机按键来关闭它，只能通过显示时间的长短来控制Toast信息提示框的关闭。

创建Toast对象时请注意，在创建只显示文本的Toast对象时建议使用makeText方法，而不要直接使用new关键字创建Toast对象。虽然Toast有setText方法，但是不能在使用new关键字创建Toast对象后，再使用setText方法设置Toast信息提示框的文本信息。也就是说，下面的代码会抛异常：

Toast toast = new Toast(this);

toast.setText("这里是用Toast显示的提示信息... "); //执行这段代码会抛异常

toast.show();

如果现在Toast提示框上显示更加丰富的内容，可以使用Toast类的setView方法设置一个View对象，代码如下：

View view = getLayoutInflater().inflate(R.layout.toast, null);

TextView textView = (TextView) view.findViewById(R.id.textview);

textView.setText("这里是用Toast显示的\n提示信息...");

Toast toast = new Toast(this);

toast.setDuration(Toast.LENGTH_LONG);

toast.setView(view);

toast.show();

为什么使用new创建一个Toast对象后，能够使用setView方法将一个View对象放在Toast提示框上，而不能通过setText来设置文本信息呢？其实makeText方法的代码和上面这段代码类似，同样是使用setView方法设置了一个View对象，Toast方法实际上就是通过一个View对象来显示信息的。如果创建Toast对象时未使用makeText方法，而是用new，那么在调用setText方法时View对象还没有创建出来(setText并不会负责创建对象的)，系统自然会抛出异常了。

如果同时有多条信息需要用Toast显示，系统会将这些信息缓存起来，等前一个Toast信息提示框关闭后，才会显示下一个Toast信息提示框。Toast信息提示框是顺序显示的。下面以一个例子说明Toast的使用：

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent" >


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="只显示文本的Toast" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="显示文本和图像的Toast" />


toast.xml：




android:orientation="horizontal"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:background="#555"

android:layout_margin="10dp">


android:layout_height="50dp"

android:alt="51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译" src="@drawable/face" />


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:layout_margin="10dp" />


main.java：

public class Main extends Activity implements OnClickListener

{

public void onClick(View v)

{

switch (v.getId())

{

case R.id.btnTextToast:

Toast textToast = Toast.makeText(this, "这里是用Toast显示的\n提示信息...",Toast.LENGTH_LONG);

textToast.show();

break;

case R.id.btnImageToast:

View view = getLayoutInflater().inflate(R.layout.toast, null);

TextView textView = (TextView) view.findViewById(R.id.textview); //R.id.textview是在toast.xml文件中定义的控件

textView.setText("这里是用Toast显示的\n提示信息...");

Toast toast = new Toast(this);

toast.setDuration(Toast.LENGTH_LONG);

toast.setView(view);

toast.show();

break;

}

}
public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

Button btnTextToast = (Button) findViewById(R.id.btnTextToast);

Button btnImageToast = (Button) findViewById(R.id.btnImageToast);

btnTextToast.setOnClickListener(this);

btnImageToast.setOnClickListener(this);

}

}
模拟器：Notification

Notification与Toast都可以起到通知、提醒的作用，但它们的实现原理和表现形式完全不一样。Toast相当于一个没有按钮的对话框。Notification是显示在屏幕上方状态栏中的信息，并且Notification需要用NotificationManager来管理，而Toast只需要简单创建Toast对象即可。下面来看创建并显示一个Notification的步骤：

NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

Notification notification = new Notification(resId, tickerText, System.currentTimeMillis());

PendingIntent contentIntent = PendingIntent.getActivity(this, 0, getIntent(), 0);

notification.setLatestEventInfo(this, contentTitle, contentText, contentIntent);

notificationManager.notify(id, notification);

（1）、通过getSystemService方法获得一个NotificationManager对象

（2）、创建一个Notification对象。这一步设置显示在屏幕上方状态栏的通知消息对应的图像资源ID、通知消息内容、该通知将要发出的时间(一般设置为当前时间)

（3）、由于Notification可以与应用程序脱离，也就是说，即使应用程序关闭，Notification仍然会显示在状态栏中。因此，需要创建一个PendingIntent对象，该对象由Android系统负责维护。

（4）、使用Notification类的setLatestEventInfo方法设置Notification的详细信息，也就是将状态栏往下拖拽，在这部分里面显示的详细的提示信息。包括提示信息的标题，提示信息的具体内容等等。

（5）、使用NotificationManager类的notify方法显示Notification消息。这一步需要指定标示该Notification消息的唯一ID。这个ID必须相对于同一个NotificationManager对象是唯一的，否则会覆盖相同ID的Notification。为了使这个值唯一，我们可以使用res目录中的某些资源ID，比如对应的图像资源的ID。

如果需要清除某个消息，可以使用NotificationManager类的cancel方法，该方法只有一个参数，表示要清除的Notification的ID。使用cancelAll可以清除当前NotificationManager对象中所有的Notification。下面以一个实例详细说明相关的概念：
AndroidManifest.xml：




package="net.blogjava.mobile"

android:versionCode="1"

android:versionName="1.0">




android:label="@string/app_name">


















main.xml：




android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent">




android:layout_height="wrap_content" android:text="我今天非常高兴"

android:drawablePadding="10dp" android:drawableLeft="@drawable/smile" />

android:layout_height="wrap_content" android:text="这是为什么呢?"

android:drawablePadding="10dp" android:drawableLeft="@drawable/why" />




android:layout_height="wrap_content" android:text="今天心情不好"

android:drawablePadding="10dp" android:drawableLeft="@drawable/wrath" />

android:layout_height="wrap_content" android:text="使用默认的声音" />




android:layout_height="wrap_content" android:text="使用默认的震动" />




android:layout_height="wrap_content" android:text="使用默认的Light" />




android:layout_height="wrap_content" android:text="所有的都使用默认值" />




android:layout_height="wrap_content" android:text="清除通知" />


main.java：

public class Main extends Activity implements OnClickListener

{

private NotificationManager notificationManager;



@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);



notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

Button btnSmile = (Button) findViewById(R.id.btnSmile);

Button btnWhy = (Button) findViewById(R.id.btnWhy);

Button btnWrath = (Button) findViewById(R.id.btnWrath);

Button btnClear = (Button) findViewById(R.id.btnClear);

Button btnRing = (Button) findViewById(R.id.btnRing);

Button btnVibrate = (Button) findViewById(R.id.btnVibrate);

Button btnLight = (Button) findViewById(R.id.btnLight);

Button btnRingAndVibrate = (Button) findViewById(R.id.btnRingAndVibrate);



btnSmile.setOnClickListener(this);

btnWhy.setOnClickListener(this);

btnWrath.setOnClickListener(this);

btnClear.setOnClickListener(this);

btnRing.setOnClickListener(this);

btnVibrate.setOnClickListener(this);

btnLight.setOnClickListener(this);

btnRingAndVibrate.setOnClickListener(this);

}



private void setDefaults(String tickerText, String contentTitle, String contentText, int id, int resId, int defaults)

{

Notification notification = new Notification(resId, tickerText, System.currentTimeMillis());

PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, Main.class), 0);

notification.setLatestEventInfo(this, contentTitle, contentText, contentIntent);

notification.defaults = defaults;

notificationManager.notify(id, notification);

}
private void showNotification(String tickerText, String contentTitle,String contentText, int id, int resId)

{

Notification notification = new Notification(resId, tickerText, System.currentTimeMillis());

PendingIntent contentIntent = PendingIntent.getActivity(this, 0, getIntent(), 0);

notification.setLatestEventInfo(this, contentTitle, contentText, contentIntent);

notificationManager.notify(id, notification);

}
public void onClick(View v)

{

switch (v.getId())

{

case R.id.btnSmile:

showNotification("今天非常高兴", //显示在状态栏上的提示文字

"今天考试得了全年级第一", //详细通知的标题

"数学100分、语文99分、英语100分，yeah！", //详细通知的具体内容

R.drawable.smile, //Notification对应的唯一ID值

R.drawable.smile); //资源图片的ID

break;

case R.id.btnWhy:

showNotification("这是为什么呢？",

"这道题为什么会出错呢？",

"谁有正确答案啊.",

R.drawable.why,

R.drawable.why);

break;

case R.id.btnWrath:

showNotification("今天心情不好",

"也不知道为什么，这几天一直很郁闷.",

"也许应该去公园散心了",

R.drawable.wrath,

R.drawable.wrath);

break;

case R.id.btnClear:

notificationManager.cancelAll();

break;

case R.id.btnRing:

setDefaults("使用默认的声音",

"使用默认的声音",

"使用默认的声音",

R.id.btnRing,

R.drawable.smile,

Notification.DEFAULT_SOUND);

case R.id.btnVibrate:

setDefaults("使用默认的震动",

"使用默认的震动",

"使用默认的震动",

R.id.btnVibrate,

R.drawable.smile,

Notification.DEFAULT_VIBRATE);

case R.id.btnLight:

setDefaults("使用默认的Light",

"使用默认的Light",

"使用默认的Light",

R.id.btnLight,

R.drawable.smile,

Notification.DEFAULT_LIGHTS);

case R.id.btnRingAndVibrate:

setDefaults("所有的都使用默认值",

"所有的都使用默认值",

"所有的都使用默认值",

R.id.btnRingAndVibrate,

R.drawable.smile,

Notification.DEFAULT_ALL);

break;

}

}

}
模拟器：
对话框

在Android系统中创建对话框的方式很多，使用AlertDialog类来创建对话框是最常用的一种方式。由于AlertDialog类的构造函数被声明为protected，所以不能直接使用new来创建AlertDialog类的对象实例。为了创建AlertDialog对象，需要使用Builder类，然后通过AlertDialog.Builder返回的AlertDialog对象的show方法显示对话框；或者通过Builder类的create方法返回AlertDialog对象，然后对该对话框进行一些必要的设置，最后通过AlertDialog类的show方法显示对话框，下面是这两种方式的示例代码：

AlertDialog alertDialog = new AlertDialog.Builder(this).create();

...

alertDialog.setMessage("...");

alertDialog.setTitle("...");

...

alertDialog.show();
new AlertDialog.Builder(this)

.setIcon(...)

.setTitle(...)

.setMessage(...)

.setPositiveButton(...)

.setNegativeButton(...)

.show();
AlertDialog.Builder有两个方法可以分别设置对话框的确定和取消按钮，这两个方法是：

//设置确认按钮的方法

AlertDialog.Builder setPositiveButton(CharSequence text, DialogInterface.OnClickListener listener)

AlertDialog.Builder setPositiveButton(int textId, DialogInterface.OnClickListener listener)

//设置取消按钮的方法

AlertDialog.Builder setNegativeButton(CharSequence text, DialogInterface.OnClickListener listener)

AlertDialog.Builder setNegativeButton(int textId, DialogInterface.OnClickListener listener)

还有一个方法，可以设置中性的按钮：

AlertDialog.Builder setNeutralButton(CharSequence text, DialogInterface.OnClickListener listener)

AlertDialog.Builder setNeutralButton(int textId, DialogInterface.OnClickListener listener)
上面这三个设置按钮的方法的调用顺序可以是任意的，也即是无论调用顺序怎样，setPositiveButton方法设置的按钮总会排在第一位，setNeutralButton方法设置的按钮总会排在第二位，setNegativeButton方法设置的按钮总会排在最后一位。使用AlertDialog类创建的对话框最多只能有3个按钮。这三个设置对话框按钮的方法虽然都可以被重复多次调用，但是系统只以每一个方法最后一次调用为准。

如果不进行任何其它设置，只是简单地显示一个带Message的对话框，这个对话框并不会起多大的作用。因为在对话框上面没有按钮，除非按手机上的取消键，否则无法关闭这个对话框。为了给对话框加上图片、文字和按钮，可以在调用show方法之前，调用AlertDialog.Builder类中的相关方法对对话框进行设置，比如说左上角显示的图标、标题、提示信息等等，这些设置对话框相关信息的方法返回的都是AlertDialog.Builder对象，所以可以串在一起写。

AlertDialog.Builder类有两个重要的方法：create和show，create虽然返回了AlertDialog对象，但是并不显示这个对话框，而show方法则会立即显示对话框。如果想在获得AlertDialog对象后做进一步处理，而不是立即显示该对话框，可以使用create方法，在相关事情处理完毕后，再调用show方法显示对话框。

一、带三个按钮的对话框

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="显示 确认/忽略/取消 对话框"/>


main.java：

public class Main extends Activity implements OnClickListener

{

@Override

public void onClick(View v)

{

new AlertDialog.Builder(this)

.setIcon(R.drawable.question)

.setTitle("是否删除文件？")

.setMessage("是否删除选定文件的对话框\n请想好后再点击相关按钮")

.setPositiveButton("确定", new DialogInterface.OnClickListener(){

public void onClick(DialogInterface dialog, int whichButton)

{

new AlertDialog.Builder(Main.this).setMessage("您选择了确定按钮，文件已经被删除.").show();

}

})

.setNeutralButton("忽略", new DialogInterface.OnClickListener(){

public void onClick(DialogInterface dialog, int whichButton)

{

new AlertDialog.Builder(Main.this).setMessage("您选择了忽略按钮，将跳过该操作.").show();

}

})

.setNegativeButton("取消",new DialogInterface.OnClickListener(){

public void onClick(DialogInterface dialog, int whichButton)

{

new AlertDialog.Builder(Main.this).setMessage("您选择了取消按钮，该文件未被删除.")..show();

}

})

.show();

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

Button button = (Button) findViewById(R.id.button);

button.setOnClickListener(this);

}

}
模拟器：
二、简单列表对话框、单选列表对话框、多选列表对话框

（1）、简单列表对话框

通过AlertDialog.Builder类的setItems方法可以创建简单的列表对话框。这种对话框实际上相当于将ListView控件放在对话框上，然后在ListView中添加若干简单的文本。setItems方法的定义如下所示：

AlertDialog.Builder setItems(int itemsId, DialogInterface.OnClickListener listener)

AlertDialog.Builder setItems(CharSequence[] items, DialogInterface.OnClickListener listener)

setItems可以通过传递一个字符串数组资源ID或字符串数组变量为对话框中的列表提供数据。
（2）、单选列表对话框

通过AlertDialog.Builder类的setSingleChoiceItems方法可以创建带单选按钮的列表对话框。setSingleChoiceItems方法有如下4种重载形式：

//从资源文件中装载数据

AlertDialog.Builder setSingleChoiceItems(int itemsId, int checkedItem, DialogInterface.OnClickListener listener)

//从字符串数组中装载数据

AlertDialog.Builder setSingleChoiceItems(CharSequence[] items, int checkedItem, DialogInterface.OnClickListener listener)

//从ListAdapter对象中装载数据

AlertDialog.Builder setSingleChoiceItems(ListAdapter adapter, int checkedItem, DialogInterface.OnClickListener listener)

//从数据集中装载数据

AlertDialog.Builder setSingleChoiceItems(Cursor cursor, int checkedItem, String labelColumn, DialogInterface.OnClickListener listener)

checkedItem：表示默认选中的列表项

listener： 表示单击某个列表项时被触发的对象

labelColumn：如果数据源是数据集，该数据集中指定的列会作为对话框的数据加载到列表框中
（3）、多选列表对话框

通过AlertDialog.Builder类的setMultiChoiceItems方法可以创建带复选框的列表对话框。setMultiChoiceItems方法有如下3种重载形式：

//从数据集中装载数据

AlertDialog.Builder setMultiChoiceItems(Cursor cursor, String isCheckedColumn, String labelColumn, DialogInterface.OnMultiChoiceClickListener listener)

//从资源文件中装载数据

AlertDialog.Builder setMultiChoiceItems(int itemsId, boolean[] checkedItems, DialogInterface.OnMultiChoiceClickListener listener)

//从字符串数组中装载数据

AlertDialog.Builder setMultiChoiceItems(CharSequence[] items, boolean[] checkedItems, DialogInterface.OnMultiChoiceClickListener listener)

checkedItems： 该参数的数组长度要和列表框中列表项个数相等，该参数用于设置每一个列表项的默认值，如果为true，表示当前的列表项为选中状态，否则表示未选中状态。

listener： 表示选中某个列表项时被触发的对象。

isCheckedColumn：确认列表项是否被选中，1表示选中，0表示未选中。
下面的例子是创建这三种对话框的相关代码

main.xml：




android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="显示列表对话框" />


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="显示单选列表对话框" />


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="显示多选列表对话框" />


Main.java：

public class Main extends Activity implements OnClickListener

{

private String[] citys = new String[]{ "北京", "上海", "深圳", "成都", "重庆", "营山" };

private boolean boolMultiChoiseDialog[] = new boolean[]{ false, true, false, true, false, false };

private ButtonOnClick buttonOnClick = new ButtonOnClick(1);

private ListView lv = null;



private void showListDialog()

{

new AlertDialog.Builder(this)

.setTitle("选择城市")

.setItems(citys, new DialogInterface.OnClickListener(){

public void onClick(DialogInterface dialog, int which)

{

final AlertDialog ad = new AlertDialog.Builder(Main.this).setMessage("您已经选择了: " + which + ":" + citys[which]).show();



//设置一个定时器，5秒钟后关闭对话框

android.os.Handler hander = new android.os.Handler();

hander.postDelayed(new Runnable(){

@Override

public void run()

{

ad.dismiss();//调用AlertDialog类的dismiss方法关闭对话框，当然也可以调用cancel方法

}

}, 5 * 1000);

}

})

.show();

}
private void showSingleChoiceDialog()

{

new AlertDialog.Builder(this)

.setTitle("选择城市")

.setSingleChoiceItems(citys, 1, buttonOnClick)

.setPositiveButton("确定",buttonOnClick)

.setNegativeButton("取消", buttonOnClick)

.show();

}
private void showMultiChoiceDialog()

{

AlertDialog ad = new AlertDialog.Builder(this)

.setIcon(R.drawable.image)

.setTitle("选择城市")

.setMultiChoiceItems(citys, boolMultiChoiseDialog, new DialogInterface.OnMultiChoiceClickListener(){

public void onClick(DialogInterface dialog,int whichButton, boolean isChecked)

{

}

})

.setPositiveButton("确定", new DialogInterface.OnClickListener(){

public void onClick(DialogInterface dialog, int whichButton)

{

String s = "您选择了"+lv.getCheckedItemPositions().size()+"项--";

for (int i = 0; i < citys.length; i++)

{

/*

SparseBooleanArray android.widget.ListView.getCheckedItemPositions()

说明 ：Returns the set of checked items in the list.

返回值：A SparseBooleanArray which will return true for each call to get(int position)

where position is a position in the list.



SparseBooleanArray：

SparseBooleanArrays map integers to booleans. Unlike a normal array of booleans there can be gaps in the indices. It is intended to be more efficient than using a HashMap to map Integers to Booleans.



SparseBooleanArray的get(int key)方法：

Gets the boolean mapped from the specified key, or false if no such mapping has been made.

*/

if (lv.getCheckedItemPositions().get(i))

{

s += i + ":" + lv.getAdapter().getItem(i) + " ";

}

}



if (lv.getCheckedItemPositions().size() > 0)

{

new AlertDialog.Builder(Main.this).setMessage(s).show();

}

else

{

new AlertDialog.Builder(Main.this).setMessage("您未选择任何城市").show();

}

}

})

.setNegativeButton("取消", null)

.create();



lv = ad.getListView();//获取多选列表对话框中的ListView对象

ad.show();

}
private class ButtonOnClick implements DialogInterface.OnClickListener

{

private int index; //城市数组的索引
public ButtonOnClick(int index)

{

this.index = index;

}
//如果在单选列表对话框里面添加了按钮，在处理单击事件时需要同时考虑列表项和确定、取消按钮。

//由于它们的单击事件的接口都是DialogInterface.OnClickListener，因此，可以为这些单击事件编写一个内嵌的java类。

//然后将该类的对象传入setSingleChoiceItems、setPositiveButton、setNegativeButton

public void onClick(DialogInterface dialog, int whichButton)

{

//whichButton表示单击的按钮或者列表项的索引，所有列表项的索引都是不小于0的，而按钮的索引都是小于0的

if( whichButton >= 0 )

{

index = whichButton; //如果单击的是列表项，将当前列表项的索引保存在index里面

//如果想在单击列表项后关闭该对话框，可在此调用dialog.cancel()或者dialog.show()

}

else

{

if (whichButton == DialogInterface.BUTTON_POSITIVE) // -1

{

new AlertDialog.Builder(Main.this).setMessage("您已经选择了：" + index + ":" + citys[index]).show();

}

else if (whichButton == DialogInterface.BUTTON_NEGATIVE) // -2

{

new AlertDialog.Builder(Main.this).setMessage("您什么都未选择").show();

}

}

}

}
@Override

public void onClick(View view)

{

switch (view.getId())

{

case R.id.btnListDialog:

{

showListDialog();

break;

}

case R.id.btnSingleChoiceDialog:

{

showSingleChoiceDialog();

break;

}

case R.id.btnMultiChoiceDialog:

{

showMultiChoiceDialog();

break;

}

}

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

Button btnListDialog = (Button) findViewById(R.id.btnListDialog);

Button btnSingleChoiceDialog = (Button) findViewById(R.id.btnSingleChoiceDialog);

Button btnMultiChoiceDialog = (Button) findViewById(R.id.btnMultiChoiceDialog);

btnListDialog.setOnClickListener(this);

btnSingleChoiceDialog.setOnClickListener(this);

btnMultiChoiceDialog.setOnClickListener(this);

}

}
模拟器：三、水平进度对话框和圆形进度对话框

下面以一个实际例子来说明水平进度对话框和圆形进度对话框的实现方式。本例中的进度对话框包括两个按钮：【暂停】和【取消】，单击暂停按钮后，对话框关闭，再次显示该对话框时，进度条的起始位置从上一次关闭对话框的位置开始(这个仅限于水平对话框)。单击取消按钮后，对话框关闭，再次显示该对话框时，进度的起始位置仍然从0开始。

要实现进度随着时间的变化不断递增的效果，可以使用多线程以及定时器来完成这个工作。本例中使用Handler类来不断更新进度对话框的进度值。
main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="显示进度对话框"/>


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="显示旋转指针对话框"/>


Main.java：

public class Main extends Activity implements OnClickListener

{

private static final int MAX_PROGRESS = 200;

private ProgressDialog progressDialog;

private Handler progressHandler;

private int progress;
// 显示进度对话框，style表示进度对话框的风格

private void showProgressDialog(int style)

{

progressDialog = new ProgressDialog(this);

progressDialog.setIcon(R.drawable.wait);

progressDialog.setTitle("正在处理数据...");

progressDialog.setMessage("请稍后...");

progressDialog.setProgressStyle(style); //设置进度对话框的风格

progressDialog.setMax(MAX_PROGRESS); //设置进度对话框的进度最大值



// 设置进度对话框的【暂停】按钮

progressDialog.setButton(DialogInterface.BUTTON_POSITIVE,"暂停", new DialogInterface.OnClickListener(){

public void onClick(DialogInterface dialog, int whichButton)

{

progressHandler.removeMessages(1); //通过删除消息代码的方式停止定时器

}

});



// 设置进度对话框的【取消】按钮

progressDialog.setButton(DialogInterface.BUTTON_NEGATIVE,"取消", new DialogInterface.OnClickListener()

{

public void onClick(DialogInterface dialog, int whichButton)

{

progressHandler.removeMessages(1); //通过删除消息代码的方式停止定时器的执行

progress = 0; //恢复进度初始值

progressDialog.setProgress(0);

}

});
progressDialog.show();



progressHandler = new Handler()

{

@Override

public void handleMessage(Message msg)

{

super.handleMessage(msg);
// 进度达到最大值，关闭对话框

if (progress >= MAX_PROGRESS)

{

progress = 0;

progressDialog.dismiss();

}

else

{

progress++; // 将进度递增1

progressDialog.incrementProgressBy(1);

// 随机设置下一次递增进度（调用handleMessage方法）的时间

progressHandler.sendEmptyMessageDelayed(1, 50 + new Random().nextInt(500));

}

}

};
// 设置进度初始值

progress = (progress > 0) ? progress : 0;

progressDialog.setProgress(progress);

progressHandler.sendEmptyMessage(1);

}
@Override

public void onClick(View view)

{

switch (view.getId())

{

case R.id.button1: //显示进度条风格的进度对话框

showProgressDialog(ProgressDialog.STYLE_HORIZONTAL);

break;

case R.id.button2: //显示旋转指针风格的进度对话框

showProgressDialog(ProgressDialog.STYLE_SPINNER);

break;

}

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);
Button button1 = (Button) findViewById(R.id.button1);

Button button2 = (Button) findViewById(R.id.button2);

button1.setOnClickListener(this);

button2.setOnClickListener(this);

}

}
模拟器：
注意事项：

进度对话框默认情况下是圆形进度条，如果要显示水平进度条，需要使用setProgressStyle进行设置。

虽然ProgressDialog类的getProgress方法可以获得当前进度，但只是在水平进度条风格的对话框中该方法才会有效。如果是圆形进度条，该方法永远返回的是0。

圆形进度对话框中的进度圆圈只是一个动画图像，并没有任何表示进度的功能，这种对话框一般在很难估计准确时间和进度的情况下使用。

四、自定义对话框

虽然AlertDialog类提供了很多预定义的对话框，但是这些对话框也不能完全满足系统的需求。为了创建更丰富的对话框，也可以采用与创建Activity同样的方法。也就是说，直接使用XML布局文件或代码创建视图对象，并将这些视图对象添加到对话框中。AlertDialog.Builder类的setView方法可以将视图对象添加到当前的对话框中。可以使用下面的形式将一个视图对象添加到对话框中：

new AlertDialog.Builder(this).setIcon(…).setTitle(…).setView(…).show();
main.xml:




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="显示登录对话框" />



login.xml:




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:orientation="horizontal"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_marginLeft="20dp"

android:layout_marginRight="20dp">


android:layout_width="wrap_content"

android:text="用户名："

android:textSize="20dp"

android:layout_height="wrap_content" />


android:layout_width="fill_parent"

android:layout_height="wrap_content" />




android:orientation="horizontal"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_marginLeft="20dp"

android:layout_marginRight="20dp">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="密 码："

android:textSize="20dp" />


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:password="true" />





Main.java:

public class Main extends Activity implements OnClickListener

{

@Override

public void onClick(View v)

{

LinearLayout loginLayout = (LinearLayout) getLayoutInflater().inflate(R.layout.login, null);

new AlertDialog.Builder(this)

.setIcon(R.drawable.login)

.setTitle("用户登录")

.setView(loginLayout)

.setPositiveButton("登录", new DialogInterface.OnClickListener(){

public void onClick(DialogInterface dialog, int whichButton)

{

//编写处理用户登录的代码

}

})

.setNegativeButton("取消",new DialogInterface.OnClickListener(){

public void onClick(DialogInterface dialog, int whichButton)

{

//取消用户登录，退出程序

}

})

.show();

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

Button button = (Button) findViewById(R.id.button);

button.setOnClickListener(this);

}

}

模拟器五、使用Activity托管对话框

Android/OPhone 开发完全讲义 P63
六、创建悬浮对话框和触摸任何位置都可以关闭的对话框

Android/OPhone 开发完全讲义 P64Menu菜单

菜单是Android系统中重要的用户接口之一。在Android中提供了丰富多彩的菜单，比如系统的主菜单，也可称为选项菜单；带图像、复选框、选项按钮的菜单；上下文菜单。本章节将对这些菜单的使用进行详细讲解。

选项菜单

如果我们在Activity主界面按下手机的Menu按键，这时就会在屏幕底部弹出相应的带图标的选项菜单。这种带图标的选项菜单最多只能显示6个菜单项，当设置超过6个菜单项时，弹出的选项菜单只显示前五个菜单项，右下角的第六个菜单项时More的菜单项。用户点击这个More菜单项后会显示一个浮于主界面之上的一个扩展选项菜单，扩展选项菜单不支持显示图标，但可以显示单选框和复选框。
如何定义Activity的选项菜单呢，当我们第一次调用选项菜单时，Activity会调用onCreateOptionsMenu()回调方法，所以只需要重新实现onCreateOptionsMenu()方法，并在里面初始化选项菜单就可以了。该方法的定义如下：

public boolean onCreateOptionsMenu(Menu menu)

通过Menu的add方法可以添加一个选项菜单项，该方法有4种重载形式，其定义如下：

public MenuItem add (int titleRes)

public MenuItem add (CharSequence title)

public MenuItem add (int groupId, int itemId, int order, int titleRes)

public MenuItem add (int groupId, int itemId, int order, CharSequence title)

add方法最多有4个参数，这些参数的含义如下：

groupId： 菜单项的分组ID，该参数一般用于选项菜单。该参数可以是负整数、0、正整数

itemId： 当前添加的菜单项的ID，该参数可以使负整数、0、正整数

order： 菜单显示顺序的ID，Android系统在显示菜单项时，根据order参数的值按照升序从左到右、从上到下显示相应菜单项。该参数必须是不小于0的正整数

titleRes或title： 菜单项标题的字符串资源ID或字符串

add方法返回的是一个MenuItem对象，每一个MenuItem对象对应一个菜单项。可以通过MenuItem的相应方法来设置与菜单项相关的内容。

MenuItem的SetIntent方法，可以将一个Activity与菜单项关联，setIntent方法的定义如下：

public abstract HYPERLINK "file:///D:\\android\\android_sdk\\docs\\reference\\android\\view\\MenuItem.html" MenuItem setIntent ( HYPERLINK "file:///D:\\android\\android_sdk\\docs\\reference\\android\\content\\Intent.html" Intent intent)

将一个Activity与菜单项关联后，单击该菜单项后，系统会调用startActivity方法来显示与菜单项关联的Activity。如果同时也设置了菜单项的单击事件，则与该菜单项关联的Activity将失效。也就是说，系统将会调用单击事件方法，而不会显示与菜单项关联的Activity。
下面是一个简单的选项菜单初始化的例子：

MenuDemo.java：

public class MenuDemo extends Activity {

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

}



//选项菜单

public boolean onCreateOptionsMenu(Menu menu){

//public abstract MenuItem add(int groupId, int itemId, int order, CharSequence title)

//Add a new item to the menu. This item displays the given title for its label.

//这里需要注意的是，菜单项的id必须是唯一的，因为在处理选项菜单的点击事件时，就是通过该id来区分是哪一个菜单项被选中

menu.add(0,1,0,"save")

.setIcon(android.R.drawable.ic_menu_save);



menu.add(0,2,0,"delete")

.setIcon(android.R.drawable.ic_menu_delete);



return true;

}



public boolean onOptionsItemSelected(MenuItem item){

super.onOptionsItemSelected(item);

switch(item.getItemId()){

case 1:

new AlertDialog.Builder(this).setMessage("你点击了save按钮").show();

break;

case 2:

new AlertDialog.Builder(this).setMessage("你点击了delete按钮").show();

break;

default:

break;

}



return true;

}

}
模拟器：
上下文菜单

上下文菜单是一种悬浮于主界面之上的菜单。当注册到一个View对象上以后，默认情况下用户可以通过长按View对象以调用上下文菜单。上下文菜单的每个元素依然是菜单项，但是它并不支持显示图标和设置快捷键。另外，上下文菜单还可以设置顶部标题和顶部图标。上下文菜单可以和任何View对象进行关联，比如TextView、EditText、Button等等。

与选项菜单类似，初始化上下文菜单依然是通过重新实现onCreateContextMenu()回调方法来完成的，处理上下文菜单的菜单项的点击事件是通过重新实现onContextItemSelected()回调方法来完成的。如果要为View对象注册上下文菜单，需要使用registerForContextMenu()。与选项菜单不同的是，上下文菜单的初始化回调方法并不只被调用一次，它会在每次呼出上下文菜单时被调用。

当一个View关联上下文菜单后，触摸该View，不要抬起，等一会儿就会显示上下文菜单。如果有一些View已经有了自己的上下文菜单，例如EditText，这种情况下，系统会将我们自定义的上下文菜单项添加到视图自带的上下文菜单项的后面。下面是一个关于上下文菜单的例子：

MenuDemo.java：

public class MenuDemo extends Activity {

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);



TextView tv = new TextView(this);

tv.setText("上下文菜单的载体");

registerForContextMenu(tv);

setContentView(tv);

}



//创建上下文菜单

public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo info){

super.onCreateContextMenu(menu, v, info);

//public abstract MenuItem add(int groupId, int itemId, int order, CharSequence title)

//Add a new item to the menu. This item displays the given title for its label.

//这里需要注意的是，菜单项的id必须是唯一的，因为在处理选项菜单的点击事件时，就是通过该id来区分是哪一个菜单项被选中

menu.add(0,1,0,"save")

.setIcon(android.R.drawable.ic_menu_save);



menu.add(0,2,0,"delete")

.setIcon(android.R.drawable.ic_menu_delete);

}



public boolean onContextItemSelected(MenuItem item){

super.onOptionsItemSelected(item);

switch(item.getItemId()){

case 1:

new AlertDialog.Builder(this).setMessage("你点击了save按钮").show();

break;

case 2:

new AlertDialog.Builder(this).setMessage("你点击了delete按钮").show();

break;

default:

break;

}

return true;

}

}
模拟器：
三、子菜单

子菜单是可以被添加到其它菜单上的菜单，不过子菜单不能添加到子菜单上。当我们有大量的菜单项需要被显示时，利用子菜单对这些菜单项进行分类是一个比较好的办法。这样可以让用户更容易找到他们所需的菜单项，同时也使得菜单看起来更整洁有条理。传统的子菜单是以层次结构显示的，而Android系统中的子菜单采用了弹出式的显示方式。也就是当单击带有子菜单的菜单项后，父菜单会关闭，在屏幕上会单独显示子菜单。

在android中使用子菜单十分简单，我们只需把添加菜单项的add()方法替换成addSubMenu()方法，就可以给菜单添加子菜单。addSubMenu方法的定义如下：

public SubMenu addSubMenu (int titleRes)

public SubMenu addSubMenu (CharSequence title)

public SubMenu addSubMenu (int groupId, int itemId, int order, int titleRes)

public SubMenu addSubMenu (int groupId, int itemId, int order, CharSequence title)

addSubMenu方法和add方法的参数个数和类型完全相同，所不同的是它们的返回值类型。addSubMenu返回的是一个SubMenu对象。可以通过SubMenu的add方法添加对应的子菜单。SubMenu的add方法与Menu的add方法在功能和使用方法上完全相同。

在子菜单上还可以带复选框或者单选按钮，具体可以参照《Android/OPhone开发完全讲义》P73

下面以一个例子对子菜单的用法进行说明：

MenuDemo.java：

public class MenuDemo extends Activity {

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

}



//选项菜单

public boolean onCreateOptionsMenu(Menu menu){

menu.add(0,1,0,"save")

.setIcon(android.R.drawable.ic_menu_save);



menu.add(0,2,0,"delete")

.setIcon(android.R.drawable.ic_menu_delete);



SubMenu subMenu = menu.addSubMenu(0,3,0,"search").setIcon(android.R.drawable.ic_menu_search);

subMenu.add(0,4,0,"本地");

subMenu.add(0,5,0,"网络");



return true;

}



public boolean onOptionsItemSelected(MenuItem item){

super.onOptionsItemSelected(item);

switch(item.getItemId()){

case 1:

new AlertDialog.Builder(this).setMessage("你点击了save按钮").show();

break;

case 2:

new AlertDialog.Builder(this).setMessage("你点击了delete按钮").show();

break;

case 4:

new AlertDialog.Builder(this).setMessage("你点击了子菜单'本地'按钮").show();

break;

case 5:

new AlertDialog.Builder(this).setMessage("你点击了资产的'网络'按钮").show();

break;

default:

break;

}



return true;

}

}

模拟器：
4种响应菜单项单击事件的方式

onMenuItemSelected： 单击任何类型的菜单项(包括选项菜单项、选项菜单的子菜单项、上下文菜单项、上下文菜单的子菜单项)，onMenuItemSelected方法都会被调用，如果多种类型的菜单要执行同一段代码的时候，可以考虑将所有这些代码放在onMenuItemSelected方法中。

onOptionsItemSelected： 该方法在单击选项菜单以及选项菜单的子菜单项时被调用。如果只处理这两种类型的菜单，可以考虑将响应代码放在onOptionsItemSelected方法中。

onContextItemSelected： 该方法在单击上下文菜单以及上下文菜单项的子菜单时被调用。如果只处理这两种类型的菜单，可以考虑将响应代码放在onContextItemSelected方法中。

onMenuItemClick： 如果想将某些响应菜单项单击事件的代码独立出来，可以考虑设置这些菜单项的单击事件，也就是编写一个实现OnMenuItemClickListener接口的类，并将相关的代码放在OnMenuItemClickListener接口的onMenuItemClick方法中。

这4个负责响应菜单项单击事件的方法都返回一个boolean类型的值。一般情况下，可以使这些方法永远返回true。如果onMenuItemClick方法返回false，Android系统仍然会继续调用onMenuItemSelected方法。实际上，在Activity. onMenuItemSelected方法中负责根据当前菜单项的类型调用onOptionsItemSelected或onContextItemSelected方法。当然，如果覆盖onMenuItemSelected方法后，未调用Super.onMenuItemSelected，系统就不会调用onOptionsItemSelected或onContextItemSelected方法了。如果onMenuItemSelected、onOptionsItemSelected或onContextItemSelected方法返回false(这里该true还是false，待进一步确认)，则系统不会调用与菜单项关联的Activity类的startActivity方法，也就是说，与菜单项关联的Activity不会被显示。显示和编辑文本的控件

在应用程序中经常需要显示和编辑文本，Android SDK中提供了TextView和EditText等组件，用于显示和编辑文本。下面将详细介绍这些相关的组件：

TextView：Displays text to the user and optionally allows them to edit it. A TextView is a complete text editor, however the basic class is configured to not allow editing.

CheckedTextView：An extension to TextView that supports the Checkable interface. This is useful when used in a ListView where the it's setChoiceMode has been set to something other than CHOICE_MODE_NONE.

EditText：EditText is a thin veneer over TextView that configures itself to be editable.

ExtraEditText：Specialization of EditText for showing and interacting with the extracted text in a full-screen input method.

AutoComplteteTextView：An editable text view that shows completion suggestions automatically while the user is typing. The list of suggestions is displayed in a drop down menu from which the user can choose an item to replace the content of the edit box with.

MultiAutoCompleteTextView：An editable text view, extending AutoCompleteTextView, that can show completion suggestions for the substring of the text where the user is typing instead of necessarily for the entire thing.

下面是文本相关控件在继承体系中的继承关系：TextView

Displays text to the user and optionally allows them to edit it. A TextView is a complete text editor, however the basic class is configured to not allow editing.

TextView是用来显示文本的控件，我们可以对TextView做许多复杂的设置，比如，设置TextView的文字字体大小、文字颜色、背景颜色、文本距离TextView控件边缘的距离、TextView距离其它组件的间距等等，下面以几个例子简要说明这些属性。

例一：设置TextView的padding和layout_margin




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textColor="#3300ff" //设置文本的颜色

android:background="#66ffff" //设置背景颜色

android:text="设置文本颜色、背景颜色" />


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="更多其它复杂的设置：padding、margin..."

android:textSize="20dp" //设置文本大小

android:textColor="#FF00FF"

android:background="#ffff00"

android:padding="30dp" //设置TextView里面的文本距离该控件边缘的距离

android:layout_margin="30dp" /> //设置该控件距离相邻的其它控件的间距


上面代码中大多属性的含义可以通过属性的字面意思猜测出来，这里要注意两个属性：android:padding和android:layout_margin。android:padding属性用于设置文字距离TextView组件边缘的距离，android:layout_margin属性用于设置TextView组件距离相邻的其它组件的间距。

android:padding：

Sets the padding, in pixels, of all four edges. Padding is defined as space between the edges of the view and the view's content. A views size will include it's padding. If a background is provided, the padding will initially be set to that (0 if the drawable does not have padding). Explicitly setting a padding value will override the corresponding padding found in the background.

android:paddingBottom：

Sets the padding, in pixels, of the bottom edge

android:paddingLeft：

Sets the padding, in pixels, of the left edge

android:paddingRight：

Sets the padding, in pixels, of the right edge

android:paddingTop：

Sets the padding, in pixels, of the right edge

android:layout_margin ：

Specifies extra space on the left, top, right and bottom sides of this view. This space is outside this view's bounds.

android:layout_marginBottom ：

Specifies extra space on the bottom side of this view. This space is outside this view's bounds.

android:layout_marginLeft：

Specifies extra space on the left side of this view. This space is outside this view's bounds.

android:layout_marginRight：

Specifies extra space on the right side of this view. This space is outside this view's bounds.

android:layout_marginTop：

Specifies extra space on the top side of this view. This space is outside this view's bounds.
除了可以在XML布局文件中设置TextView组件的属性以外，还可以在代码中设置其属性值，例如：

textView.setTextColor(android.graphics.Color.RED); //设置字体颜色

textView.setBackgroundResource(R.color.background); //设置背景颜色

textView.setBackgroundColor(android.graphics.Color.RED); // 设置背景颜色

textView.setBackgroundDrawable(getBaseContext().getResources().getDrawable(R.color.background));// 设置背景颜色
例二：在TextView中显示URL

TextView不仅可以显示普通的文本，还可以识别文本中的链接，并将这些链接转换成可单击的链接。系统会根据不同类型的链接调用相应的软件进行处理。比如，当这个链接是web地址时，单击该链接系统会启动web浏览器，并导航到该网址所指向的网页。TextView控件识别链接的方式有两种：自动识别和HTML解析。

自动识别：

自动识别是指TextView会将文本中的链接自动识别出来，这些链接并不需要做任何标记。实现自动识别链接的功能需要设置TextView的属性android:autoLink。该属性可设置的值如下：
HTML解析：

如果不设置TextView标签的Android:autoLink属性，就需要使用HTML的标签来显示可单击的链接。如果通过XML布局文件来设置TextView中的值，可以直接在字符串资源文件中用标签指定链接以及链接的文本，并在布局文件中引用字符串资源的ID。如果使用java代码来设置，需要使用android.text.Html类的fromHtml方法进行转换。下面用的例子中，设置了5个TextView组件，前三个使用自动识别链接的方式识别不同的链接，第四个TextView在字符串资源文件里面指定显示的文本；最后一个TextView在代码中使用Html.fromHtml方法将带等标签的文本转换成Spanned对象。相关的代码如下所示：

布局文件




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:background="#FFFFFF">




android:layout_marginTop="20dp"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textColor="#000000"

android:autoLink="web" />


android:layout_marginTop="20dp"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textColor="#000000"

android:autoLink="email" />


android:layout_marginTop="20dp"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textColor="#000000"

android:autoLink="phone" />

android:layout_marginTop="20dp"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textColor="#000000"

android:autoLink="all"

android:text="@string/link_text_manual"/>


android:layout_marginTop="20dp"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textColor="#000000"

android:autoLink="all"/>


字符串资源文件：





Hello World

Hello

博客：http://blog.csdn.net/wuliming_sc


相关代码：

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);



//自动识别链接的方式

TextView tvWebURL = (TextView) findViewById(R.id.tvWebURL);

tvWebURL.setText("博客：http://blog.csdn.net/wuliming_sc");
TextView tvEmail = (TextView) findViewById(R.id.tvEmail);

tvEmail.setText("电子邮件:thinking@qq.com");
TextView tvPhone = (TextView) findViewById(R.id.tvPhone);

tvPhone.setText("联系电话:13800138000");



//在代码中设置带HTML标签的文本

TextView textView2 = (TextView) findViewById(R.id.textview2);

textView2.setText(Html.fromHtml("博客：http://blog.csdn.net/wuliming_sc"));

}

CheckedTextView

An extension to TextView that supports the Checkable interface. This is useful when used in a ListView where the it's setChoiceMode has been set to something other than CHOICE_MODE_NONE.

CheckedTextView将和Listview一起总结。

EditText

EditText是TextView类的子类，因此，EditText控件具有TextView的一切XML属性和方法。它们的区别是EditText还可以输入文本，而TextView只能显示文本。EditText可以通过多种方式指定允许输入的字符，例如，如果只想输入数字，可以使用如下三种方式：

将EditText标签的android:digits属性值设为0123456789

将EditText标签的android:numeric属性值设为integer

将EditText标签的android:inputType属性值设为number



android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent" android:gravity="center_horizontal">




android:layout_height="wrap_content" android:text="使用android:digits属性（输入数字）" />


android:textColor="#000000" android:background="#FFFFFF"

android:layout_margin="10dp" android:digits="0123456789" /> //选中该文本框，不会自动弹出虚拟键盘




android:layout_height="wrap_content" android:text="使用android:numeric属性（输入有符号的浮点数）" />


android:textColor="#000000" android:background="#FFFFFF"

android:layout_margin="10dp" android:numeric="decimal|signed"/> //选中该文本框，会自动弹出虚拟键盘




android:layout_height="wrap_content" android:text="使用android:inputType属性（输入数字）" />


android:textColor="#000000" android:background="#FFFFFF"

android:layout_margin="10dp" android:inputType="number" /> //选中该文本框，会自动弹出虚拟键盘




android:layout_height="wrap_content" android:text="使用android:digits属性（输入26个小写字母）" />


android:textColor="#000000" android:background="#FFFFFF"

android:layout_margin="10dp" android:digits="abcdefghijklmnopqrstuvwxyz" />//选中该文本框，不会自动弹出虚拟键盘




android:layout_height="wrap_content" android:text="使用android:inputType属性（输入Email）" />


android:textColor="#000000" android:background="#FFFFFF"

android:layout_margin="10dp" android:inputType="textEmailAddress" /> //选中该文本框，会自动弹出虚拟键盘

在使用android:inputType属性设置EditText允许输入的字符，当焦点落在该控件上时，显示的虚拟键盘会随着inputType属性值的不同而不同。用android:digits属性设置EditText允许输入的字符，当焦点落在该控件上时，不会弹出虚拟键盘。

ExtraEditText

Specialization of EditText for showing and interacting with the extracted text in a full-screen input method.

AutoComplteteTextView、MultiAutoCompleteTextView (自动完成输入内容)

AutoCompleteTextView和EditText类似，都可以输入文本。但是AutoCompleteTextView可以和一个字符串数组或者List对象绑定，当用户输入两个以及以上字符的时候，系统将在AutoCompleteTextView下方列出字符串数组中所有以输入字符开头的字符串，这个和google的搜索框类似。

MultiAutoCompleteTextView具有连续输入的功能。也就是说，当输入完一个字符串后，在该字符串后面输入一个逗号，在逗号前后可以有任意多个空格，然后再输入一个字符串，仍然会显示辅助输入的列表。但是要使用MultiAutoCompleteTextView类的setTokenizer方法指定MultiAutoCompleteTextView.CommaTokenizer类的对象实例(该对象表示输入多个字符串时的分隔符是逗号)。

下面以一个例子简单说明：




android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:text="AutoCompleteTextView" />


android:layout_width="fill_parent" android:layout_height="wrap_content" />


android:text="MultiAutoCompleteTextView" />


android:layout_width="fill_parent" android:layout_height="wrap_content" />


public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

String[] autoString = new String[]

{ "a", "ab", "abc", "abcd","abcde","abcdef","bc", "bcd", "bcdf","bcdfg","bcdfgh","bcdfghi" };

ArrayAdapter adapter = new ArrayAdapter(this,android.R.layout.simple_dropdown_item_1line, autoString);



// AutoCompleteTextView

AutoCompleteTextView autoCompleteTextView = (AutoCompleteTextView) findViewById(R.id.autoCompleteTextView);

autoCompleteTextView.setAdapter(adapter);



// MultiAutoCompleteTextView

MultiAutoCompleteTextView multiAutoCompleteTextView = (MultiAutoCompleteTextView) findViewById(R.id.multiAutoCompleteTextView);

multiAutoCompleteTextView.setAdapter(adapter);

multiAutoCompleteTextView.setTokenizer(new MultiAutoCompleteTextView.CommaTokenizer());

}Button ImageButton ZoomButton
Button

按钮是用得最多的一种控件，Button直接继承于View。最常用的按钮事件是单击事件，可通过设置Button类的setOnClickListener方法来设置单击事件的处理方法。如果当前类实现了android.view.View.OnClickListener接口，可以直接将this传入setOnClickListener方法：btnTmp. setOnClickListener(this)

我们可以通过调用View的setBackgroundDrawable()方法传入Drawable对象或者引用Drawable资源的id，来设置Button显示的背景图片。当然，也可以在XML布局文件中设置android:background值为一个Drawable资源。

如果按钮需要动态的调整大小，用固定大小的背景图片就会比较麻烦，需要根据按钮上要显示的文字的宽高对图片进行调整。在android里面，我们可以使用9patch图片来解决这个问题。9patch是android支持的可按规则拉伸的png格式的图片。后缀名为”.9.png”。实际上，9patch图片就是在原来png图片的上下左右分别多了一个像素的边界，通过在这个额外的边界上画黑色的直线，以此设置背景图片的哪些区域会被拉伸、以及向那个方向拉伸。我们可以通过Android SDK提供的9patch图片专用绘图工具draw9-patch打开一张图片png图片，该工具在sdk的安装路径的tools目录里面。通过该工具，在按钮区域外扩展一个像素，并用黑色像素点在这扩展的一像素的边界上画直线：
如上图所示，四角区域的图片，在伸展的过程中不做任何改变，保持原样；最上边和最下边两块区域只能在水平方向伸展；最左边和最右边两块区域只能载垂直方向伸展；中间这块区域向两个方向伸展。

右边是对应的效果图，最上面的效果图，是原始尺寸的背景图片只在垂直方向做伸展；中间的效果图是原始尺寸的背景图片只在水平方向做伸展。
同时显示图像和文字的按钮

要同时显示文字和图像，最简单的办法是使用Button标签的android:drawableX属性，其中X的可取值是Top、Bottom、Left、Right。分别表示在文字的上方、下方、左边、右边显示图像。该属性需要指定一个图像资源ID。android:drawableX的属性，可以多个一起使用，比如同时使用android:drawableBottom和android:drawableLeft，则在该按钮文字的下方、左边都会显示指定的图像。我们还可以使用android:drawablePadding属性设置文字到图像之间的距离。下面的代码设置了4个按钮，并分别在上下左右显示图像：




android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_height="wrap_content"

android:drawableTop="@drawable/star"

android:text="按钮1" />


android:layout_height="wrap_content"

android:drawableBottom="@drawable/star"

android:text="按钮2"

android:drawablePadding="30dp" />


android:layout_height="wrap_content"

android:drawableLeft="@drawable/star"

android:text="按钮3" />


android:layout_height="wrap_content"

android:drawableRight="@drawable/star"

android:text="按钮4"

android:drawablePadding="20dp"/>


ImageButton

ImageButton并不是TextView的子类，而是ImageView的之类。因此，Android:text属性并不起作用。ImageButton控件的android:src属性用来设置图片的背景。如果想在代码里面修改ImageButton的图像，可以使用ImageButton类的setImageResource或其它同类的方法。下面的代码，配置了两个带背景图片的按钮：




android:orientation="horizontal" android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:alt="51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译" src="@drawable/button1_1" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:alt="51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译" src="@drawable/button2_1" />



效果图如下所示：
ZoomButton

......
日期和时间控件

DatePicker、TimePicker

DatePicker控件用于输入日期，日期的范围是1900-1-1~2100-12-31 通过DatePicker类的getYear、getMonth、getDayOfMonth方法可以分别获得DatePicker控件当前的年、月、日。DatePicker通过init方法进行初始化，init方法的定义如下：

void android.widget.DatePicker.init(int year, int monthOfYear, int dayOfMonth, OnDateChangedListener onDateChangedListener)

其中year、monthOfYear、dayOfMonth参数分别用来设置年月日，onDateChangedListener参数用来设置DatePicker控件的日期变化事件对象。

TimePicker控件用来输入时间，只能输入小时和分钟。TimePicker默认情况下是12小时制，如果想以24小时制显示时间，可以使用TimePicker类的setIs24HourView方法来设置。当TimePicker的时间变化时，会触发OnTimeChanged事件，但是与DatePicker控件不同的是，TimePicker通过setOnTimeChangedListener方法设置时间变化的事件对象，而DatePicker通过init方法设置日期变化的事件对象。

下面以一个例子来说明这两个控件的使用情况：

main.xml：




android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content"/>


android:layout_width="fill_parent"

android:layout_height="wrap_content"/>


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textSize="18dp"/>


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="设置日期"

android:textSize="18dp"/>


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="设置时间"

android:textSize="18dp"/>


Main.java：

public class Main extends Activity implements OnDateChangedListener,OnTimeChangedListener

{

private TextView textView;

private DatePicker datePicker;

private TimePicker timePicker;

private Button btnSetDate;

private Button btnSetTime;

private Calendar c;
@Override

public void onTimeChanged(TimePicker view, int hourOfDay, int minute)

{

textView.setText("当前时间："+ timePicker.getCurrentHour()+":"+timePicker.getCurrentMinute()+"\n");

}
@Override

public void onDateChanged(DatePicker view, int year, int monthOfYear, int dayOfMonth)

{

textView.setText("当前日期："+ datePicker.getYear()+"-"+datePicker.getMonth()+"-"+datePicker.getDayOfMonth()+"\n");

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);



datePicker = (DatePicker) findViewById(R.id.datepicker);

timePicker = (TimePicker) findViewById(R.id.timepicker);

textView = (TextView) findViewById(R.id.textview);

btnSetDate = (Button)findViewById(R.id.btnSetDate);

btnSetTime = (Button)findViewById(R.id.btnSetTime);

c = Calendar.getInstance();



datePicker.init(2008, 8, 8, this); //初始化日期，并设置其事件的监听方法
timePicker.setOnTimeChangedListener(this); //设置时间选择控件的事件监听方法

timePicker.setIs24HourView(false); //设置日期格式:12或者24小时

timePicker.setCurrentHour(18); //设置小时

timePicker.setCurrentMinute(18); //设置分钟



btnSetDate.setOnClickListener(new Button.OnClickListener(){

public void onClick(View v) {

new DatePickerDialog(Main.this,

new DatePickerDialog.OnDateSetListener()

{

public void onDateSet(DatePicker view, int year, int monthOfYear,int dayOfMonth)

{

//设置日期

datePicker.updateDate(year, monthOfYear, dayOfMonth);

}

},c.get(Calendar.YEAR),c.get(Calendar.MONTH),c.get(Calendar.DAY_OF_MONTH))

.show();

}

});



btnSetTime.setOnClickListener(new Button.OnClickListener(){

public void onClick(View v) {

new TimePickerDialog(Main.this,

new TimePickerDialog.OnTimeSetListener() {

public void onTimeSet(TimePicker view, int hourOfDay, int minute)

{

//设置时间

timePicker.setCurrentHour(hourOfDay);

timePicker.setCurrentMinute(minute);

}

},c.get(Calendar.HOUR_OF_DAY),c.get(Calendar.MINUTE),true).show();

}

});

}

}
模拟器：
AnalogClock、DigitalClock

AnalogClock控件用来以表盘的形式显示时间。该控件自有两个指针：时针和分针。DigitalClock控件用来以数字方式显示当前时间。该控件可以显示时分秒。

AnalogClock直接继承于View；DigitalClock直接继承于TextView。

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:gravity="center_horizontal">


android:layout_width="fill_parent"

android:layout_height="wrap_content" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:textSize="18dp" />

单选框、复选框、开关状态按钮单项选择(RadioGroup、RadioButton)

Android平台提供了单项选择的控件，可以通过RadioGroup、RadioButton组合起来完成一个单项选择效果。下面通过一个例子来演示相关的功能：

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="@string/hello" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:orientation="vertical"

android:layout_x="3px"

android:layout_y="54px" >


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="@string/RadioButton1" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="@string/RadioButton2" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="@string/RadioButton3" />



Activity.java：

public class Activity01 extends Activity

{

RadioGroup m_RadioGroup;

RadioButton m_Radio1, m_Radio2, m_Radio3;
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);
m_RadioGroup = (RadioGroup) findViewById(R.id.RadioGroup01);

m_Radio1 = (RadioButton) findViewById(R.id.RadioButton1);

m_Radio2 = (RadioButton) findViewById(R.id.RadioButton2);

m_Radio3 = (RadioButton) findViewById(R.id.RadioButton3);
/* 设置事件监听 */

m_RadioGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {

public void onCheckedChanged(RadioGroup group, int checkedId)

{

if (checkedId == m_Radio1.getId())

{

DisplayToast("您选择的是：" + m_Radio1.getText());

}

else if (checkedId == m_Radio2.getId())

{

DisplayToast("您选择的是：" + m_Radio2.getText());

}

else

{

DisplayToast("您选择的是：" + m_Radio3.getText());

}

}

});

}



/* 显示Toast */

public void DisplayToast(String str)

{

Toast toast = Toast.makeText(this, str, Toast.LENGTH_LONG);

//设置toast显示的位置

toast.setGravity(Gravity.TOP, 0, 220);

//显示该Toast

toast.show();

}

}
strings.xml：





你喜欢下面那一种操作系统？

Examples

Windows

Linux

Moc os


复选框(CheckBox)

多项选择与单项选择最重要的区别就在于它可以让用户选择一个以上的选项。既然用户可以选择多项，为了确认用户是否选择的了某一项，需要对每一个选项进行事件监听。我们可以对CheckBox设置OnCheckedChangeListener事件监听，也可以设置OnClickListener，因为CheckBox是从Button继承而来。

CheckBox默认情况下是未选中状态。如果想修改这个默认值，可以将android:checked属性值设置为true，或者使用CheckBox类的setChecked方法设置CheckBox的状态。在代码中可以使用CheckBox类的isChecked方法判断是否被选中。

下面看一个例子，当用户选择完毕并提交后，会向用户提示相关的信息：

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

>


android:id="@+id/TextView1"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="@string/hello" />


android:id="@+id/CheckBox1"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="@string/CheckBox1">


android:id="@+id/CheckBox2"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="@string/CheckBox2">


android:id="@+id/CheckBox3"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="@string/CheckBox3">


android:id="@+id/CheckBox4"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="@string/CheckBox4">


Activity.java：

public class Activity01 extends Activity

{

CheckBox m_CheckBox1;

CheckBox m_CheckBox2;

CheckBox m_CheckBox3;

CheckBox m_CheckBox4;



@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);
/* 取得每个CheckBox对象 */

m_CheckBox1 = (CheckBox) findViewById(R.id.CheckBox1);

m_CheckBox2 = (CheckBox) findViewById(R.id.CheckBox2);

m_CheckBox3 = (CheckBox) findViewById(R.id.CheckBox3);

m_CheckBox4 = (CheckBox) findViewById(R.id.CheckBox4);
final CheckBox.OnCheckedChangeListener btnListener = new CheckBox.OnCheckedChangeListener() {

public void onCheckedChanged(CompoundButton buttonView, boolean isChecked)

{

int num = 0;

String strTmp = "";



if(m_CheckBox1.isChecked())

{

num++;

strTmp += m_CheckBox1.getText() + "\n" ;

}



if(m_CheckBox2.isChecked())

{

num++;

strTmp += m_CheckBox2.getText() + "\n" ;

}



if(m_CheckBox3.isChecked())

{

num++;

strTmp += m_CheckBox3.getText() + "\n" ;

}



if(m_CheckBox4.isChecked())

{

num++;

strTmp += m_CheckBox4.getText() + "\n" ;

}



strTmp = "你选择了" + num + "项，它们分别是：" + "\n" + strTmp;



DisplayToast(strTmp);

}

};



//对每个选项设置事件监听

m_CheckBox1.setOnCheckedChangeListener(btnListener);

m_CheckBox2.setOnCheckedChangeListener(btnListener);

m_CheckBox3.setOnCheckedChangeListener(btnListener);

m_CheckBox4.setOnCheckedChangeListener(btnListener);

}



public void DisplayToast(String str)

{

Toast toast = Toast.makeText(this, str, Toast.LENGTH_SHORT);

toast.setGravity(Gravity.TOP, 0, 220); //设置toast显示的位置

toast.show(); //显示该Toast

}

}开关状态按钮(ToggleButton)

ToggleButton控件提供了可以表示“开/关”状态的功能。ToggleButton通过在该按钮下方显示一个绿色的指示条表示“开/关”状态。至于绿色的指示条表示开还是关，用户可以自行决定。不过一般来讲绿色的指示条默认为开启状态，白色的指示条默认为关闭状态。

虽然ToggleButton是Button的子类，但android:text属性不再起作用。如果要更改默认的按钮文本，可以使用android:textOff和android:textOn属性。

默认情况下，按钮上的指示条为白色，如果要在XML布局文件中修改默认值，可以使用android:checked属性，在代码中使用ToggleButton类的setChecked方法。将android:checked属性设置为true时，指示条显示为绿色。

main.xml：




android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent">




android:layout_width="wrap_content"

android:layout_height="wrap_content"/>

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:checked="true"

android:textOff="灯灭:关闭状态" android:textOn="灯亮:开启状态" />

下拉列表框Spinner

Spinner控件用于显示一个下拉列表。该控件的用法与ListView控件类似，在装载数据的时候也需要创建一个Adapter对象，并在创建Adapter对象的过程中指定要装载的数据(数组、List对象等等)。下面简要介绍一下Spinner数据的几种绑定方式：

数组绑定

private static final String[] strWeeks={”星期一”，”星期二”，”星期三”，”星期四”，”星期五”，”星期六”，”星期天”};

mySpinner = (Spinner) findViewById(R.id.mySpinner);

ArrayAdapter adapter = new ArrayAdapter(this, android.R.layout.simple_spinner_item, strWeeks);

mySpinner.setAdapter(adapter);
列表绑定

ArrayList cityList= new ArrayList();//初始化一个city的String arraylist

cityList.add("北京");

cityList.add("上海");

cityList.add("深圳");

cityList.add("成都");

cityList.add("营山");

mySpinner = (Spinner) findViewById(R.id.mySpinner);

ArrayAdapter adapter = new ArrayAdapter(this,android.R.layout.simple_spinner_item,cityList);

mySpinner.setAdapter(adapter);
从XML文件里面获取数据

res/values/arrays.xml代码如下：







中国·北京

中国·上海

中国·深圳

中国·成都

中国·营山




布局文件中，Spinner的定义如下:


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:entries="@+array/ strCityName"/>
下面以一个例子说明下拉列表框的使用方式

main.xml：




android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_height="wrap_content" />


android:layout_height="wrap_content" android:layout_marginTop="20dp"/>


item.xml：




android:orientation="horizontal" android:layout_width="fill_parent"

android:layout_height="wrap_content">


android:layout_height="60dp" android:alt="51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译" src="@drawable/icon"

android:paddingLeft="10dp" />


android:layout_width="wrap_content" android:layout_height="fill_parent"

android:textSize="16dp" android:gravity="center_vertical"

android:paddingLeft="10dp" />


Main.java：

public class Main extends Activity

{

@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);



//第一个下拉列表框设置

Spinner spinner1 = (Spinner) findViewById(R.id.spinner1);

String[] applicationNames = new String[]{ "Android", "window mobile", "iphone", "blackberry", "QQphone" };

ArrayAdapter aaAdapter = new ArrayAdapter(this,android.R.layout.simple_spinner_item, applicationNames);

//如果加上下面这条语句，列表项将带RadioButton组件，不加这一句的话，将显示普通的下拉列表框

//aaAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

spinner1.setAdapter(aaAdapter);
//第二个下拉列表框相关设置

Spinner spinner2 = (Spinner) findViewById(R.id.spinner2);

final List> items = new ArrayList>();

Map item1 = new HashMap();

item1.put("ivLogo", R.drawable.calendar);

item1.put("tvApplicationName", "多功能日历");

Map item2 = new HashMap();

item2.put("ivLogo", R.drawable.eoemarket);

item2.put("tvApplicationName", "eoeMarket客户端");

items.add(item1);

items.add(item2);



SimpleAdapter simpleAdapter = new SimpleAdapter(this,

items,

R.layout.item,

new String[]{"ivLogo", "tvApplicationName"},

new int[]{ R.id.ivLogo, R.id.tvApplicationName }

);

spinner2.setAdapter(simpleAdapter);
spinner2.setOnItemSelectedListener(new OnItemSelectedListener()

{

public void onItemSelected(AdapterView parent, View view,int position, long id)

{

new AlertDialog.Builder(view.getContext())

.setTitle(items.get(position).get("tvApplicationName").toString())

.setIcon(Integer.parseInt(items.get(position).get("ivLogo").toString()))

.show();

}
public void onNothingSelected(AdapterView parent)

{

}

});

}

}
模拟器：ScrollView、HorizontalScrollView

垂直滚动（ScrollView）

ScrollView控件只支持垂直滚动，并且ScrollView里面只能包含一个控件。通常在< ScrollView >标签中定义一个垂直显示的LinearLayout，然后在这个LinearLayout里面放置多个控件。如果该LinearLayout中的控件所占用的总的高度超过屏幕的高度，就会在屏幕的右侧出现一个滚动条。通过单击手机的上下按钮，或者上下拖动屏幕就可以滚动查看未显示的部分。相关的例子如下所示：

main.xml：




android:layout_width="fill_parent" android:layout_height="wrap_content">


android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_height="wrap_content"

android:text="滚动视图"

android:textSize="30dp" />


android:layout_height="wrap_content"

android:alt="51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译" src="@drawable/item1" />


android:layout_height="wrap_content"

android:text="只支持垂直滚动"

android:textSize="30dp" />


android:layout_height="wrap_content"

android:alt="51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译" src="@drawable/item2" />


android:layout_height="wrap_content"

android:alt="51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译" src="@drawable/item3" />





模拟器：
水平滚动（HorizontalScrollView）

HorizontalScrollView支持水平滚动，用法与ScrollView控件类似。如果将上面的main.xml里面的修改成，并将线性布局的android:orientation属性修改为horizontal，显示的效果将如下图所示：
两个方向均可滚动

将上面这两个组件组合使用，就可以实现垂直和水平方向均可以滚动的效果。我们可以在标签里面嵌套，或者在标签里面嵌套。这两种方式都可以实现两个方向的滚动。示例代码如下：




android:layout_width="fill_parent" android:layout_height="wrap_content">




...







TabHost

如果要在屏幕上放置很多控件，可能一屏放不下，除了使用滚动视图以外，我们还可以使用TabHost控件来分页管理控件。当单击标签控件的不同标签时，会显示当前标签里面的内容。在Android系统中的每一个标签可以显示一个View或者一个Activity。

TabHost是标签控件的核心类，也是标签的集合。每一个标签是tabHost.TabSpec类的一个对象实例。通过TabHost类的addTab方法可以添加多个TabHost.TabSpec类的对象实例(多个标签)。如果从XML布局文件中添加View，首先需要建立一个布局文件，并且根节点要使用或者标签。下面是一个例子：
main.xml：




android:layout_width="fill_parent"

android:layout_height="fill_parent">




android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:orientation="vertical" >


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="这是在第一个标签上显示的文本"

android:textSize="18sp">




android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Button">








android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:orientation="vertical" >


android:layout_width="wrap_content"

android:layout_height="wrap_content">








android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:orientation="vertical">


android:layout_width="166px"

android:layout_height="98px"

android:orientation="vertical">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="RadioButton">




android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="RadioButton">










MyTab.java：

public class MyTab extends TabActivity implements OnTabChangeListener {
private TabHost myTabhost;



@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

myTabhost=this.getTabHost();
LayoutInflater.from(this).inflate(R.layout.main, myTabhost.getTabContentView(), true);

myTabhost.setBackgroundColor(Color.argb(150, 22, 70, 150));



myTabhost.addTab(myTabhost.newTabSpec("One") //make a new Tab

.setIndicator("tab1", getResources().getDrawable(R.drawable.gimp))

.setContent(R.id.widget_layout_Blue));
myTabhost.addTab(myTabhost.newTabSpec("Two") //make a new Tab

.setIndicator("tab2", getResources().getDrawable(R.drawable.mumule))

.setContent(R.id.widget_layout_red));
myTabhost.addTab(myTabhost.newTabSpec("Three") //make a new Tab

.setIndicator("tab3", getResources().getDrawable(R.drawable.notepad))

.setContent(R.id.widget_layout_green));



myTabhost.setOnTabChangedListener(this);

}
@Override

public void onTabChanged(String tagString) {

if (tagString.equals("One")){

}

else if(tagString.equals("Two")){

}

else if(tagString.equals("Three")){

}

else{

}

}

}
模拟器：ProgressBar、SeekBar、RatingBar
进度条(ProgressBar)

ProgressBar默认情况下是圆形的进度条，可以通过style属性将圆形进度条设置成大中小三种形式，代码如下：




android:layout_height="wrap_content"

style="?android:attr/progressBarStyleSmallTitle"/>




android:layout_height="wrap_content"/>




android:layout_height="wrap_content"

style="?android:attr/progressBarStyleLarge"/>

ProgressBar在默认情况下显示的是中型的圆形进度条，因此，如果想要显示的就是中等大小的圆形进度条，无需设置style属性。
ProgressBar还支持水平进度条，代码如下：


android:layout_width="fill_parent" android:layout_height="wrap_content"

style="?android:attr/progressBarStyleHorizontal"

android:max="100"

android:progress="30"

android:secondaryProgress="60"

android:layout_marginTop="20dp" />

进度条的总大小用android:max设置，其值可以是任意一个合法的正整数。ProgressBar的水平进度条支持两级进度，分别使用android:progress和android:secondaryProgress属性设置。本例中，一级进度和二级进度分别显示在进度条总长度的30%和60%的位置上。在代码中设置水平进度条的两级进度需要使用ProgressBar类的setProgress和setSecondaryProgress方法。
Android还支持将水平或者圆形的进度条放在标题栏上。例如，将圆形进度条放在标题栏上，可以在onCreate中使用如下的代码：

requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);

setContentView(R.layout.main);

setProgressBarIndeterminateVisibility(true);

如果要将水平进度条放在标题栏上，可以在onCreate方法中使用如下代码：

requestWindowFeature(Window.FEATURE_PROGRESS);

setContentView(R.layout.main);

setProgressBarVisibility(true);

setProgress(1200); //设置水平进度条的当前进度，默认最大值为10000

将进度条放在标题栏，有以下需要注意的事项：

requestWindowFeature方法应该在setContentView之前调用，否则系统会抛出异常

setProgressBarIndeterminateVisibility、setProgressBarVisibility、setProgress要在setContentView之后调用，否则这些方法无效

放在标题栏上的水平进度条不能设置最大值，系统已经将最大值设置为10000

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">




android:layout_height="wrap_content"

android:text="圆形进度条（小）" />


android:layout_height="wrap_content"

style="?android:attr/progressBarStyleSmallTitle" />


android:layout_height="wrap_content"

android:text="圆形进度条（中）" />


android:layout_height="wrap_content" />


android:layout_height="wrap_content"

android:text="圆形进度条（大）" />


android:layout_height="wrap_content"

style="?android:attr/progressBarStyleLarge" />


android:layout_height="wrap_content"

android:text="水平进度条" />


android:layout_height="wrap_content"

style="?android:attr/progressBarStyleHorizontal"

android:max="100"

android:progress="30" />

android:layout_width="fill_parent"

android:layout_height="wrap_content"

style="?android:attr/progressBarStyleHorizontal"

android:max="100"

android:progress="30"

android:secondaryProgress="60"

android:layout_marginTop="20dp" />




android:orientation="horizontal"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_marginTop="20dp"

android:text="增加进度" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_marginTop="20dp"

android:text="减小进度" />




拖动条(SeekBar)

拖动条类似于进度条，不同的是用户可以对其进行控制。例如，应用程序中用户对音量进行控制，这个就可以通过拖动条来实现。SeekBar是ProgressBar的子类，但是一般SeekBar并不需要设置第二级进度，如果设置了android:secondaryProgress属性，系统仍然会显示第二级进度，不过并不会随着滑块的滑动有任何的变化。与SeekBar控件滑动相关的事件接口是OnSeekBarChangeListener，该接口定义了如下3个事件方法：

public void onProgressChanged(SeekBar seekBar, int progress,boolean fromUser)

public void onStartTrackingTouch(SeekBar seekBar)

public void onStopTrackingTouch(SeekBar seekBar)

当按住滑块时，会触发onStartTrackingTouch事件，在拖动滑块滑动时，会触发onProgressChanged事件，松开滑块后，会触发onStopTrackingTouch事件。

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:max="100"

android:progress="50"

android:secondaryProgress="75" />


android:layout_width="fill_parent"

android:layout_height="wrap_content" />


android:layout_width="fill_parent"

android:layout_height="wrap_content" />


Activity01.java：

public class Activity01 extends Activity implements SeekBar.OnSeekBarChangeListener

{

//声明SeekBar对象

SeekBar mSeekBar;

TextView mProgressText;

TextView mTrackingText;
protected void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

//取得SeekBar对象

mSeekBar = (SeekBar)findViewById(R.id.seek);

mSeekBar.setOnSeekBarChangeListener(this);

mProgressText = (TextView) findViewById(R.id.progress);

mTrackingText = (TextView) findViewById(R.id.tracking);

}
//在拖动中--即值在改变

public void onProgressChanged(SeekBar seekBar, int progress, boolean fromTouch)

{

mProgressText.setText("当前值："+progress);

}

public void onStartTrackingTouch(SeekBar seekBar)

{

mTrackingText.setText("正在调节");

}

//停止拖动

public void onStopTrackingTouch(SeekBar seekBar)

{

mTrackingText.setText("停止调节");

}

}
改变ProgressBar、SeekBar的背景颜色

进度条和拖动条都没有提供直接修改进度条颜色的方法或者属性。这个问题可以通过drawable资源和android:progressDrawable属性来解决。一个完整的ProgressBar或SeekBar控件由以下几部分组成：

第一级进度条

第二级进度条

背景，也就是进度条未经过的地方

因此，组件的颜色也由三部分组成：第一级进度条的颜色，第二级进度条的颜色，背景颜色。设置这三部分的颜色的步骤如下：

（1）、确定三部分要用什么颜色后，用绘图工具创建3个选定颜色的图片，图片的大小任意。本例中，用progress.png表示第一级进度条的颜色；用senondary.png表示第二级进度条的颜色；bg.png表示背景颜色。 （2）、在res\drawable目录下创建一个barcolor.xml文件，并输入以下代码：













（3）、在ProgressBar和SeekBar标签中使用android:progressDrawable属性指定barcolor.xml文件的资源ID：


android:layout_height="wrap_content"

android:max="100"

android:layout_marginTop="20dp"

android:progress="30"

android:progressDrawable="@drawable/barcolor" />

……

我们除了可以用纯颜色来设置各种颜色以外，还可以用各种图像文件来显示丰富多彩的进度条。下面将以一个实例展示相关的特性：

main.xml：




android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent">




android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:layout_marginTop="20dp"

style="?android:attr/progressBarStyleHorizontal"

android:max="100"

android:progress="30"

android:secondaryProgress="60"

android:progressDrawable="@drawable/barcolor" />




android:layout_height="wrap_content"

android:max="100"

android:layout_marginTop="20dp"

android:progress="30"

android:progressDrawable="@drawable/barcolor" />




android:layout_height="wrap_content"

android:layout_marginTop="20dp"

android:text="Face拖动条" />


android:layout_height="wrap_content"

android:max="100"

android:progress="30"

android:progressDrawable="@drawable/barface" />

barcolor.xml：













barface.xml：











在drawable下面的图片以及xml文件：
模拟器：
评分组件(RatingBar)

在许多电子相册，网上书店、博客中，都有对照片或者文章进行评分的功能，在android SDK中，也提供了RatingBar控件来完成类似的工作。RatingBar有如下几个与评分相关的属性：

android:numStars：指定用于评分的五角星的数量，默认情况下是根据布局的设置尽量横向填充

android:rating：指定当前的分数

android:stepSize：指定分数的增量单位(步长),默认值是0.5，当然也可以设置为其它的值，比如0.1

下面是一个使用RatingBar控件的例子：

Main.xml：




android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent">




android:layout_height="wrap_content"

android:text="3颗星，步长是0.5" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:numStars="3"

android:rating="2" />




android:layout_height="wrap_content"

android:text="5颗星，步长是0.1" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:numStars="5"

android:stepSize="0.1" />




android:layout_height="wrap_content"

android:layout_marginTop="10dip">


android:layout_width="wrap_content"

android:layout_height="wrap_content" />




style="?android:attr/ratingBarStyleSmall"

android:layout_marginLeft="5dip"

android:layout_width="wrap_content"

android:layout_height="wrap_content" />






style="?android:attr/ratingBarStyleIndicator"

android:layout_marginLeft="5dip"

android:layout_width="wrap_content"

android:layout_height="wrap_content" />


Main.java：

public class Main extends Activity implements OnRatingBarChangeListener

{

private RatingBar smallRatingBar;

private RatingBar indicatorRatingBar;

private TextView textView;
@Override

public void onRatingChanged(RatingBar ratingBar, float rating,

boolean fromUser)

{

smallRatingBar.setRating(rating);

indicatorRatingBar.setRating(rating);

if (ratingBar.getId() == R.id.ratingbar1)

textView.setText("ratingbar1的分数：" + rating);

else

textView.setText("ratingbar2的分数：" + rating);

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

RatingBar ratingBar1 = (RatingBar) findViewById(R.id.ratingbar1);

RatingBar ratingBar2 = (RatingBar) findViewById(R.id.ratingbar2);

textView = (TextView) findViewById(R.id.textview);
ratingBar1.setOnRatingBarChangeListener(this);

ratingBar2.setOnRatingBarChangeListener(this);



smallRatingBar = (RatingBar) findViewById(R.id.smallRatingbar);

indicatorRatingBar = (RatingBar) findViewById(R.id.indicatorRatingbar);

}

}
模拟器：
GridView、Gallery和ImageSwitcher

GridView

GridView控件用于显示一个表格。实际上，GridView与ListView、Spinner等控件的使用方法比较类似，只是GridView在显示方式上有所不同。GridView使用二维表格的形式来显示，每一个单元格就是一个View对象，在单元格上可以放置任何Android支持的控件。

既然GridView使用二维表格的方式显示单元格，就需要设置二维表的列。设置GridView的列可以使用android:columnWidth属性，也可以使用GridView的setColumnWidth方法设置列数。GridView中的单元格会根据列数自动换行显示，因此无需设置其行数。

例子1

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:gravity="center_horizontal">




android:layout_height="wrap_content"

android:numColumns="5"

android:padding="20dp" android:horizontalSpacing="6dp"

android:verticalSpacing="6dp" />


android:layout_height="200dp" />


Main.java：

public class Main extends Activity implements OnItemSelectedListener, OnItemClickListener

{

private ImageView imageView;

private int[] resIds = new int[]{

R.drawable.item1, R.drawable.item2, R.drawable.item3,

R.drawable.item4, R.drawable.item5, R.drawable.item6,

R.drawable.item7, R.drawable.item8, R.drawable.item9,

R.drawable.item10,R.drawable.item11,R.drawable.item12,

R.drawable.item13,R.drawable.item14,R.drawable.item15

};
@Override

public void onItemSelected(AdapterView parent, View view, int position, long id)

{

imageView.setImageResource(resIds[position]);

}
@Override

public void onNothingSelected(AdapterView parent)

{

// TODO Auto-generated method stub

}
@Override

public void onItemClick(AdapterView parent, View view, int position, long id)

{

imageView.setImageResource(resIds[position]);

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

GridView gridView = (GridView) findViewById(R.id.gridview);
List> cells = new ArrayList>();

for (int i = 0; i < resIds.length; i++)

{

Map cell = new HashMap();

cell.put("imageview", resIds[i]);//每一个单元格都是一个ImageView控件，android:id属性值是imageView

cells.add(cell);

}



SimpleAdapter simpleAdapter = new SimpleAdapter(

this,

cells,

R.layout.cell, new String[]{ "imageview" },

new int[]{ R.id.imageview }

);

gridView.setAdapter(simpleAdapter);



imageView = (ImageView) findViewById(R.id.imageview);

gridView.setOnItemSelectedListener(this);

gridView.setOnItemClickListener(this);

imageView.setImageResource(resIds[0]);

}

}
模拟器：例子二

grid_view.xml:




android:id="@+id/grid_view"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:numColumns="auto_fit"

android:verticalSpacing="10dp"

android:horizontalSpacing="10dp"

android:columnWidth="90dp"

android:stretchMode="columnWidth"

android:gravity="center"

/>
GridViewActivity.java:

public class GridViewActivity extends Activity {

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.grid_view);

setTitle("GridView");

GridView gridview = (GridView)findViewById(R.id.grid_view);

gridview.setAdapter(new ImageAdapter(this));

}



public class ImageAdapter extends BaseAdapter {

private Context mContext;
public ImageAdapter(Context c) {

mContext = c;

}
public int getCount() {

return mThumbIds.length;

}
public Object getItem(int position) {

return position;

}
public long getItemId(int position) {

return position;

}
public View getView(int position, View convertView, ViewGroup parent) {

ImageView imageView;

if (convertView == null) { // if it's not recycled, initialize some attributes

imageView = new ImageView(mContext);

imageView.setLayoutParams(new GridView.LayoutParams(85, 85));

imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);

imageView.setPadding(8, 8, 8, 8);

} else {

imageView = (ImageView) convertView;

}
imageView.setImageResource(mThumbIds[position]);

return imageView;

}
// references to our images

private Integer[] mThumbIds = {

R.drawable.grid_view_01, R.drawable.grid_view_02,

R.drawable.grid_view_03, R.drawable.grid_view_04,

R.drawable.grid_view_05, R.drawable.grid_view_06,

R.drawable.grid_view_07, R.drawable.grid_view_08,

R.drawable.grid_view_09, R.drawable.grid_view_10,

R.drawable.grid_view_11, R.drawable.grid_view_12,

R.drawable.grid_view_13, R.drawable.grid_view_14,

R.drawable.grid_view_15, R.drawable.sample_1,

R.drawable.sample_2, R.drawable.sample_3,

R.drawable.sample_4, R.drawable.sample_5,

R.drawable.sample_6, R.drawable.sample_7

};

}

}
模拟器：
Gallery和ImageSwitcher

Gallery组件一般用于显示图像列表，因此，可以称为相册控件。Gallery和GridView的区别是Gallery只能水平显示一行，而且支持水平滑动效果。Gallery本身并不支持循环显示图像，也就是说，当显示到最后一个图像时，图像列表就不再向左移动了。为了达到循环显示图片的效果，我们可以通过改造Gallery的Adapter对象即可：

BaseAdapter类中的getView方法的调用与getCount方法的返回值有关。如果其返回值为n，则getView方法中的position参数值是绝对不会大于n-1的。因此，可以使getCount返回一个很大的数，比如Integer.MAX_VALUE。这样系统就会以为Adapter中有很多的View对象。

修改getCount的返回值后，对应的在获取相应图像ID资源时，需要做相应的处理：

imageView.setImageResource(resIds[position % resIds.length]);
main.xml：




xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="fill_parent"

android:layout_height="fill_parent">




android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:layout_alignParentTop="true"

android:layout_alignParentLeft="true" />




android:layout_width="fill_parent"

android:layout_height="80dp"

android:layout_alignParentBottom="true"

android:layout_alignParentLeft="true"

android:gravity="center_vertical"

android:spacing="10dp" />


Main.java：

public class Main extends Activity implements AdapterView.OnItemSelectedListener, ViewSwitcher.ViewFactory

{

private Gallery gallery;

private ImageSwitcher imageSwitcher;

private ImageAdapter imageAdapter;
private int[] resIds = new int[]

{

R.drawable.item1, R.drawable.item2, R.drawable.item3, R.drawable.item4, R.drawable.item5,

R.drawable.item6, R.drawable.item7, R.drawable.item8, R.drawable.item9, R.drawable.item10,

R.drawable.item11, R.drawable.item12, R.drawable.item13, R.drawable.item14, R.drawable.item15

};
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

requestWindowFeature(Window.FEATURE_NO_TITLE);//设置该Activity没有titlebar，使得图片显示区域更大

setContentView(R.layout.main);



gallery = (Gallery) findViewById(R.id.gallery);



imageAdapter = new ImageAdapter(this);

gallery.setAdapter(imageAdapter);

gallery.setOnItemSelectedListener(this);



imageSwitcher = (ImageSwitcher) findViewById(R.id.imageswitcher);

imageSwitcher.setFactory(this);

//设置淡入淡出效果

imageSwitcher.setInAnimation(AnimationUtils.loadAnimation(this, android.R.anim.fade_in));

imageSwitcher.setOutAnimation(AnimationUtils.loadAnimation(this, android.R.anim.fade_out));

}



@Override

public void onItemSelected(AdapterView parent, View view, int position, long id)

{

//当点击gallery里面的某一张图片时，对ImageSwitcher里面的图片进行设置

imageSwitcher.setImageResource(resIds[position % resIds.length]);

}
@Override

public void onNothingSelected(AdapterView parent)

{

}
/*

makeView()是接口ViewSwitcher.ViewFactory的抽象方法：

Public Methods abstract View makeView()

Creates a new View to be added in a ViewSwitcher.



使用imageSwitcher的关键就是需要一个工厂类来创建在ImageSwitcher上显示的View对象(在本例中是ImageView对象)。

这个工厂类需要实现android.widget.ViewSwitcher.ViewFactory接口，并在该接口的makeView方法中创建View对象。

*/

@Override

public View makeView()

{

ImageView imageView = new ImageView(this);

imageView.setBackgroundColor(0xFF000000);

imageView.setScaleType(ImageView.ScaleType.FIT_CENTER);

imageView.setLayoutParams(new ImageSwitcher.LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
return imageView;

}



public class ImageAdapter extends BaseAdapter

{

private Context mContext;
public ImageAdapter(Context context)

{

mContext = context;

}
public int getCount()

{

return Integer.MAX_VALUE;

}
public Object getItem(int position)

{

return position;

}
public long getItemId(int position)

{

return position;

}
//设置ImageView控件的显示风格和图像资源

public View getView(int position, View convertView, ViewGroup parent)

{

ImageView imageView = new ImageView(mContext);
imageView.setImageResource(resIds[position % resIds.length]);

imageView.setScaleType(ImageView.ScaleType.FIT_XY);

imageView.setLayoutParams(new Gallery.LayoutParams(80, 60));

//imageView.setLayoutParams(new Gallery.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));

imageView.setBackgroundResource(R.drawable.picture_frame);
return imageView;

}

}

}

模拟器：ListView

一、普通的ListView

ListView用来以列表的形式显示数据。ListView控件采用MVC模式将前端显示与后端数据进行分离。ListView控件在转载数据时需要指定一个Adapter对象。Adapter对象相当于MVC模式中的Controller，ListView相当于MVC模式中的View，为ListView提供数据的List或数组相当于MVC模式中的Model。要显示的数据与ListView之间通过Adapter对象进行连接，同时又相对独立。

向ListView控件加载数据之前需要创建一个Adapter对象，代码如下所示：

ArrayAdapter aaData = new ArrayAdapter(this, android.R.layout.simple_list_item_1, data);

ArrayAdapter的构造函数有三个参数，第一个为android.content.Context对象；第二个指定列表项的模板，也就是一个XML布局文件的资源ID；第三个指定在列表项中显示的数据。本例中使用的是Android SDK提供的XML布局文件，该布局文件对应的资源ID是android.R.layout.simple_list_item_1，该文件可以在Android SDK的安装路径下找到，比如说“D:\android\android_sdk\platforms\android-1.5\data\res\layout”。simple_list_item_1.xml里面的内容如下：


android:id="@android:id/text1"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textAppearance="?android:attr/textAppearanceLarge"

android:gravity="center_vertical"

android:paddingLeft="6dip"

android:minHeight="?android:attr/listPreferredItemHeight"

/>

从这段代码可以看出，在布局文件中只有一个TextView标签，因此，使用这个布局文件相当于在ListView中只显示简单的文本列表项。

例子1

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content" />


main.java：

public class Main extends Activity implements OnItemSelectedListener, OnItemClickListener

{

//如果列表项要显示的文字太长，将会自动换行显示

private static String[] data = new String[]{ "机器化身", "变形金刚", "第九区", "火星任务", "人工智能", "钢铁侠",

"铁臂阿童木 ", "未来战士", "星际传奇", "侏罗纪公园2:失落的世界 简介：由史蒂文-斯皮尔伯格率领《侏罗纪公园》的高个子数学专家杰夫高布伦，重回培养过恐龙的桑纳岛。" };
@Override

public void onItemSelected(AdapterView parent, View view, int position, long id)

{

Log.d("itemselected", "select " + position + " item");

}
@Override

public void onNothingSelected(AdapterView parent)

{

Log.d("nothingselected", "nothing selected");

}



@Override

public void onItemClick(AdapterView parent, View view, int position, long id)

{

Log.d("itemclick", "click " + position + " item");

}



@Override

protected void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

ListView lvCommonListView = (ListView) findViewById(R.id.lvCommonListView);
//将ArrayAdapter构造方法的最后一个参数改成dataList，系统就会加载List对象的数据

//List dataList = new ArrayList();

//dataList.add("机器化身");

//dataList.add("火星任务");

ArrayAdapter aaData = new ArrayAdapter(this, android.R.layout.simple_list_item_1, data);
//使用setAdapter后，ListView控件的每一个列表项都会使用simple_list_item_1.xml文件定义的模板来显示

//并将data数组中每一个元素赋值给每一个列表项(一个列表项就是在simple_list_item_1.xml中定义的TextView控件)

lvCommonListView.setAdapter(aaData);
//默认情况下，ListView控件选中的是第一项。如果想一开始就选中指定的列表项，需要使用ListView类的setSelection方法

lvCommonListView.setSelection(6);

lvCommonListView.setOnItemClickListener(this);

lvCommonListView.setOnItemSelectedListener(this);

}

}
模拟器：
可以单选和多选的ListView

上面的例子只显示简单的文本，不能进行选择。如果想对列表项进行选择，可以用系统自带的其它布局文件。这几个布局文件对应的资源ID以及xml文件里面的具体内容如下所示：

android:R.layout.simple_list_item_checked：


android:id="@android:id/text1"

android:layout_width="fill_parent"

android:layout_height="?android:attr/listPreferredItemHeight"

android:textAppearance="?android:attr/textAppearanceLarge"

android:gravity="center_vertical"

android:checkMark="?android:attr/textCheckMark"

android:paddingLeft="6dip"

android:paddingRight="6dip"

/>

android:R.layout.simple_list_item_single_choice：


android:id="@android:id/text1"

android:layout_width="fill_parent"

android:layout_height="?android:attr/listPreferredItemHeight"

android:textAppearance="?android:attr/textAppearanceLarge"

android:gravity="center_vertical"

android:checkMark="?android:attr/listChoiceIndicatorSingle"

android:paddingLeft="6dip"

android:paddingRight="6dip"

/>

android:R.layout.simple_list_item_multiple_choice：


android:id="@android:id/text1"

android:layout_width="fill_parent"

android:layout_height="?android:attr/listPreferredItemHeight"

android:textAppearance="?android:attr/textAppearanceLarge"

android:gravity="center_vertical"

android:checkMark="?android:attr/listChoiceIndicatorMultiple"

android:paddingLeft="6dip"

android:paddingRight="6dip"

/>

虽然从显示的效果图上看，上述三个布局文件添加的是RadioButton、CheckBox、CheckedTextView控件，但是实际上这三个布局文件中只使用了CheckedTextView控件，之所以风格会不一样，是因为设置了CheckedTextView标签的android:checkMark属性。
例子1

main.xml：




android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_height="wrap_content"

android:text="CheckedTextView"

android:background="#FFF"

android:textColor="#000"

android:gravity="center" />


android:layout_width="fill_parent"

android:layout_height="wrap_content" />




android:layout_height="wrap_content"

android:text="RadioButton"

android:background="#FFF"

android:textColor="#000"

android:gravity="center" />


android:layout_width="fill_parent"

android:layout_height="wrap_content" />




android:layout_height="wrap_content"

android:text="CheckBox"

android:background="#FFF"

android:textColor="#000"

android:gravity="center" />


android:layout_width="fill_parent"

android:layout_height="wrap_content" />


main.java：

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

requestWindowFeature(Window.FEATURE_NO_TITLE);//设置该Activity没有titlebar

setContentView(R.layout.main);



ListView lvCheckedTextView = (ListView) findViewById(R.id.lvCheckedTextView);

ListView lvRadioButton = (ListView) findViewById(R.id.lvRadioButton);

ListView lvCheckBox = (ListView) findViewById(R.id.lvCheckBox);

String[] data = new String[]{ "变形金刚2","阿凡达"};
ArrayAdapter aaCheckedTextViewAdapter = new ArrayAdapter(this, android.R.layout.simple_list_item_checked, data);

lvCheckedTextView.setAdapter(aaCheckedTextViewAdapter);

//如果只设置列表项的模板，也就是这几个布局文件，在单击列表项时相应选项并不会被选中

//因此，在设置列表项的模板后，还需要使用ListView类的setChoiceMode方法设置选择的模式:单选模式or多选模式

//这三种布局形式，都可以设置为单选或者多选的模式

lvCheckedTextView.setChoiceMode(ListView.CHOICE_MODE_SINGLE);//单选模式
ArrayAdapter aaRadioButtonAdapter = new ArrayAdapter(this, android.R.layout.simple_list_item_single_choice, data);

lvRadioButton.setAdapter(aaRadioButtonAdapter);

lvRadioButton.setChoiceMode(ListView.CHOICE_MODE_SINGLE);//单选模式
ArrayAdapter aaCheckBoxAdapter = new ArrayAdapter(this, android.R.layout.simple_list_item_multiple_choice, data);

lvCheckBox.setAdapter(aaCheckBoxAdapter);

lvCheckBox.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);//多选模式

}

}
模拟器：
使用SimpleAdapter建立复杂的列表项

在某些Activity中，只包含一个ListView，这时候使用ListActivity是非常方便的。ListAcitvity实际上是ListView和Activity的结合，一个ListActivity只包含一个ListView控件，在ListActivity类的内部通过代码来创建ListView对象，因此，使用ListActivity并不需要使用XML布局文件来定义ListView控件。

我们可以使用ListActivity类的setListAdapter方法来设置Adapter对象。该方法相当于调用了ListView类的setAdapter方法。当然我们也可以通过ListActivity类的getListView方法获得当前ListActivity的ListView对象，并像操作普通的ListView对象一样它。

目前，SimpleAdapter类只支持以下三种控件：实现Checkable接口的控件、TextView及其子类、ImageView及其子类。如果在列表中出现了其它的控件，除非这些控件使用的是静态值，否则无法使用SimpleAdapter动态地为这些控件设置相应的值。SimpleAdapter类只有一个构造方法，其定义如下：

SimpleAdapter(Context context, List> data, int resource, String[] from, int[] to)

data： 其是一个List类型的参数，而List对象的元素类型是Map。比如下面的这个例子，代码中定义了三个控件，一个ImageView，两个TextView，这个布局文件将作为列表项的模板来显示每一个列表项。因此，每一个列表项都要根据不同的情况设置ImageView的图像和两个TextView的文本。假设要添加两个列表项，就意味着要设置6个值(每个列表项3个值)。每个列表项的值可以用一个Map对象来表示。key表示相应组件的id值(在下面的例子中，是ivLogo、tvAuthor、tvApplicationName)，value表示具体的值。

resource： 表示列表项模板的资源ID，在下面的例子中，是R.layout.main

from： 表示XML布局文件中控件标签的Android:id属性值

to： 表示XML布局文件中控件对应的资源ID，from和to两组参数的相对顺序要一致
main.xml：




android:orientation="horizontal" android:layout_width="fill_parent"

android:layout_height="wrap_content">


android:layout_width="60dp"

android:layout_height="60dp"

android:alt="51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译" src="@drawable/icon"

android:paddingLeft="10dp" />




android:orientation="vertical"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:gravity="right"

android:padding="10dp">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:textSize="16dp" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_below="@id/tvApplicationName"

android:textSize="14dp" />






main.java：

public class Main extends ListActivity

{

private static String[] applicationNames = new String[]

{ "多功能日历", "eoeMarket客户端", "耐玩的重力消砖块", "白社会", "程序终结者" };



private static String[] authors = new String[]

{ "李宁", "eoemobile", "wawa", "ApkHome", "lucyfa" };



private static int[] resIds = new int[]

{ R.drawable.calendar, R.drawable.eoemarket, R.drawable.brick, R.drawable.whitesociety, R.drawable.terminater };
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

List> appItems = new ArrayList>();
for (int i = 0; i < applicationNames.length; i++)

{

Map appItem = new HashMap();

appItem.put("ivLogo", resIds[i]);

appItem.put("tvAuthor", authors[i]);

appItem.put("tvApplicationName", applicationNames[i]);

appItems.add(appItem);

}



SimpleAdapter simpleAdapter = new SimpleAdapter(this,

appItems,

R.layout.main,

new String[]{"tvApplicationName", "ivLogo", "tvAuthor" },

new int[]{R.id.tvApplicationName, R.id.ivLogo, R.id.tvAuthor});
setListAdapter(simpleAdapter);

}

}
模拟器：
自定义Adapter来建立复杂的列表项

由于SimpleAdapter类目前只支持以下三种控件：实现Checkable接口的控件、TextView及其子类、ImageView及其子类，如果在列表中出现了其它的控件，除非这些控件使用的是静态值，否则无法使用SimpleAdapter动态地为这些控件设置相应的值。在本例中除了使用ImageView和TextView控件以外，还是用了一个评分控件RatingBar来显示应用程序的分数。因此，无法使用SimpleAdapter来为每一个列表项中的控件赋值。所以，在本例中使用自定义Adapter类来处理每一个列表项中的控件。
rating.xml：




android:orientation="horizontal"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:gravity="center_vertical">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:numStars="5"/>


main.xml：




android:orientation="horizontal" android:layout_width="fill_parent"

android:layout_height="wrap_content" android:gravity="center_vertical">


android:layout_width="60dp"

android:layout_height="60dp"

android:alt="51CTO下载-Android基础知识详解,毕业论文设计,开题报告,外文翻译" src="@drawable/icon"

android:paddingLeft="5dp" />




android:orientation="vertical"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:gravity="right"

android:padding="10dp">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:textSize="16dp" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_below="@id/tvApplicationName"

android:textSize="14dp" />






android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:gravity="right"

android:padding="10dp">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="5.0" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:numStars="5"

style="?android:attr/ratingBarStyleSmall"

android:layout_below="@id/tvRating" />






Main.java：

public class Main extends ListActivity

{

private static String[] applicationNames = new String[]

{ "多功能日历", "eoeMarket客户端", "耐玩的重力消砖块", "白社会", "程序终结者" };



private static String[] authors = new String[]

{ "李宁", "eoemobile", "wawa", "ApkHome", "lucyfa" };



private static int[] resIds = new int[]

{ R.drawable.calendar, R.drawable.eoemarket, R.drawable.brick, R.drawable.whitesociety, R.drawable.terminater };



private static float[] applicationRating = new float[]

{ (float) 5.0, (float) 5.0, (float) 3.5, (float) 5.0, (float) 4.0 };



private String inflater = Context.LAYOUT_INFLATER_SERVICE;

private LayoutInflater layoutInflater;

private RatingAdapter raAdapter;
private class RatingAdapter extends BaseAdapter

{

private Context context;
public RatingAdapter(Context context)

{

this.context = context;

layoutInflater = (LayoutInflater) context.getSystemService(inflater);

}
@Override

public int getCount()

{

return applicationNames.length;

}
@Override

public Object getItem(int position)

{

return applicationNames[position];

}
@Override

public long getItemId(int position)

{

return position;

}
//在单击每一个列表项时会弹出一个设置当前列表项中应用程序分数的对话框，因此需要在RatingAdapter类中添加一个setRating方法来设置分数

public void setRating(int position, float rating)

{

applicationRating[position] = rating;

notifyDataSetChanged();

}
@Override

public View getView(int position, View convertView, ViewGroup parent)

{

LinearLayout linearLayout = (LinearLayout)layoutInflater.inflate(R.layout.main, null);

ImageView ivLogo = (ImageView) linearLayout.findViewById(R.id.ivLogo);

TextView tvApplicationName = ((TextView) linearLayout.findViewById(R.id.tvApplicationName));

TextView tvAuthor = (TextView) linearLayout.findViewById(R.id.tvAuthor);

TextView tvRating = (TextView) linearLayout.findViewById(R.id.tvRating);

RatingBar ratingBar = (RatingBar) linearLayout.findViewById(R.id.ratingbar);



ivLogo.setImageResource(resIds[position]);

tvApplicationName.setText(applicationNames[position]);

tvAuthor.setText(authors[position]);

tvRating.setText(String.valueOf(applicationRating[position]));

ratingBar.setRating(applicationRating[position]);

return linearLayout;

}

}
@Override

protected void onListItemClick(ListView l, View view, final int position, long id)

{

View myView = getLayoutInflater().inflate(R.layout.rating, null);

final RatingBar ratingBar = (RatingBar) myView.findViewById(R.id.ratingbar);

ratingBar.setRating(applicationRating[position]);



new AlertDialog.Builder(this)

.setTitle(applicationNames[position])

.setMessage("给应用程序打分")

.setIcon(resIds[position])

.setView(myView)

.setPositiveButton("确定", new OnClickListener(){

public void onClick(DialogInterface dialog, int which)

{

raAdapter.setRating(position, ratingBar.getRating());

}

})

.setNegativeButton("取消", null)

.show();

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);
List viewList = new ArrayList();

viewList.add(getLayoutInflater().inflate(R.layout.main, null));

raAdapter = new RatingAdapter(this);

setListAdapter(raAdapter);

}

}
模拟器：
动态添加、删除ListView列表项

Android/OPhone 开发完全讲义 P112
改变ListView列表项选中状态的背景颜色

Android/OPhone 开发完全讲义 P115
可展开的列表组件

Android/OPhone 开发完全讲义 P120

数据的存取

SharePreferences 6.1

SharePreferences的基本使用方式

SharePreferences数据的存储位置

设置存取数据的文件的访问权限

PreferenceActivity

文件的存储6.2

普通文件的存取

文件的浏览

XML文件的解析

SAX解析XML文件

SAX是一种占用内存少且解析速度快的解析器，它采用的是事件驱动，它不需要解析完整个文档，而是按照内容顺序看文档某个部分是否符合xml语法，如果符合就触发相应的事件，所谓的事件就是些回调方法（callback）,这些方法定义在ContentHandler中，下面是其主要方法：

startDocument 、startElement、endElement、charachers、endDocument

DOM解析XML文件

DOM解析XML文件时，会将XML文件的所有内容以文档树方式存放在内存中，然后允许您使用DOM API遍历XML树、检索所需的数据。使用DOM操作XML的代码看起来是比较直观的，并且在某些方面比基于SAX的实现更加简单。但是，因为DOM需要将XML文件的所有内容以文档树方式存放在内存中，所以内存的消耗比较大，特别对于运行Android的移动设备来说，因为设备的资源比较宝贵，所以建议还是采用SAX来解析XML文件，当然，如果XML文件的内容比较小采用DOM也是可行的。

除了可以使用SAX和DOM解析XML文件，大家也可以使用Android内置的Pull解析器解析XML文件。Pull解析器的运行方式与 SAX 解析器相似。

SQLite数据库6.4

http://www.cnblogs.com/TerryBlog/archive/2010/07/05/1771459.html

使用过 SQLite 数据库的童鞋对 Cursor 应该不陌生，如果你是搞.net 开发你大可以把Cursor理解成 Ado.net 中的数据集合相当于dataReader。今天特地将它单独拿出来谈，加深自己和大家对Android 中使用 Cursor 的理解。

关于 Cursor

在你理解和使用 Android Cursor 的时候你必须先知道关于 Cursor 的几件事情：

Cursor 是每行的集合。

使用 moveToFirst() 定位第一行。

你必须知道每一列的名称。

你必须知道每一列的数据类型。

Cursor 是一个随机的数据源。

所有的数据都是通过下标取得。
关于 Cursor 的重要方法

close()

关闭游标，释放资源

copyStringToBuffer(int columnIndex, CharArrayBuffer buffer)

在缓冲区中检索请求的列的文本，将其存储

getColumnCount()

返回所有列的总数

getColumnIndex(String columnName)

返回指定列的名称，如果不存在返回-1

getColumnIndexOrThrow(String columnName)

从零开始返回指定列名称，如果不存在将抛出IllegalArgumentException 异常。

getColumnName(int columnIndex)

从给定的索引返回列名

getColumnNames()

返回一个字符串数组的列名

getCount()

返回Cursor 中的行数

moveToFirst()

移动光标到第一行

moveToLast()

移动光标到最后一行

moveToNext()

移动光标到下一行

moveToPosition(int position)

移动光标到一个绝对的位置

moveToPrevious()

移动光标到上一行

部分代码演示

下面来看看一小段代码：

if (cur.moveToFirst() == false)

{

//为空的Cursor

return;

}
访问 Cursor 的下标获得其中的数据

int nameColumnIndex = cur.getColumnIndex(People.NAME);

String name = cur.getString(nameColumnIndex);
现在让我们看看如何循环 Cursor 取出我们需要的数据

while(cur.moveToNext())

{

//光标移动成功

//把数据取出

}

当cur.moveToNext() 为假时将跳出循环，即 Cursor 数据循环完毕。
如果你喜欢用 for 循环而不想用While 循环可以使用Google 提供的几下方法：

isBeforeFirst()

isAfterLast()

isClosed()

有了以上的方法，可以如此取出数据：

for(cur.moveToFirst();!cur.isAfterLast();cur.moveToNext())

{

int nameColumn = cur.getColumnIndex(People.NAME);

int phoneColumn = cur.getColumnIndex(People.NUMBER);

String name = cur.getString(nameColumn);

String phoneNumber = cur.getString(phoneColumn);

}
Tip:在Android 查询数据是通过Cursor 类来实现的。当我们使用 SQLiteDatabase.query()方法时，就会得到Cursor对象，Cursor所指向的就是每一条数据。结合ADO.net的知识可能好理解一点。

ContentProvider、ContentResolver 6.5

如何将应用程序的数据暴露出去？ContentProvider是应用程序与外界(其它应用程序)共享数据的桥梁。ContentProvider的最直接表现是向其它应用程序提供了一个Cursor对象，然后使用ContentProvider的程序可以像操作记录集一样操作Cursor对象。至于Cursor是如何创建的(有可能是对应一个查询结果集，也有可能是XML或者其他类型的数据)并不重要。

如何通过一套标准及统一的接口获取其他应用程序暴露的数据？Android提供了ContentResolver，外界的程序可以通过ContentResolver接口访问ContentProvider提供的数据。

Intent

用Intent启动Activity，并在Activity之间传递数据

我们知道，通过startActivity方法可以启动一个Activity，代码如下所示：

Intent browserIntent = new Intent( this, Test.class );

startActivity( browserIntent );

该代码只是简单的启动了一个Activity，如果要向新启动的Activity传递数据，该如何做呢？实际上，在Intent类中有一个putExtra方法，该方法有多种重载形式，下面是常见的几个：

public Intent putExtra (String name, String value)

public Intent putExtra (String name, int value)

public Intent putExtra (String name, boolean value)

public Intent putExtra (String name, Serializable value)

……

从这些重载方法可以看出，putExtra方法可以保存各种类型的值，当用startActivity方法启动Activity时，这些值也会一同随Intent对象传递到新启动的Activity。然后在新的Activity中可以通过getIntent().getExtras()获得一个Bundle对象，并通过该对象的getXxx方法(Xxx表示String、Int等等)来获得通过putExtra方法保存的值。

在下面的例子中，有一个Browser类，在该类中获取从Main类传过去的数据，并显示在TextView控件中。在Main类中向Brower传递了3种类型的值：String、int和可序列化的对象(如果要使用putExtra方法保存复杂类型的值，比如说对象，要求这些复杂类型的值必须是可序列化的，也就是其对应的类必须实现java.io.Serizlizable接口)。下面是这个例子的主要代码：

Main.java：

class Data implements Serializable //可序列化的对象

{

private static final long serialVersionUID = 1L;

public String name = "android version";

public float[] values = new float[]{ 1.0f, 1.5f, 1.6f, 2.0f, 2.1f, 2.2f, 3.0f};

}
public class Main extends Activity implements OnClickListener

{
//系统通过onActivityResult获取Process的返回值

protected void onActivityResult(int requestCode, int resultCode, Intent data)

{

switch (requestCode)

{

//首先判断返回的请求代码，也就是startActivityForResult(processIntent, R.layout.process)方法的第二个参数值

//在本例中直接使用了与Precess类对应的XML布局文件的资源ID作为请求代码

case R.layout.process:

//在Process这个Activity中，单击确定，返回的结果代码是20

if (resultCode == 20)

{

Toast.makeText(this, data.getStringExtra("text"), Toast.LENGTH_LONG).show();

}

//在Process这个Activity中，单击取消，返回的结果代码是21

else if (resultCode == 21)

{

Toast.makeText(this, "您取消了操作", Toast.LENGTH_LONG).show();

}

break;

default:

break;

}



super.onActivityResult(requestCode, resultCode, data);

}
@Override

public void onClick(View v)

{

switch (v.getId())

{

case R.id.btnStartActivity: //向另外一个Activity传送数据

Data data = new Data();

Intent browserIntent = new Intent(this, Browser.class);

browserIntent.putExtra("name", "wuliming_sc@qq.com");

browserIntent.putExtra("age", 10);

browserIntent.putExtra("data", data);

startActivity(browserIntent);

break;



case R.id.btnReturn: //从另外一个Activity接收数据

Intent processIntent = new Intent(this, Process.class);

//要想从Activity中获得返回数据，在启动Activity时必须使用startActivityForResult方法

startActivityForResult(processIntent, R.layout.process);

break;

}

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

Button btnStartActivity = (Button) findViewById(R.id.btnStartActivity);

Button btnReturn = (Button) findViewById(R.id.btnReturn);

btnStartActivity.setOnClickListener(this);

btnReturn.setOnClickListener(this);

}

}
Browser.java：

public class Browser extends Activity

{

@Override

protected void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.browser);

TextView textView = (TextView)findViewById(R.id.textview);

Bundle bundle = getIntent().getExtras();

String s = "";

s += "name:" + bundle.getString("name") + "\n";

s += "age:" + bundle.getInt("age") + "\n";

Data data =(Data) bundle.getSerializable("data");

s += "Data.name:" + data.name + "\n";

String values = "";

for(int i = 0; i < data.values.length; i++)

{

values += data.values[i] + " ";

}

s += "Data.values:" + values;

textView.setText(s);

}

}

Process.java：

public class Process extends Activity implements OnClickListener

{

private EditText editText;
@Override

public void onClick(View v)

{

switch (v.getId())

{

case R.id.btnOK: //单击确定按钮后，系统会关闭当前Activity，并将文本框里面的值保存在Intent中

getIntent().putExtra("text", editText.getText().toString());

setResult(20, getIntent());

break;
case R.id.btnCancel: //单击取消按钮，使用如下代码设置结果代码

setResult(21);

break;

}

finish();
}
@Override

protected void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.process);

editText = (EditText) findViewById(R.id.edittext);

Button btnOK = (Button) findViewById(R.id.btnOK);

Button btnCancel = (Button) findViewById(R.id.btnCancel);

btnOK.setOnClickListener(this);

btnCancel.setOnClickListener(this);

}

}
AndroidManifest.xml：




package="net.blogjava.mobile" android:versionCode="1"

android:versionName="1.0">
























模拟器：调用其他应用程序中的Activity(打电话、浏览网页、发Email等)

前一部分，使用如下方法创建Intent对象：

public HYPERLINK "file:///D:\\android\\android_sdk\\docs\\reference\\android\\content\\Intent.html" \l "Intent(android.content.Context, java.lang.Class)" Intent( HYPERLINK "file:///D:\\android\\android_sdk\\docs\\reference\\android\\content\\Context.html" Context packageContext, HYPERLINK "file:///D:\\android\\android_sdk\\docs\\reference\\java\\lang\\Class.html" Class cls );

第一个参数的类型是Context，一般传入的参数是this或者context，第二个参数的类型是Activity类的class对象，比如Process.class。实际上，Intent除了这种构造方法以外，还有许多其他的重载形式，下面是两种较为常用Intent构造方法的重载形式：

Intent(String action) ;

Intent(String action, Uri uri);

在这两个构造方法中，参数类型并不是Context和Class，而是String和uri。使用这种参数类型的Intent对象被称为隐式Intent对象(直接指定Context和Class的称为显示Intent对象)。也就是说，通过Intent类的构造方法并没有明确指定Intent的目标是哪一个Activity，这些目标要依靠在AndroidManifest.xml文件中的配置信息才能确定。也就是说，action所指的目标可能不止一个。下面是一个例子：

AndroidManifest.xml:




package="net.blogjava.mobile" android:versionCode="1"

android:versionName="1.0">






















Main.xml：




android:orientation="vertical" android:layout_width="fill_parent"

android:layout_height="fill_parent">


android:layout_width="fill_parent"

android:layout_height="wrap_content">


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="电话号" />


android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:layout_marginLeft="10dp" />






android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="直接拨号" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="调用通话记录" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="将电话号传入拨号程序" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="浏览网页" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="向Email客户端传递Email地址" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="发送Email" />


android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="选择音频程序" />

Main.java：

public class Main extends Activity implements OnClickListener

{

private EditText etPhone;
@Override

public void onClick(View view)

{

switch (view.getId())

{

//直接拨打在文本框中输入的电话号码，拨号功能对应的Action是Intent.ACTION_CALL，使用这个Action不需要指定一个Uri

case R.id.btnCall:

Intent callIntent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + etPhone.getText().toString()));

startActivity(callIntent);

break;

//调用通话记录的Action是Intent.ACTION_CALL_BUTTON，该Action没有输入，也没有输出

case R.id.btnCallButton:

Intent callButtonIntent = new Intent(Intent.ACTION_CALL_BUTTON);

startActivity(callButtonIntent);

break;

//将电话号传入拨号程序。如果不想直接拨打输入的电话号码，而只想将电话号码自动传入Android内置的拨号程序，然后再做进一步的处理，

//需要使用Intent.ACTION_DIAL，该Action也需要一个“tel:电话号码“ 格式的uri

case R.id.btnDial:

Intent dialIntent = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:" + etPhone.getText().toString()));

startActivity(dialIntent);

break;

//浏览网页。Android SDK内置的Web浏览器也对外提供了Action，可以通过调用这个Action来传递一个web网址，并通过浏览器打开它

case R.id.btnWeb:

Intent webIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://blog.csdn.net/wuliming_sc"));

startActivity(webIntent);

break;

//向Email客户端传递Email地址。Email客户端提供了一个Action，可以通过这个Action将一个Email地址发送到Email客户端输入

//Email的文本框

case R.id.btnSendToEmail:

Uri uri = Uri.parse("mailto:test@qq.com");

Intent intent = new Intent(Intent.ACTION_SENDTO, uri);

startActivity(intent);

break;
//发送Email：在许多情况下需要传递的不仅仅是一个Email地址，还包括Email标题、内容等实质性的信息。这些信息可以通过

//Intent.ACTION_SEND传递。

case R.id.btnSendEmail:

Intent sendEmailIntent = new Intent(Intent.ACTION_SEND);

sendEmailIntent.putExtra(Intent.EXTRA_EMAIL, new String[]{ "techcast@126.com" });

sendEmailIntent.putExtra(Intent.EXTRA_CC, new String[]{ "abc@126.com", "test@126.com" });

sendEmailIntent.putExtra(Intent.EXTRA_SUBJECT, "关于Android的两个技术问题");

sendEmailIntent.putExtra(Intent.EXTRA_TEXT, "1. 如何调用其他应用程序中的Activity?\n2. 在应用程序中如果接收系统广播？");

sendEmailIntent.setType("text/plain");

// Intent.createChooser方法可以创建一个自定义的选择器。在Android系统中，支持Intent.ACTION_SEND动作的不只有email

//客户端，还有一个发送短信的客户端，甚至还可能有其它的支持Intent.ACTION_SEND的客户端，因此，单击”发送email”按钮不会

//直接进入发送email的界面，而是弹出一个可供选择的菜单

startActivity(Intent.createChooser(sendEmailIntent, "选择发送消息的客户端"));

break;

//我们可以通过Intent.ACTION_GET_CONTENT动作来选择拥有相同类型的应用。在下面的代码中通过setType方法设置了应用程序的类型

//“audio/*”，该类型表示选择系统中所有支持音频功能的应用

case R.id.btnAudio:

Intent audioIntent = new Intent(Intent.ACTION_GET_CONTENT);

audioIntent.setType("audio/*");

startActivity(Intent.createChooser(audioIntent, "选择音频程序"));

break;

}

}
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

Button btnCall = (Button) findViewById(R.id.btnCall);

Button btnCallButton = (Button) findViewById(R.id.btnCallButton);

Button btnDial = (Button) findViewById(R.id.btnDial);

Button btnWeb = (Button) findViewById(R.id.btnWeb);

Button btnAudio = (Button) findViewById(R.id.btnAudio);

Button btnSendToEmail = (Button) findViewById(R.id.btnSendToEmail);

Button btnSendEmail = (Button) findViewById(R.id.btnSendEmail);

etPhone = (EditText) findViewById(R.id.etPhone);

btnCall.setOnClickListener(this);

btnCallButton.setOnClickListener(this);

btnDial.setOnClickListener(this);

btnWeb.setOnClickListener(this);

btnAudio.setOnClickListener(this);

btnSendToEmail.setOnClickListener(this);

btnSendEmail.setOnClickListener(this);

}

}
模拟器：
接收和发送广播

Intent不仅可以启动Activity，还可以发送广播。Broadcast Action和Activity Action一样，既可以由系统负责广播，也可以由自己的应用程序负责广播。可以实现某些特殊功能，比如，在开机时自动启动某一个应用程序；当接收到短信时自动提取或保存短信记录等等。实际上，在手机中发生这样的事件时，Android都会向整个系统发送相应的Broadcast Action。如果应用程序接收到这些Broadcast Action，就可以来完成相应的功能。

接收系统广播

接收系统广播一般需要以下两个步骤：

（1）、编写一个继承自android.content.BroadcastReceiver的类，并实现该类中的onReceive方法。如果应用程序接收到系统发送的广播，就会调用onReceive方法。

（2）、在AndroidManifest.xml文件中使用标签来指定在第一步中编写的接收系统广播的类可以接收哪一个Broadcast Action。

完成这两步后，运行程序，这时程序已经安装在手机或者模拟器上了，然后可以退出程序。这时只要Android系统向外广播应用程序可以接收的Broadcast Action，并且该程序未被卸载，系统就会自动调用onReceive方法来处理这个Broadcast Action。下面是几个接收系统广播的例子：

开机自动运行的程序

AndroidManifest.xml：




package="net.blogjava.mobile.startup" android:versionCode="1"

android:versionName="1.0">








































Main.java：

public class Main extends Activity

{

@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

}

}
StartupReceiver.java：

public class StartupReceiver extends BroadcastReceiver

{

@Override

public void onReceive(Context context, Intent intent)

{

Intent mainIntent = new Intent(context, Main.class);

mainIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(mainIntent);

}

}
模拟器：
运行该程序，运行完毕后，即可关闭该程序。然后重新启动模拟器，会发现模拟器在启动后总是先运行该程序。
接收短信

短信是手机中经常使用的一种服务。当手机接收到短信的时候，会向系统发送广播。如果我们的应用程序要在手机收到短信后做点什么，就需要接收这个系统广播。下面是一个接收短信系统广播的例子：

AndroidManifest.xml：




package="net.blogjava.mobile.sms" android:versionCode="1"

android:versionName="1.0">





























标签为应用程序打开接收短信的权限 -->




Main.java：

public class Main extends Activity

{

public TextView textView;
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

textView = (TextView) findViewById(R.id.textview);

}

}
SMSReceiver.java：

public class SMSReceiver extends BroadcastReceiver

{

@Override

public void onReceive(Context context, Intent intent)

{

if ("android.provider.Telephony.SMS_RECEIVED".equals(intent.getAction()))

{

StringBuilder sb = new StringBuilder();

Bundle bundle = intent.getExtras();// 接收由SMS传过来的数据



if (bundle != null)// 判断是否有数据

{

//通过pdus可以获得接收到的所有短信消息

Object[] objArray = (Object[]) bundle.get("pdus");

//构建短信对象array,并依据收到的对象长度来创建array的大小

SmsMessage[] messages = new SmsMessage[objArray.length];

for (int i = 0; i < objArray.length; i++)

{

messages[i] = SmsMessage.createFromPdu((byte[]) objArray[i]);

}
/* 将送来的短信合并自定义信息于StringBuilder当中 */

for (SmsMessage currentMessage : messages)

{

sb.append("短信来源:\n");

sb.append(currentMessage.getDisplayOriginatingAddress());// 获得接收短信的电话号码

sb.append("\n短信内容:\n");

sb.append(currentMessage.getDisplayMessageBody());// 获得短信的内容

}

}



Intent mainIntent = new Intent(context, Main.class);

mainIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(mainIntent);

Toast.makeText(context, sb.toString(), Toast.LENGTH_LONG).show();

}

}

}
模拟器：
在编写SMSReceiver类时需要注意以下几点：

接收短信的Broadcast Action是android.provider.Telephony.SMS_RECEIVED，因此，要在onReceive方法的开始部分判断接收到的是否是接收短信的Broadcast Action。

需要通过Bundle.get(“pdus”)来获得接收到的短消息。其返回一个表示短信内容的数组，每一个数组元素表示一条短信。这就意味着通过Bundle.get(“pdus”)可以返回多条系统接收到的短信内容。

通过Bundle.get(“pdus”)返回的数组不能直接使用，需要使用Smsmessage.createFromPdu方法将这些数组元素转换成SmsMessage对象才可以方便的使用。每一个SmsMessage对象表示一条短信。

通过SmsMessage类的getDisplayOriginatingAddress方法可以获得发送短信的电话号码。通过getDisplayMessageBody可以获得短信的内容。

显示手机电池的当前电量

如果在手机上进行某些耗电的工作，提前查一下手机电池当前的电量是一个好主意，如发现手机电池电量不足，可以进行相应的提示。查看电池的电量需要接收一个系统广播，在下面例子中实现的接收器不是在AndroidManifest.xml中使用标签定义的，而是在程序中通过registerReceiver方法进行注册的。

AndroidManifest.xml：




package="net.blogjava.mobile"

android:versionCode="1"

android:versionName="1.0">





















Main.java：

public class Main extends Activity

{

private TextView tvBatteryChanged;

private BroadcastReceiver batteryChangedReceiver = new BroadcastReceiver()

{
@Override

public void onReceive(Context context, Intent intent)

{

if (Intent.ACTION_BATTERY_CHANGED.equals(intent.getAction()))

{

//level表示当前电量的值

int level = intent.getIntExtra("level", 0);

//scale表示电量的总刻度

int scale = intent.getIntExtra("scale", 100);

//将电量换算成百分比

tvBatteryChanged.setText("电池用量：" + (level * 100 / scale) + "%");

}

}

};
@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

tvBatteryChanged = (TextView) findViewById(R.id.tvBatteryChanged);

//注册Receiver

registerReceiver(batteryChangedReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));

}

}

模拟器：在自己的应用程序中发送广播

如果在自己的应用程序中发生某些动作时想通知其他的应用程序或向其他的应用程序传递数据，就可以考虑通过sendBroadcast方法发送广播。使用sendBroadcast方法发送的数据实际上也是Intent对象。只是通过Intent对象指定的是Broadcast Action，而不是Activity Action。比如下面的代码向系统发送一条广播：

Intent broadcastIntent = new Intent（“net.blogjava.mobile.MYBROADCAST”）；

broadcastIntent.putExtra(“name”,“broadcast”);

sendBroadcast(broadcastIntent);

接收这条广播与接收Activity Action类似，通过getExtras方法获得Bundle对象，然后通过Bundle类的getXxx方法获得相应的广播数据。

具体的实例可以参考：《Android/OPhone开发完全讲义》P180Android服务

系统服务 8.2时间服务 8.3跨进程访问 8.4这部分需要详细总结，目前暂时跳过

网络

常见《Android/OPhone开发完全讲义》第九章
图形、音频、视频

图形 10.1音频、视频 10.2

2D动画

帧动画

帧动画实际上就是由若干图像组成的动画，这些图像会以一定的时间间隔进行切换。电影的原理也有些类似于帧动画。一般电影是每秒25帧，也就是说，电影在每秒钟之内会以相等的时间间隔连续播放25幅电影静态画面。由于人的视觉停留，在这样的播放频率下，电影看起来是连续的。

...

补间动画

如果动画中的图像变换比较有规律时，可以采用自动生成中间图像的方式来生产动画，例如图像的移动、旋转、缩放等等。当然，还有更复杂的情况，比如由正方形变圆形、圆形变椭圆形，这些变换过程中的图像都可以根据一定的数学算法自动生成。我们只需要指定动画的第一帧和最后一帧的图像即可。这种自动生成中间图像的动画被称为补间动画。

补间动画的优点是节省硬盘空间，这是因为这种动画只需要提供两帧图像(第一帧和最后一帧)，其它的图像由系统自动生成。当然，这种动画也有一定的缺点，就是当动画很复杂时无法自动生成中间图像，例如由电影画面组成的动画，由于每幅画面过于复杂，系统无法预测下一幅画面是什么样子，因此，这种复杂的动画只能使用帧动画来完成。

...

OpenGL ES编程

OpenGL( Open Graphics Library 开放式图形库 )定义了一个跨编程语言、跨操作系统的性能卓越的三维图形标准。OpenGL定义了一套编程接口，任何语言都可以实现这套编程接口。目前几乎所有的流行语言都有OpenGL的实现，例如c/c++、java、c#等等。虽然DirectX是windows上使用最广泛的三维图形库，但是在专业领域以及非Windows的操作系统上，OpenGL是不二的选择。

虽然OpenGL非常强大，但是支持这些强大的功能也需要付出很高的代价，也就是说需要高性能的硬件的支持(主要是CPU和GPU)。而移动设备与同时代的PC的硬件配置还差很多，根本无法在移动设备上使用OpenGL的全部功能。因此，成立于2000年的Khronos集团推出了可以在移动设备上使用简化版本的OpenGL，成为OpenGL ES(OpenGL for Embedded Systems)。Khronos是一个图形软硬件行业协会，该协会主要关注图形和多媒体方面的开放标准。

...Android支持的各种资源
Android支持的各种资源 13.1.2

使用系统资源

字符串资源

数组资源

颜色资源

尺寸资源

类型资源

主题资源

绘画资源

动画资源

菜单资源

布局资源

属性资源

XML资源

RAW资源

ASSETS资源

对资源进行国际化窗口小部件(App Widget)NDK编程

PAGE1 / NUMPAGES125