基于Android的背单词软件设计与实现计算机毕业论文 - 图文

毕业论文

论文题目：基于

姓 名：

学 号：班 级：专 业：软件工程学 院：软件学院指导老师：完成时间：

Android的背单词软件的设计与实现 2015年4月17日

基于Android的背单词软件的设计与实现

摘 要

随着经济全球化，我们与外国人的接触越来越多，英语已经成为了中国与外面交流的主要工具，同时我国的英语教育也开始普及到了小学，人们对学习英语越来越重视。而对于学习英语特别是英语单词记忆，记忆单词的方式也在不断的更新，而今移动互联网时代的到来，尤其智能手机的广泛应用，英语学习的平台已经逐渐向计算机或者手机等移动设备上转移，背单词的方式方法进入一个新的领域。背单词软件是当下比较流行且方便有效的辅助记忆工具，本文介绍的背单词软件是一款基于android平台的应用软件，其主要功能有单词学习，单词背诵，单词测试，真人发音，添加生词本等。同时本文对背单词软件开发中有关系统设计，系统实施方法和设计词库等方面进行了探索，以此推动计算机英语辅助软件开发。

关键词： Android； 背单词； 英文学习； 软件开发

I

Design and implementation of memorizing word software based on

Android

Abstract

With the economic globalization, we contact with foreigners more and more, English has become the main tool to communicate with foreign in China, English education in our country also started to popularize the primary school, people pay more and more attention to learning English. For learning English especially in English words memory,memorize words way are also constantly updated, but now the advent of the era of mobile Internet,especially the wide application of smart phones,English learning platform has been gradually shift to computer or on mobile devices such as mobile phones,methods of memorizing words into a new field.Memorizing words software is now more popular and convenient and effective tool of memory,crouching tiger word software is introduced in this paper a based on android platform of application software,its main function is the word study, recite words, word test, pronunciation, to add the new words and so on.At the same time in this paper, the back word software development related to system design, system implementation methods and designs thesaurus has explored in such aspects,to promote English computer auxiliary software development.

Key words: Android; recite words; English study; software development

II

目 录

摘 要 ........................................................................................................................................ I Abstract .................................................................................................................................. II

1. 绪 论 .................................................................................................................................. 1 1.1研究内容 ........................................................................................................................ 1 1.2研究意义 ........................................................................................................................ 1 1.3研究现状和发展趋势 .................................................................................................... 1 2. 平台与开发工具 .................................................................................................................. 3 2.1 开发平台介绍 ............................................................................................................... 3 2.2 开发语言与开发环境 ................................................................................................... 3 3. 英语背单词软件总体设计与需求分析 .............................................................................. 5 3.1 Android四大组件简介 .................................................................................................. 5 3.2 Android 手机应用软件的UI设计 ............................................................................... 6 3.3 英语背单词软件需求分析与性能分析 ....................................................................... 7 3.4 英语背单词软件操作流程图与数据库设计 ............................................................... 8 3.4.1 英语背单词软件操作流程图 ................................................................................ 8 3.4.2 数据库的创建与设计 ............................................................................................ 8 4. 系统各个模块的具体实现 ................................................................................................ 14 4.1 启动模块的实现 ......................................................................................................... 14 4.2 用户信息模块的实现 ................................................................................................. 15 4.3 用户单词学习模块的实现 ......................................................................................... 17 4.4 用户单词复习模块的实现 ......................................................................................... 19 4.5 用户单词测试模块的实现 ......................................................................................... 20 4.6 生词本模块的实现 ..................................................................................................... 21 4.7 各界面之间切换的实现 ............................................................................................. 23 5. 客户端界面测试 ................................................................................................................ 24 5.1 系统测试的目标 ......................................................................................................... 24 5.2 测试流程 ..................................................................................................................... 24 5.3 测试用例与测试结果 ................................................................................................. 24 6. 总结 .................................................................................................................................... 25 6.1 本文工作总结 ............................................................................................................. 25 6.2 进一步工作的打算 ..................................................................................................... 25 参考文献 ................................................................................................................................. 26 致 谢 ..................................................................................................................................... 27 外文原文 ................................................................................................................................. 28 外文翻译 ................................................................................................................................. 44

1. 绪 论

1.1研究内容

本着对用户学习英语提供便利和有效记忆的目标，该英语背单词软件是基于Android手机平台，通过词库的解析与导入，开发出针对使用Android平台的手机英语背单词系统。用户使用此平台进行单词学习、单词背诵、单词测试、加入生词本等。相对于书本辞典操作来说，背单词可以更简便的直接的体现给用户，而且使用方便，操作简单。用户作为系统的服务群体，按照自己的需求选择词库进行单词学习等，按照自己的方式选择所需背记单词的数量。遇到有生僻的单词可以加入生词本方便以后的二次查找，节省时间，方便阅览。

本系统要求主要实现以下功能模块： ? 用户能够选择词库，导入词库； ? 用户能够进行单词的学习；

? 用户能够进行已学习过单词的复习，同时制定复习计划； ? 用户能够进行单词的测试； ? 提供单词的真人发音功能；

? 提供生词本功能，用户可以随时添加生词。

1.2研究意义

以前人们用最简单的辞典，在众多的资料中翻阅、查找，费时、费力，而且应用性非常差。设计这么一个背单词系统，使得用户可以便捷，快速的进行操作，同时也达到了稳定，准确的目的。基于Android的英语背单词程序的设计可以进一步扩大学习英语的途径，让广大公众能够随时随地方便且快捷地认识与记忆英语单词，以提高自身的英语水平。本软件提供从初次记忆单词到熟记单词的所有功能，帮助大家科学学习。当您初次使用本软件记忆单词后，系统会自动为您制定学习复习计划，帮助您科学快速地完成记忆单词的过程。软件提供测试功能，帮助您自我检测学习状态。更好地发挥了Android技术对移动互联网的现实性作用。

1.3研究现状和发展趋势

据市场研究公司IDC称，2013年上季度Android手机全球份额达75%。成为最大智能手机系统。今年第一季度，全球Android智能手机出货量上升至1.621亿台，高于去年同期的9030万台;市场份额为75%，高于去年同期的59.1%。其他操作系统的表现则要平稳很多。Android越来越引起人们的关注和追捧。移动通信和互联网成为当今世界发展最快、市场潜力最大、前景最诱人的两大业务，它们的增长速度都是任何预测家未曾预料到的，所以移动互联网可以预见将会创造经济神话。移动互联网的优势决定其用

1

户数量庞大，截至2012年9月底，全球移动互联网用户已达15亿。

Android是一种以Linux为基础的开放源码操作系统，采用Linux内核，主要使用于便携设备。开放手机联盟（OHA）成员可以任意使用和修改安卓的SDK软件包。系统的开源性使其具有良好的拓展性，一方面，为众多移动应用开发者提供了良好的系统性平台，有利于移动应用的集合；另一方面，终端厂商可以针对自身的特殊需要“定制化开发”。与此相比，尽管2010年2月，塞班基本完成开源工作，但由于代码臃肿，用户界面设计缺失，塞班的开源并无实际意义，错失发展良机。因此，基于Android的英语背单词程序开发，也是现代移动互联网时代下催生的人们生活中不可或缺的一个产物。

我们认为，安卓操作系统发展迅猛主要得益于免费、开源和良好产业运作策略，这三点为安卓在智能手机市场赢得更多的发展机遇。系统的免费让更多的厂商加入，推动了份额的上升；代码的开源让更多的开发者进入应用开发；应用的丰富吸引了更多用户选择，这也是谷歌值得众多厂商学习的地方。此外，谷歌通过OHA联合众多厂商进行系统研发，不断更新版本，将系统应用推广到更多的终端产品中，确保用户体验持续改善。

3G互联网时代下，移动应用越来越多，Android 4.2.2更新包于2013年2月11日发布，未来采用Android系统手机越来越多。不仅仅在于手机，在任何移动设备上，都可以采用Android开发移植到终端设备上，例如电视、冰箱、空调、洗衣机等。将这些设备计入互联网，我们可以通过手机实时知道各个设备的状态，也可以控制它们工作。总之，Android 将带给我们更加智能、便捷、现代的生活。从而，Android应用的开发，将会越来越庞大，需求将会越来越丰富。开发英语背单词手机软件和其他应用将会越来越普遍，Android将会越来越壮大。

2

2. 平台与开发工具

2.1 开发平台介绍

本设计采用windows 作为开发平台，由于windows系列操作系统做为市场份额最大的PC操作系统，无论是用户数还是基于windows平台应用数都是遥遥领先的。大多数开发者都会选择此平台作为开发平台，而且很多应用在windows 平台提供了的相应的开发工具，如Eclipse、QT等。虽然大多数用户很乐于将 Eclipse 当作 Java 集成开发环境（IDE）来使用，但是 Eclipse 的目标却不仅仅这样。Eclipse 这个开发工具还包括插件的开发环境（Plug-in Development Environment，PDE），而这个组件主要是针对希望扩展 Eclipse 的人来的，因为Eclipse允许他们构建出与 Eclipse 开发环境无缝集成的工具。因为 Eclipse 中的所有东西都是插件存在，对于 Eclipse 提供的插件，并且给用户提供一致及统一的集成开发环境来说，所有的软件开发人员都具有一样的发挥场所。

Eclipse 是一个开放源代码的、基于 Java 的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括 Java 开发工具（Java Development Kit，JDK）。 虽然大多数用户很乐于将 Eclipse 当作 Java 集成开发环境（IDE）来使用，但 Eclipse 的目标却不仅限于此。Eclipse 还包括插件开发环境（Plug-in Development Environment，PDE），这个组件主要针对希望扩展 Eclipse 的软件开发人员，因为它允许他们构建与 Eclipse 环境无缝集成的工具。由于 Eclipse 中的每样东西都是插件，对于给 Eclipse 提供插件，以及给用户提供一致和统一的集成开发环境而言，所有工具开发人员都具有同等的发挥场所。本毕设安装的是Android 开发插件。

2.2 开发语言与开发环境

Android的上层应用程序是用Java语言开发，同时还需要基于Dalvik虚拟机，所以，Google公司推荐使用主流的Java继承开发环境Eclipse。只有Eclipse还不够，因为是使用Java语言进行开发，还应该有由SUN公司提供的Java SDK(其中包括JRE：Java Runtime Environment)。此外，Android的应用程序开发和Java开发有较大区别的，所以还需要有Google提供的Android SDK。同时，还需要在Eclipse安装ADT，为Android开发提供开发工具的升级或者变更，是Eclipse下开发工具的升级下载的工具。eclipse装有android开发插件，从而运行Android 模拟器 ，模拟Android智能手机。

简言之，需要以下软件，才能搭建Android开发环境，从而进行Android应用程序的开发。运行开发环境如表2-1所示：

3

操作系统 名称 表2-1 运行开发环境 版本 语种 简体中文 默认 默认 默认 Window 7旗舰版 开发工具 安卓开发工具 Sp 1 3.6 17 1.6以上 Eclipse ADT 基于平台 Android 4

3. 英语背单词软件总体设计与需求分析

3.1 Android四大组件简介 1) Activity

Activity是Android应用程序和用户进行交互的窗口，它是Android系统构造中最基本的一种，Activity要为各界面的状态进行保持，它做许多的持久化事情，良好的管理生命周期和一些要跳转的逻辑。一个Activity一般展现一个用户界面。比如，一个Activity可以为一个用户展示选择的菜单列表或者展示出一些图片和图片的标题。对于一个消息服务应用程序，它可能包括一个显示联系人列表的界面,一个编写信息的界面，和其它的一些查看信息及修改应用程序的设置而用到的Activity。虽然这些Activity共同工作，一起构成了一个应用完整的程序，但是每个Activity都是相对独立的。

2) Service

Service在后台，为Activity服务，封装好一些完整的功能逻辑，并接受上面的指令，然后完成相关的事务处理，使用中要定义好接受的Intent提供同步及异步的接口。Service虽然没有用户的界面，但是Service会在后台一直运行。比如，Service可能会在用户处理其它事务时，同时播放音乐，或者把网络上的数据获取下来，或者进行一些运算，然后把计算的结构提供给Activity，让它展示给用户。使用中，Service都要继承类Serivce。和Activity等其它组件一样，Service运行在应用程序的主线程中。因此Service不能让其它组件或者用户界面阻塞，这个通常就要为这些Service类增加线程执行耗时的任务。

3) Broadcast Receiver

Broadcast Receiver是Android提供的第三方应用数据的访问方案，它可以派生出Content Provider这个类，然后对外提供数据，它可以像数据库一样进行选择排序，它屏蔽内部的细节，并对外提供了一个统一接口模型，这很好的简化上层应用，它对数据整合提供了更方便的方式。Broadcase Receiver并不执行任何的任务，它仅是接受并响应广播的通知的一类组件。而大部分的广播的通知是由系统产生，比如改变时区时，电池电量低时，用户选择一幅图片或用户换了语言首时。对于应用程序，也同样可以良好的发送广播通知，比如通知其他的应用程序某些数据已经下载到设备上来并且可以使用。

4) Content Provider

接受一种或多种的Intent作为触发事件，对于接受到的相关消息，进行一些简单处理，转换成Notification，这统一了Android系统的事件广播模型。对于应用程序可以通过ContentProvider来访问其它的应用程序中的一些私有的数据，这即是Android系统中提供的一种标准的共享数据的机制。对于共享的数据可存储在系统的文件中、SQLite

5

中或者其它的媒体中。ContentProvider实现类扩展自ContentProvider这个类，并通过实现此类的一组标准接口，使其它的应用程序能存取它控制的一些数据。但是应用程序并不是直接调用ContentProvider中的一些方法，而是间接的，通过类ContentResolver来实现。ContentResolver这个类能够与任何的一个ContentProvider进行通信，它能与ContentProvider良好的合作管理进程间通信。

3.2 Android 手机应用软件的UI设计

由于Android系统是一款手机操作系统，所以基于此系统的应用开发也是基于手机屏幕大小的。手机屏幕大小不一，但要求软件能够适应不同大小的手机屏幕，也就是界面能够自动适应，而且屏幕能够翻转（基于重力感应使屏幕画面自动水平和垂直切换）。Android 界面由两大基本组件组成：即容器和控件。一个窗口由一个基本的容器组成， 容器中可以放容器或者控件，每一个容器或者控件都有大小、长宽等属性。

在一个Android 应用中，一个Activity（Activity是Android中最常用也是最基本的组件）通常就是一个单独的屏幕，每一个Activity都被实现为一个独立的类，并且继承Activity这个子类。Activity提供了与用户交互的可视化界面。创建一个Activity一般继承Activity父类。覆盖Activity的onCreate()方法，在该方法中调用setOnContextView（）方法来展示要显示的视图。

整个Android 项目划分不同文件在不同文件夹中,android使用xml文件作为系统的布局文件，android 资源文件和 文件夹如图3-1所示：

图3-1 Android项目文件结构

6

要想控制手机界面的显示方式，则必须使用布局这一概念。布局就像容器，里面可以装下很多控件。布局里面还可以套用其他的布局。这样就可以实现界面的多样化以及设计的灵活性。

(1) LinearLayout（线性）布局： 线性版面配置，在这个标签中，所有元件都是按由上到下的排队排成的。包括垂直线性布局和水平线性布局。

(2) RelativeLayout（相对布局）就是以相对的方式定位布局，允许子元素指定他们相对于其它元素或父元素的位置（通过ID指定）。相对布局示例如图3-2所示：

图3-2 Android相对布局

(3) FrameLayout（帧布局）是最简单的一个布局对象。是一个框架布局样式，可以用include标签载入定义的另一个layout文件，所有的子元素将会固定在屏幕的左上角；你不能为FrameLayout中的一个子元素指定一个位置。后一个子元素将会直接在前 一个子元素之上进行覆盖填充，把它们部份或全部挡住（除非后一个子元素是透明的）。 (4) TableLayout（表格布局） 是一种类似表格的布局，这种布局会把包含的元素以行和列进行排列。表格的列数为所有行中的最大列数；每一行可以是一个Table Row布局对象，也可以是普通的View（视图）对象，TableRow里面每一个元素占一列TableLayout总列数由列数最多的那一行决定。

因此，要想实现各种显示效果，可根据不同的界面需求，选用不同的布局方法。 3.3 英语背单词软件需求分析与性能分析

技术可行性上，Android是一个成熟强大的移动操作系统，而且是一个开源的系统，市场占有率很高。Android应用是用java语言，虽然版本有好多，但一般会向下兼容，用Eclipse + ADT来创建应用程序，Android提供开发的足够的接口API让开发者开发功能强大的应用程序。

7

经济可行性上，该应用程序不需要服务器端，不需要与别的应用进行交互，只需要本地Android智能机设置好，用户学习内容自动保存，而且复习计划可自行设置提醒。占用内存小，用户电池消耗小。所以该方案是可行的。

操作可行性上，利用现有的windows系统进行开发。使用Eclipse作为开发工具以及使用Sqlite作为数据库，通过模拟器进行程序调试，然后通过android智能机进行功能测试。整个过程平台广泛，皆可实现。

系统性能分析方面要求程序响应速度快、安全性高、信息处理速度快。 3.4 英语背单词软件操作流程图与数据库设计 3.4.1 英语背单词软件操作流程图

本英语背单词软件的操作流程图如图3-3所示：

启动 选择词库 学习习

复 习 测 试 生词本 发音加入生词本发音加入生词本测试结果加入生词本删除编辑单词3.4.2 数据库的创建与设计

当前android平台采用的是sqlite数据库。SQLite数据库功能强大，使用方便。 本系统使用了SQLite数据库来保存英文单词信息。在Android中创建和打开一个数据库都可以使用openOrCreateDatabase方法来实现，本系统创建了名为“wordroi d.db”的数据库，并返回一个SQLiteDatabase对象db如下：

SQLiteDatabase db=SQLiteDatabase.openOrCreateDatabase( DB_NAME, null); DB_NAME为数据库的储存地址：\data/data/wordroid.model/databases/wordroid.db\ 创建表通过execSQL方法来执行一条SQL语句。本系统创建了一个名为sql的表。具体代码如下：

图3-3 操作流程图

8

String sql=\CREATE TABLE \+ table + \( ID text not null, SPELLING text not null , MEANNING text not null, PHONETIC_ALPHABET text, LIST text not null\db.execSQL(sql);

向表中添加一条数据使用insert方法来添加数据即单词。具体实现如下：

db.insert(table, null, values);

通过使用update方法来修改表中数据，具体实现如下： db.update(table, values, whereClause, whereArgs);

通过使用delete方法从表中删除数据。关闭数据库很重要，经常容易忘记。直接使用SQLiteDatabase的close方法。

在Android中查询数据是通过Cursor类实现的，使用SQLiteDatabase.query()方法时，会得到一个Cursor对象，Cursor指向的就是每一条数据。注意Android使用Cursor类返回一个需要的值，Cursor作为一个指针从数据库查询返回结果，使用Cursor允许Android更有效地管理它们需要的行和列，运用cursor.moveToFirst()是对Cursor指向的位置进行操作:移到第一行。

wordroid.db文件放在Eclipse Android工程中的res文件夹下的raw目录中，通过使用getResources().openRawResource方法获得raw目录中资源的InputStre am对象，然后将该InputStream对象中的数据写入手机内存或SD卡的目录中相应文件中。如图3-4所示:

图3-4 数据库文件

9

在wordroid数据库中主要包含以下几个表格： ? 表BOOKS

该表记录了词库的基本信息，包括词库的ID，词库的名称，加入时间，list数量，单词数量。如下表3-1所示：

表3-1 BOOKS表 字段 类型 非空 默认值 主键 描述 √ √ ID text 编号 √ NAME text 名称 √ GENERATE_TIME text 加入时间 √ NUMOFLIST text List数量 √ NUMOFWORD text 单词数量

BOOKS表具体内容如图3-5所示：

图3-5 表BOOKS

? 表book1

该表记录了单词的基本信息，包括单词的编号，单词的拼写，单词的意思，单词音标，所属list. 如下表3-2所示：

表3-2 book1表 字段 类型 非空 默认值 主键 描述 √ √ ID text 编号 √ SPELLING text 拼写 √ MEANNING text 意思 PHONETIC_ALPHABET text 音标 √ LIST text 所属list 10

表book1具体内容如图3-6所示：

图3-6表book1

? 表book2

该表记录了单词的基本信息，包括单词的编号，单词的拼写，单词的意思，单词音标，所属list。见表3-2。

表book2具体内容如图3-7所示：

图3-7表book2

? 表book3

该表记录了单词的基本信息，包括单词的编号，单词的拼写，单词的意思，单词音标，所属list。 见表3-2。

表book3具体内容如图3-8所示：

11

图3-8表book3

? 表PLAN

该表记录了复习计划的基本信息，包括词库的编号，所在list，已学习list，学习时间，复习次数，复试时间，最佳得分，是否复习。 如下表3-3所示。

表3-3 PLAN表 字段 类型 非空 默认值 主键 描述 √ BOOKID text 词库的编号 √ LIST text 所在list √ LEARNED text 已学习list text LEARN_TIME 学习时间 REVIEW_TIMES text 复习次数 REVIEWTIME text 复试时间 BESTSCORE text 最佳得分 SHOULDREVIEW text 是否复习

12

表PLAN具体内容如图3-9所示：

图3-9表PLAN

13

4. 系统各个模块的具体实现

4.1 启动模块的实现

启动界面是系统的第一个界面，目的是给用户一种直观的感受，给用户一种良好的感觉。启动界面的布局文件为layout文件夹里的login.xml，由一个Linearlayout（线性布局） 构成，里面包含一个ImageView （图片控件）并填充整个手机界面，考虑到横竖屏切换和屏幕大小，在res的drawable-hdpi、drawable-ldpi和drawa ble-mdpi三个文件夹分别放三种尺寸图片，分辨路为480x800、800x480、320x460并且启动画面要覆盖整个手机屏幕，启动界面如图4-1所示：

图4-1 启动界面

启动界面最主要的工作时设置画面延时，并且能够在画面显示的3秒内对HOME键、返回键，做出相应，并且可以支持横竖屏切换。实现延时效果主要使用线程来实现。当android程序启动时，首先由AndroidMainfest.xml系统主配置文件来查找第一个要显示界面（第一个要显示的Activity必须要包含在与之间）

代码如下：

protected void onCreate(Bundle savedInstanceState) { // TODO Auto-generated method stub this.setTitle(\安卓背单词--Wordroid\); super.onCreate(savedInstanceState); this.setContentView(R.layout.login); LayoutInflater mInflater = LayoutInflater.from(this); myView = mInflater.inflate(R.layout.main, null); Thread thread = new Thread(){ public void run(){ try {Thread.sleep(2000); Message m = new Message(); m.what=1;

14

Main.this.mHandler.sendMessage(m); } catch (InterruptedException e1) { // TODO Auto-generated catch block e1.printStackTrace();}}};thread.start(); OperationOfBooks OOB = new OperationOfBooks(); SharedPreferences setting = getSharedPreferences(\, MODE_PRIVATE); OOB.setNotify(setting.getString(\, \下午\),Main.this); File dir = new File(\); if (!dir.exists()) dir.mkdir(); if (!(new File(SqlHelper.DB_NAME)).exists()) { FileOutputStream fos; try {fos = new FileOutputStream(SqlHelper.DB_NAME); byte[] buffer = new byte[8192]; int count = 0;

InputStream is = getResources().openRawResource( R.raw.wordorid);

while ((count = is.read(buffer)) > 0) { fos.write(buffer, 0, count); } fos.close(); is.close(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace();} }

SharedPreferences settings=getSharedPreferences(SETTING_BOOKID, 0); DataAccess.bookID=settings.getString(BOOKNAME, \); OOB.UpdateListInfo(Main.this); initWidgets();}

登录界面由SplashActivity.java类负责显示。然后根据当前类要显示布局文件文件来绘制整个界面。随之，启动延时线程，采用循环，循环一次线程休眠100ms（防止系统卡顿）。按下HOME键则返回手机主界面，延时暂停，再点击启动程序时延时线程继续运行，直到3s后，跳到下一个界面。当按下返回键时，程序将关闭。 4.2 用户信息模块的实现

该界面的布局文件为main.xml,整个界面直观明了的展示了该系统的主要功能以及用户学习进度。界面用一张图片作为背景，在界面左上角显示两个图片按钮(ImageButton):删除按钮与重置按钮，组成一个线性布局。在界面中间上方处显示下拉列表组件（Spinner）,给用户提供词库的选择：GRE红宝书（上），GRE红宝书（中），GRE红宝书（下）以及导入新词库。在界面中间布局了三个文本框（Textview）和两个使用进度条（ProgressBar），组成一个线性布局。一个文本框用来显示用户学习信息：词库名称，总词汇量与创建时间；两个使用进度条分别显示已学习list的数量与已复习list的数量。在界面的的底部布局了四个按钮（Button）：学习，复习，测试，生词本。组成了一个线性布局。这些控件在一起采用相对布局，可以使这些控件的位置相对摆放，靠在父容器下方，不至于零散。用户信息主界面如图4-2所示：

15

图4-2 用户信息主界面

上文提到了该界面给用户提供词库选择的下拉列表组件（Spinner）,词库选择则要为下拉列表定义一个适配器，这里就用到前面定义的books；同时为适配器设置下拉列表下拉时的菜单样式；最后将适配器(adapter)添加到下拉列表上(pickBook)。代码如下： ArrayAdapter< CharSequence > adapter = new ArrayAdapter< CharSequence >(this, android.R.layout.simple_spinner_item, books);

adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

pickBook.setAdapter(adapter);

事件pickBook.setOnItemSelectedListener(new OnItemSelectedListener()为下拉列表设置各种事件的响应，这个事响应菜单被选中。

同时该界面initWidgets() 实现了桌面小插件的设置，把用户生词本的内容直接呈现，方便用户的浏览。对于界面左上角的两个删除与重置按钮，通过 onClick (View v)事件，页面上显示一个（对话框）dialog，dialog的样式设置由res，文件夹下的values文件夹dialogStyle.xml负责，界面显示时，先生成一个dialog对象，然后显示这个dialog。

词库由wordroid.db数据库里的表Book1, Book2, Book3组成，通过this.set ListAdapter(new ArrayAdapter(this, R.layout.file_row, fileNames));实现词库的导入操作。相关代码如下：

super.onCreate(savedInstanceState); this.setTitle(\导入新词库\

16

this.setContentView(R.layout.import_book);

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);

File f = new File(\File[] files=f.listFiles();

fileNames = new String[files.length]; for (int i=0;i

fileNames[i]=files[i].getName();}

this.setListAdapter(new ArrayAdapter(this, R.layout.file_row, fileNames));

4.3 用户单词学习模块的实现

该界面的布局文件为studyword_main.xml和studyword.xml。studyword_main. xml文件里显示两个文本框，构成一个框架布局FrameLayout。分别为未学习过的LIST和所有的LIST；同时显示各项LIST列表。用户单词学习列表界面如图4-3所示：

图4-3 用户单词学习列表界面

Studyword.xml布局文件界面上方布局了一个文本框：单词记忆。界面中间显示一个图片按钮和两个文本框，构成一个线性布局。图片按钮为发音标示，按钮的属性设置为@android:drawable/btn_default，文本框分别为拼写（spelling）与单词解释（info）。界面底部显示三个按钮，构成一个线性布局。按钮分别为：上一个，加入生词本，下一个。用户单词学习记忆界面如图4-4所示：

17

图4-4 用户单词学习记忆界面

重复加入生词本以后会提示：生词本中已包含这个单词；强制退出时会提示学习未完成，进行选择。

该学习模块的机器发音功能通过TTS引擎实现，TTS即TextToSpeech,将所指定的文本转成不同语言音频输出。如果用户手机支持TTS发音功能，首先设置发音语言tts.setLanguage(loc)，判断语言可用后，使用Speak()方法可以直接在应用程序中实现语音功能tts.speak(list.get(currentnum).getSpelling(),TextToSpeech.

QUEUE_ADD,null)。发音完成后，回收TTS即可，当确定应用程序不再需要TTS的相关功能后，可以在Activity的OnDestroy()方法中调用super.onDestroy()释放当前TTS实体所占用的资源。相关代码如下：

public class TTS { ...........

private TextToSpeech.OnInitListener ttsInitListener = new TextToSpeech.OnInitListener() {

@Override

public void onInit(int status){

Locale loc = new Locale(%us\

if (tts.isLanguageAvailable(loc) == TextToSpeech.LANG_AVAILABLE){ tts.setLanguage(loc);

} tts.setOnUtteranceCompletedListener(ttsUtteranceCompletedListener);}

18

4.4 用户单词复习模块的实现

该界面的布局文件为reviewlayout.xml。界面的上方布局了一个文本框：单词复习。界面中间显示一个图片按钮和两个文本框，构成线性布局嵌套。图片按钮为发音标示，按钮的属性设置为@android:drawable/btn_default，文本框分别为拼写（spelling）与单词解释（info）。界面底部显示三个按钮，另有两个隐藏按钮，构成一个线性布局。按钮分别为：加入生词本，我记得，不记得了，记对了，记错了。 用户单词复习界面如图4-5所示：

图4-5 用户单词复习界面

按下我记得按钮文本框显示单词的解释，界面下方显示“记对了”“记错了”两个按钮，按下记对了进入下一个单词的复习。强制退出时会提示复习未完成，进行选择。

该单词复习模块首先需要对已学习过的list进行数据存储，这里使用Activity类的getSharedPreferences方法获得SharedPreferences对象，其中存储key-value的文件的名称由getSharedPreferences方法的第一个参数指定；使用该接口的edit获得

SharedPreferences.Editor对象，再通过SharedPreferences.Editor接口的putString方法保存数据。进入复习界面后，则通过getString读取保存的list。用户在复习选择时通过setVisibility()实现各个按钮控件的可见与否。复习完成时生成一个dialog对象，然后显示这个dialog。相关核心代码如下：

private void UpdateView() {

if (currentnum

SharedPreferences setting =

getSharedPreferences(\wordroid.model_preferences\MODE_PRIVATE);

if(setting.getBoolean(\iftts\false)){

Thread thread =new Thread(new Runnable(){ public void run(){

try {

19

Thread.sleep(500);

tts.speak(list.get(currentnum).getSpelling(),TextToSpeech.QUEUE_FLUSH, ...........

null);}

public void onClick(DialogInterface dialog, int whichButton) { tts.shutdown();

4.5 用户单词测试模块的实现

用户单词测试界面的布局文件为test_list_item.xml，test_list.xml和test.xml。test_list.xml布局文件界面显示了一个文本框和一个使用列表（ListView）,文本框为选择测试单元，使用列表控件包含所选词库所有的list并显示最高正确率。点击某个list后进入test.xml布局文件界面，该界面的上方布局了一个文本框：单词测试。界面中间显示一个文本框和一个单选钮组（RadioGroup），构成线性布局。文本框的属性设置为android:attr/textAppearanceSmall，内容为单词与单词的拼写；单选钮组包含四个单选框（RadioButton），分别为单词的可选解释。界面底部显示三个按钮，构成一个线性布局。按钮分别为：下一个，结束，加入生词本。用户单词测试界面如图4-6所示：

finish();

Intent intent = new Intent();

intent.setClass(Review.this, ReviewMain.class); startActivity(intent);}}).create();

图4-6 用户单词测试界面

用户选择单选框后系统进行判断，错误给出正确解释，正确进入下一个。 该单词测试模块通过单选钮监听事件setOnCheckedChangeListener（）判断组件是

20

否被选中，给RadioGroup设置事件监听，然后用switch函数对用户所选单选项判断，最后通过DisplayToast事件进行正确与否的显示。相关核心代码如下：

RadioGroup.OnCheckedChangeListener() {

public void onCheckedChanged(RadioGroup group, int checkedId) {

if (isCheck) {

isCheck = false;

switch (rightAns) { case 0:

if ( checkedId == meaning0.getId() ) {

score++;

DisplayToast (\正确\} else {

DisplayToast(\错误,正确答案是 \allList.get(opt[0]).getMeanning());}

break;

case 1:

if ( checkedId == meaning1.getId() ) {

score++;

DisplayToast(\正确\

} else {

DisplayToast(\错误,正确答案是 \allList.get(opt[1]).getMeanning() );}break; } 4.6 生词本模块的实现

生词本界面的布局文件为attention.xml。attention.xml布局文件界面显示了一个文本框和一个使用列表（ListView）,文本框为生词本，使用列表控件包含用户所加入生词本中的生词，显示单词与单词解释。当选择某生词，显示编辑该单词与从生词本中删除选项。按下编辑该单词时，进入编辑生词本界面，该界面布局文件为editword.xml。界面上方显示了两个文本框和两个输入文本组件（EditText），一个文本框：单词与一个输入文本组件（单词拼写）构成线性布局，另一个文本框：中文与一个输入文本组件（中文解释）构成线性布局；界面中间布局了两个按钮：确定和取消。生词本界面与编辑生词本界面分别如图4-7，图4-8所示：

21

图4-7 生词本界面 图4-8 编辑生词本界面

该生词本模块通过onCreateOptionsMenu(Menu menu)实现按下menu键后进行添加新单词，onOptionsItemSelected(MenuItem item)为单词添加操作，相关代码如下：

public boolean onCreateOptionsMenu(Menu menu) {

public boolean onOptionsItemSelected(MenuItem item) { switch(item.getItemId()){

case MENU_ADD:{

Intent intent = new Intent();

Bundle bundle = new Bundle(); bundle.putString(\action\add\

intent.putExtras(bundle);

intent.setClass(Attention.this, EditWord.class); startActivity(intent);

........... }

点击某个生词后，生成一个dialog对象，然后显示这个dialog。进行操作：编辑该单词和从生词本中删除。编辑单词中，要运用meanning.getText().toString().

equals(\）和spelling.getText().toString().equals(\进行单词的匹配：非空判断与单词存在判断,即

this.spelling.getText().toString().equals(words.get(i).getSpelling())。

22

4.7 各界面之间切换的实现

界面切换是系统界面设计的核心部分，实现两个界面之间的切换是android界面设计的基本内容，本系统主要使用Intent（意图）实现界面切换。Intent可用于从一个Activity转到另一个Activity，还可以启动服务（在此不作介绍）。

最常见的一种需要将数据传到另一个Activity中 示例如下： Intent intent = new Intent(HomeActivity.this,ViewActivity.class);

Bundle b=new Bundle();//用于界面切换存放传递的数据

b.putString(\key\id);//以键值对的形式 intent.putExtras(b);//intent对象保存该数据 startActivity(intent);

第一个Activity获取第一个Activity的数据代码如下：

Intent intent = this.getIntent(); //根据当前Activity获取intent对象 Bundle b = intent.getExtras(); //获取intent中的Bundle对象 key = b.getString(\key\ //根据键值获得具体数据

如果第二界面要想返回结果到第一个界面，则在改写OnActivityResult方法， 启动第二个Activity则要使用StartActivityForResult方法。

最后还要说一点的是，android中每一个Activity（显示界面类）必须在

AndroidManifest.xml 系统最主要的配置文件中进行注册，才可以显示该界面，否则系统将报异常。

23

5. 客户端界面测试

5.1 系统测试的目标

系统测试是利用一定的测试工具然后按照计划好的测试方案、流程等对产品分别进行功能、性能等的测试，甚至可以根据需要去编写不同功能的测试工具，最后去设计和维护整个测试系统，对测试的方案也可能出现的问题进行分析和评估。在执行测试的用例之后，根据需要跟踪检测到的故障，以保证开发的产品适合需求。系统测试是整个软件最后必须要经历的步骤，系统测试主要测试系统的稳定性、健壮性等。本毕业设计主要测试各个界面切换是否正常、界面内控件是否在操作之后做出相应的反应。 5.2 测试流程

测试流程为：第一次打开程序，看经过3s后是否进入用户信息主界面、在主界面点击各个按钮界面的信息是否发生变化、点击导入词库是否进入SD卡文件浏览界面、在单词学习界面点击某个list是否进入该list的记忆界面、点击发音按钮是否机器发音、点击加入生词本按钮是否进入生词本界面、在单词复习界面点击需要复习的list是否进入该list的复习界面、点击我记得界面是否变化、点击我的复习计划是否进入复习计划界面、在单词测试界面点击某个list是否进入该list的测试界面、选中一个单词解释后是否显示正确判断、在生词本界面点击一个单词是否弹出操作选项、点击编辑该单词是否进入编辑生词本界面、点击设置按钮是否进入设置界面、点击说明按钮是否进入帮助界面。

通过把软件运行在模拟器，然后进行一下以上流程模拟的操作，再拿真机进行一定的测试，包含以上流程的处理操作。 5.3 测试用例与测试结果

测试用例1：显示对话框。在用户主界面点击词库选择栏是否弹出用户选择对话框，点击某一词库该界面的内容显示栏等是否发生变化。

测试结果：点击下拉按钮出现了用户信息对话框，点击GRE红宝书（中）后，用户主界面的内容显示栏发生变化，词库名称变为GRE红宝书（中），总词汇量变为1954，创建时间变为当前时间等。

测试用例2：界面切换。点击学习按钮后是否进入用户单词学习界面。

测试结果：点击学习按钮后进入了用户单词学习界面，该界面上方显示未学习的list和所有的list，中间显示未学习的list列表。

测试用例3：Widget控件。在模拟器主界面点击menu后，再点击add，进入widget选择对话框选择该程序图标是否在主界面显示。

测试结果：点击menu后，再点击add，进入widget选择对话框选择该程序图标在主界面显示。测试结果基本符合预期。

24

6. 总结

6.1 本文工作总结

2014年3月底，我开始了我的毕业论文工作，时至今日，论文基本完成。从最初的茫然，到慢慢的进入状态，再到对思路逐渐的清晰，整个写作过程难以用语言来表达。历经了几个月的奋战，紧张而又充实的毕业设计终于落下了帷幕。回想这段日子的经历和感受，我感慨万千，在这次毕业设计的过程中，我拥有了无数难忘的回忆和收获。由于自身一些事情，4月初才开始着手资料的收集工作中，在搜集资料的过程中，主要在网上查找各类相关资料，将这些宝贵的资料全部保存在电脑上，尽量使我的资料完整、精确、数量多，这有利于论文的撰写。在论文中我充分地运用了大学期间所学到的知识和最新用到的知识。毕业论文的制作给了我难忘的回忆。在我徜徉书海查找资料的日子里，面对许多书本的罗列，最难忘的是每次找到资料时的激动和兴奋；亲手每一个界面的时间里，记忆最深的是每一步小小思路实现时那幸福的心情。在这个过程中，我遇到过困难，遇到过挫折，每一步对于我来说，都是新的尝试和挑战。Android开发的知识面广而精，使我在整个毕业设计过程中，受益匪浅。

通过这次学习和实践，我已经逐步掌握了android开发的基本方法。脚踏实地，认真严谨，实事求是的学习态度，不怕困难、坚持不懈、吃苦耐劳的精神是我在这次设计中最大的收益。唯有双倍的努力，十倍的耐性，百倍的豪情和千倍的执着来完成我们的使命。

6.2 进一步工作的打算 存在的问题：

1.界面可以做的更好看一些。

2.对不同屏幕的支持不够好，比如在小屏幕可以，到大屏幕就不能全屏了。 4.在一些界面的按钮没做效果处理，当点击时可以切换到另一种效果。 5.还有一些系统优化没有做，比如加载时，使用线程等。

6.目前Android系统逐步过渡到4.0系统，可以考虑使用4.0开发包以便进一步跟上时代的需求。

25

参考文献

[1] 杨丰盛. ANDROID应用开发揭秘[M]. 北京：机械工业出版社，2010.1 [2] 李刚. 疯狂Android讲义(第二版) . 电子工业出版社，2013.3

[3] Ethan Cerami and O’Reilly.《JAVA APPLICATION》.电子工业出版社, 2003.5 [4] 余志龙.Google.Android.SDK开发范例大全[M].人民邮电出版社，2009,7. [5] 靳岩,姚尚朗. Google Android开发入门与实战[M].人民邮电出版社，2009.7 [6] 景保玉.2010中国移动应用开发现状与趋势大调查，2011年01月12日 [7] Michael J.Young. 轻松搞定XML 林嘉胜译，2001年01月08日 [8]（英）Herbert Schildt Java参考大全（J2SE 5 Edition），清华大学出版社 [9] 王向辉，张国印，沈洁.Android应用程序开发.清华大学出版社，2010年3月 [10] Roger S. Pressman,《Software Engineering Fifth Edition》,清华大学出版 社,2002.5.

[11] Gasoline. 深入浅出Android–Google手持设备应用程序设计，2007.12

[12] Sayed Hashimi, Satya Komatineni, Dave MacLean. Pro Android 2[M]. New

York:Springer-Verlag New York Inc，2010.3

26

致 谢

本课题的设计和论文撰写过程中，我的指导老师给于了极大的帮助，为我提供了大量的相关资料。在项目初期对我们的帮助和指导，使我们迅速确定了方向并明确了分工，以及在写论文的过程中给的宝贵的意见。在此，我对老师的指导表示衷心的感谢。在毕业设计期间，同学的帮助更是我能完成的重要因素，要对我亲爱的同学，说声谢谢，并希望他们能在未来的道路上，越走越好。

这次论文的写作过程，让我收获了很多，即为在大学四年的学习生涯上划上了一个完美的句号，为将来的人生之路做好了一个非常好的铺垫。同时，我也衷心的感谢太原理工大学软件学院四年来对我的精心栽培，为我进入社会提供了莫大的帮助。

27

外文原文

Beginning Android Mark L. Murphy write Using XML-Based Layouts While it is technically possible to create and attach widgets to our activity purely through Java code, the way we did in Chapter 4, the more common approach is to use an XML-based layout file. Dynamic instantiation of widgets is reserved for more complicated scenarios, where the widgets are not known at compile-time (e g., populating a column of radio buttons based on data retrieved off the Internet). With that in mind, it’s time to break out the XML and learn how to lay out Android activities that way. What Is an XML-Based Layout? As the name suggests, an XML-based layout is a specification of widgets’ relationships to each other—and to their containers (more on this in Chapter 7)—encoded in XML format. Specifically, Android considers XML-based layouts to be resources, and as such layout files are stored in the res/layout directory inside your Android project. Each XML file contains a tree of elements specifying a layout of widgets and their containers that make up one view hierarchy. The attributes of the XML elements are properties, describing how a widget should look or how a container should behave. For example, if a Button element has an attribute value of android:textStyle = \that means that the text appearing on the face of the button should be rendered in a boldface font style. Android’s SDK ships with a tool (aapt) which uses the layouts. This tool should be automatically invoked by your Android tool chain (e.g., Eclipse, Ant’s build.xml). Of particular importance to you as a developer is that aapt generates the R.java source file within your project, allowing you to access layouts and widgets within those layouts directly from your Java code. 28

Why Use XML-Based Layouts? Most everything you do using XML layout files can be achieved through Java code. For example, you could use setTypeface() to have a button render its text in bold, instead of using a property in an XML layout. Since XML layouts are yet another file for you to keep track of, we need good reasons for using such files. Perhaps the biggest reason is to assist in the creation of tools for view definition, such as a GUI builder in an IDE like Eclipse or a dedicated Android GUI designer like DroidDraw1. Such GUI builders could, in principle, generate Java code instead of XML. The challenge is re-reading the UI definition to support edits—that is far simpler if the data is in a structured format like XML than in a programming language. Moreover, keeping generated XML definitions separated from hand-written Java code makes it less likely that somebody’s custom-crafted source will get clobbered by accident when the generated bits get re-generated. XML forms a nice middle ground between something that is easy for tool-writers to use and easy for programmers to work with by hand as needed. Also, XML as a GUI definition format is becoming more commonplace. Microsoft’s XAML2, Adobe’s Flex3, and Mozilla’s XUL4 all take a similar approach to that of Android: put layout details in an XML file and put programming smarts in source files (e.g., JavaScript for XUL). Many less-well-known GUI frameworks, such as ZK5, also use XML for view definition. While ―following the herd‖ is not necessarily the best policy, it does have the advantage of helping to ease the transition into Android from any other XML-centered view description language. OK, So What Does It Look Like? Here is the Button from the previous chapter’s sample application, converted into an XML layout file, found in the Layouts/NowRedux sample project. This code sample along with all others in this chapter can be found in the Source Code area of http://apress.com.

android:layout_width=\ android:layout_height=\ The class name of the widget—Button—forms the name of the XML element. Since Button is an Android-supplied widget, we can just use the bare class name. If you create your own widgets as subclasses of android.view.View, you would need to provide a full package declaration as well. The root element needs to declare the Android XML namespace: xmlns:android=\

All other elements will be children of the root and will inherit that namespace declaration. Because we want to reference this button from our Java code, we need to give it an identifier via the android:id attribute. We will cover this concept in greater detail later in this chapter. The remaining attributes are properties of this Button instance: ? android:text indicates the initial text to be displayed on the button face (in this case, an empty string) ? android:layout_width and android:layout_height tell Android to have the button’s width and height fill the ―parent‖, in this case the entire screen—these attributes will be covered in greater detail in Chapter 7. Since this single widget is the only content in our activity, we only need this single element. Complex UIs will require a whole tree of elements, representing the widgets and containers that control their positioning. All the remaining chapters of this book will use the XML layout form whenever practical, so there are dozens of other examples of more complex layouts for you to peruse from Chapter 7 onward. What’s with the @ Signs? Many widgets and containers only need to appear in the XML layout file and do not need to be referenced in your Java code. For example, a static label (TextView) frequently only needs to be in the layout file to indicate where it should appear. These sorts of elements in the XML file do not need to have the android:id attribute to give them a name. 30

Anything you do want to use in your Java source, though, needs an android:id. The convention is to use @+id/... as the id value, where the ... represents your locallyunique name for the widget in question. In the XML layout example in the preceding section, @+id/button is the identifier for the Button widget. Android provides a few special android:id values, of the form @android:id/.... We will see some of these in various chapters of this book, such as Chapters 8 and 10. We Attach These to the Java How? Given that you have painstakingly set up the widgets and containers in an XML layout file named main.xml stored in res/layout, all you need is one statement in your activity’s onCreate() callback to use that layout: setContentView(R.layout.main);

This is the same setContentView() we used earlier, passing it an instance of a View subclass (in that case, a Button). The Android-built view, constructed from our layout, is accessed from that code-generated R class. All of the layouts are accessible under R.layout, keyed by the base name of the layout file—main.xml results in R.layout.main. To access our identified widgets, use findViewById(), passing in the numeric identifier of the widget in question. That numeric identifier was generated by Android in the R class as R.id.something (where something is the specific widget you are seeking). Those widgets are simply subclasses of View, just like the Button instance we created in Chapter 4. The Rest of the Story In the original Now demo, the button’s face would show the current time, which would reflect when the button was last pushed (or when the activity was first shown, if the button had not yet been pushed). Most of that logic still works, even in this revised demo (NowRedux). However, rather than instantiating the Button in our activity’s onCreate() callback, we can reference the one from the XML layout:

package com.commonsware.android.layouts; import android.app.Activity; 31

import android.os.Bundle; import android.view.View; import android.widget.Button; import java.util.Date; public class NowRedux extends Activity implements View.OnClickListener { Button btn;

@Override

public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main);

btn=(Button)findViewById(R.id.button);btn.setOnClickListener(this);updateTime();

}

public void onClick(View view) { updateTime(); }

private void updateTime() { btn.setText(new Date().toString()); } }

The first difference is that rather than setting the content view to be a view we created in Java code, we set it to reference the XML layout (setContentView(R.layout.main)). The R.java source file will be updated when we rebuild this project to include a reference to our layout file (stored as main.xml in our project’s res/layout directory). The other difference is that we need to get our hands on our Button instance, for which we use the findViewById() call. Since we identified our button as @+id/button, we can reference the button’s identifier as R.id.button. Now, with the Button instance in hand, we can set the callback and set the label as needed. As you can see in Figure 5-1, the results look the same as with the original Now demo. 32

Figure 5-1. The NowRedux sample activity

Employing Basic Widgets Every GUI toolkit has some basic widgets: fields, labels, buttons, etc. Android’s toolkit is no different in scope, and the basic widgets will provide a good introduction as to how widgets work in Android activities. Assigning Labels The simplest widget is the label, referred to in Android as a TextView. Like in most GUI toolkits, labels are bits of text not editable directly by users. Typically, they are used to identify adjacent widgets (e.g., a ―Name:‖ label before a field where one fills in a name). In Java, you can create a label by creating a TextView instance. More commonly, 33

though, you will create labels in XML layout files by adding a TextView element to the layout, with an android:text property to set the value of the label itself. If you need to swap labels based on certain criteria, such as internationalization, you may wish to use a resource reference in the XML instead, as will be described in Chapter 9. TextView has numerous other properties of relevance for labels, such as:

? android:typeface to set the typeface to use for the label (e.g., monospace) ? android:textStyle to indicate that the typeface should be made bold (bold), italic (italic),or bold and italic (bold_italic) ? android:textColor to set the color of the label’s text, in RGB hex format (e.g., #FF0000 for red) For example, in the Basic/Label project, you will find the following layout file:

34

Button, Button, Who’s Got the Button? We’ve already seen the use of the Button widget in Chapters 4 and 5. As it turns out, Button is a subclass of TextView, so everything discussed in the preceding section in terms of formatting the face of the button still holds. Fleeting Images Android has two widgets to help you embed images in your activities: ImageView and ImageButton. As the names suggest, they are image-based analogues to TextView and Button, respectively. Each widget takes an android:src attribute (in an XML layout) to specify what picture to use. These usually reference a drawable resource, described in greater detail in the chapter on resources. You can also set the image content based on a Uri from a content provider via setImageURI().

ImageButton, a subclass of ImageView, mixes in the standard Button behaviors, for responding to clicks and whatnot.

For example, take a peek at the main.xml layout from the Basic/ImageView sample project which is found along with all other code samples at http://apress.com:

The result, just using the code-generated activity, is shown in Figure 6-2. 35

Figure 6-2. The ImageViewDemo sample application Fields of Green. Or Other Colors. Along with buttons and labels, fields are the third ―anchor‖ of most GUI toolkits. In Android, they are implemented via the EditText widget, which is a subclass of the TextView used for labels.

Along with the standard TextView properties (e.g., android:textStyle), EditText has many others that will be useful for you in constructing fields, including: ? android:autoText, to control if the field should provide automatic spelling assistance ? android:capitalize, to control if the field should automatically capitalize the first letter of entered text (e.g., first name, city) ? android:digits, to configure the field to accept only certain digits ? android:singleLine, to control if the field is for single-line input or multiple-line input (e.g., does move you to the next widget or add a newline?) Beyond those, you can configure fields to use specialized input methods, such as android:numeric for numeric-only input, android:password for shrouded password input, 36

and android:phoneNumber for entering in phone numbers. If you want to create your own input method scheme (e.g., postal codes, Social Security numbers), you need to create your own implementation of the InputMethod interface, then configure the field to use it via android: inputMethod.

For example, from the Basic/Field project, here is an XML layout file showing an EditText: Note that android:singleLine is false, so users will be able to enter in several lines of text. For this project, the FieldDemo.java file populates the input field with some prose: package com.commonsware.android.basic; import android.app.Activity; import android.os.Bundle; import android.widget.EditText; public class FieldDemo extends Activity { @Override

public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main);

EditText fld=(EditText)findViewById(R.id.field); fld.setText(%under the Apache License, Version 2.0 \+ \ \\\you may not use this file \+ \in compliance with the License. You may \ + \ \} }

The result, once built and installed into the emulator, is shown in Figure 6-3. 37

Figure 6-3. The FieldDemo sample application Note Android’s emulator only allows one application in the launcher per unique Java package. Since all the demos in this chapter share the com.commonsware.android.basic package, you will only see one of these demos in your emulator’s launcher at any one time.

Another flavor of field is one that offers auto-completion, to help users supply a value without typing in the whole text. That is provided in Android as the AutoCompleteTextView widget and is discussed in Chapter 8. Just Another Box to Check The classic checkbox has two states: checked and unchecked. Clicking the checkbox toggles between those states to indicate a choice (e.g., ―Add rush delivery to my order‖). In Android, there is a CheckBox widget to meet this need. It has TextView as an ancestor, so you can use TextView properties like android:textColor to format the widget. Within Java, you can invoke: ? isChecked() to determine if the checkbox has been checked ? setChecked() to force the checkbox into a checked or unchecked state ? toggle() to toggle the checkbox as if the user checked it Also, you can register a listener object (in this case, an instance of

38

OnCheckedChangeListener) to be notified when the state of the checkbox changes.

For example, from the Basic/CheckBox project, here is a simple checkbox layout: The corresponding CheckBoxDemo.java retrieves and configures the behavior of the checkbox: public class CheckBoxDemo extends Activity

implements CompoundButton.OnCheckedChangeListener { CheckBox cb; @Override

public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main); cb=(CheckBox)findViewById(R.id.check); cb.setOnCheckedChangeListener(this); }

public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { if (isChecked) { cb.setText(\} else { cb.setText(\} } } Note that the activity serves as its own listener for checkbox state changes since it implements

the

OnCheckedChangeListener

The 39

interface the listener (via is cb.setOnCheckedChangeListener(this)). callback for onCheckedChanged(), which receives the checkbox whose state has changed and what the new state is. In this case, we update the text of the checkbox to reflect what the actual box contains. The result? Clicking the checkbox immediately updates its text, as you can see in Figures 6-4 and 6-5. Figure 6-4. The CheckBoxDemo sample application, with the checkbox unchecked Figure 6-5. The same application, now with the checkbox checked

40

Turn the Radio Up As with other implementations of radio buttons in other toolkits, Android’s radio buttons are two-state, like checkboxes, but can be grouped such that only one radio button in the group can be checked at any time. Like CheckBox, RadioButton inherits from CompoundButton, which in turn inherits from

TextView. Hence, all the standard TextView properties for font face, style, color, etc., are available for controlling the look of radio buttons. Similarly, you can call isChecked() on a RadioButton to see if it is selected, toggle() to select it, and so on, like you can with a CheckBox. Most times, you will want to put your RadioButton widgets inside of a RadioGroup. The RadioGroup indicates a set of radio buttons whose state is tied, meaning only one button out of the group can be selected at any time. If you assign an android:id to your RadioGroup in your XML layout, you can access the group from your Java code and invoke: ? check() to check a specific radio button via its ID (e.g., group.check(R.id.radio1)) ? clearCheck() to clear all radio buttons, so none in the group are checked ? getCheckedRadioButtonId() to get the ID of the currently-checked radio button (or -1 if none are checked) For example, from the Basic/RadioButton sample application, here is an XML layout showing a RadioGroup wrapping a set of RadioButton widgets:

41

Figure 6-6 shows the result using the stock Android-generated Java for the project and this layout. Figure 6-6. The RadioButtonDemo sample application

Note that the radio button group is initially set to be completely unchecked at the outset. To pre-set one of the radio buttons to be checked, use either setChecked() on the RadioButton or check() on the RadioGroup from within your onCreate() callback in your activity. It’s Quite a View 42

All widgets, including the ones previously shown, extend View, and as such give all widgets an array of useful properties and methods beyond those already described. Useful Properties Some of the properties on View most likely to be used include: ? Controls the focus sequence: ? android:nextFocusDown ? android:nextFocusLeft ? android:nextFocusRight ? android:nextFocusUp

? android:visibility, which controls whether the widget is initially visible ? android:background, which typically provides an RGB color value (e.g., #00FF00 for green) to serve as the background for the widget

Useful Methods You can toggle whether or not a widget is enabled via setEnabled() and see if it is enabled via isEnabled(). One common use pattern for this is to disable some widgets based on a CheckBox or RadioButton selection. You can give a widget focus via requestFocus() and see if it is focused via isFocused(). You might use this in concert with disabling widgets as previously mentioned, to ensure the proper widget has the focus once your disabling operation is complete. To help navigate the tree of widgets and containers that make up an activity’s overall view, you can use: ? getParent() to find the parent widget or container ? findViewById() to find a child widget with a certain ID ? getRootView() to get the root of the tree (e.g., what you provided to the activity via setContentView())

43

外文翻译

Android起航

译

使用XML进行布局

虽然纯粹通过Java代码在activity上创建和添加部件，在技术上是可行的，我们在第4章中做的一样，更常见的方法是使用一种基于XML的布局文件。动态的小部件实例保留更多，情况复杂，小工具在编译时不为人所知（例如，在数据检索了互联网基础上将单选按钮填充柱。

考虑到这一点，现在是时候打破XML来学习如何用此种方式来布置Android activities。

什么是基于XML的布局？

正如其名称所示，一个基于XML的布局是一个关系到每个规格的小部件，和他们的容器（更多关于此内容的在第7章）编码的XML格式。具体来说，Android认为基于XML的布局是资源，因此布局文件存储在res /在你的Android项目布局目录中。

每个XML文件包含一个指定的部件和容器布局元素树，一种意见认为构成层次。对XML元素的属性，描述一个部件应如何看或者一个容器应如何运转。例如，如果一个按钮元素。

有一个Android的属性值：文字样式=“bold”，这意味着该文本出现在按钮的表面应该是呈现一个粗体字体样式.

Android的SDK中附带一个使用的布局的工具（aapt）。这个工具应自动调用你的Android工具链（例如，Eclipse中，Ant’s build.xml）。作为一个开发人员，尤其重要的是，在您的项目中aapt生成R.java源文件，让您能在那些布局中直接从Java代码中获取布局和部件。

为什么使用基于XML的布局？

使用XML布局文件做的大部分都可以通过Java代码。例如，你可以使用setTypeface（）命令一个按钮使用粗体文本，而不是在一个XML布局中使用属性。由于XML布局是为你跟踪的另一个文件，所以我们需要好的理由来使用这样的文件。

也许最大的原因是为了在视图定义中协助工具的建立，如IDE中一个GUI创建者像

44

Eclipse或者一个像DroidDraw1设计GUI图形用户界面建设者。这样GUI建设者们，在原则上，生成Java代码而不是XML。目前的挑战是重新阅读用户界面的定义，以支持编辑，也就是说，

如果是像XLM的结构公式数据比一个程序语言中的数据简单的多。此外，保持生成的XML定义从手写的Java代码中分离，使得某人定制的来源意外重新生成不太可能。

XML形成一个良好的中间立场，使工具作家使用更简便，程序员需要时手工工作更简易。

此外，XML作为一个GUI定义格式是越来越普遍。微软的XAML，Adobe的Flex，和Mozilla的XUL都采取Android类似的方法：把布局细节放在一个XML文件和把编程智慧资料放在源文件（例如，XUL中的JavaScript）。许多不太知名的图形用户界面框架，如ZK，还使用视图定义的XML。而“随大流”并不一定是最好的政策，但他们有优势帮助从任何其他XML为中心的观点描述语言轻松进入Android。

好了，那么基于XML的布局是什么样子的？

下面是以前的章节的示例应用程序按钮，转换成一个XML布局文件，布局/ NowRedux示例项目，在这一章中可以找到源代码的http://apress.com领域。

android:layout_width=\android:layout_height=\

部件，按钮的类名称形成XML元素的名称。因为按钮是Android提供的部件，我们可以只使用裸类的名称。如果您创建自己的部件作为android.view.View子小部件，您也将需要提供一个完整的包声明（如com.commonsware.android.MyWidget）。

根元素需要Android的XML命名空间声明：

xmlns:android=\所有其他要素将成为子根并继承该命名空间的声明。

因为我们要引用这个来自Java代码的按钮，我们需要通过android给它一个标识符：id属性。我们将在本章后面更详细的介绍这个概念。

其余的属性是此按钮实例属性：

?android：文字表示的初始文本将显示在按钮（这种情况显示空字符串）

45

?android：layout_width和Android：layout_height命令android有按钮的 宽度和高度填写 “parent”，这种情况下，整个屏幕。将这些属性将在第7章中详解。

由于这个单一部件是activity的仅有内容，我们只需要这一个因素。复杂的用户界面将需要整个树的元素，代表工具和容器，控制自己的定位。所有的这本书余下的章节将使用XML布局，所以还有数十种更复杂的其他布局实例，请前进到第七章仔细阅读。

@符号有什么用途？

许多部件和容器只需要出现在XML布局文件，不须引用在Java代码。例如，一个静态标签（TextView）只需要在布局文件中以表明它应该出现在那里。在XML文件中各种元素文件不需要有android：id属性给他们一个名称。

任何你想要在Java资源中使用的东西，都需要一个android：id.

该公约是使用@ +id...作为ID值，其中的...代表你locallyunique名称有问题的部件。在上一节的XML布局的例子中，@ +id是按钮控件的标识符。

android提供了一些特殊的android：ID值，形式@android：id/...我们将在这本书的不同章节中看到这些，例如第八章和第十章。

我们将这些附加到Java?如何？

既然你有意建立一个XML配置文件的工具和容器，名为main.xml存储res/layout，所有你需要的是一个在您activity的OnCreate（）回调以使用该版式：

setContentView（R.layout.main）;

这是相同的setContentView（），我们前面使用，通过它的一个视图子类的实例（在这种情况下，一个按钮）。该android制造的观点，来自我们的布局，是从访问该代码生成的R类。所有的布局都可以访问R.layout，由基地键控布局文件的名称- main.xml result in R.layout.main.

要访问确定部件，使用findViewById（），在数字标识符传递有问题的部件。这一数字标识符生成的R类由android在R.id.something（其中一些是你正在寻找的具体部件）。这些部件是只是子类的视图，就像我们在第四章中创建Button实例。

剩下的部分

在原始的Now演示中，按钮的表面便会显示当前的时间，这将反映当按钮被最后按下时显示的时间（或者如果在按钮尚未被按下时显示）。

这种逻辑仍然适用，即使在该修订演示（NowRedux）中。尽管如此，在activity’s onCreate() callback中的实例，我们可以从XML的布局参考一个例子：

46

本文来源：https://www.bwwdw.com/article/i8vr.html