学习笔记3"/>
Android学习笔记3
用户界面
在一个Android应用程序里,用户接口是一系列的View和ViewGroup对象组合而成。Android有很多种View和ViewGroup对象,他们都继承自View基类。
View对象是Android平台用户接口的基本对象。这些view类作为与用户交互的widgets小部件的父类,像文本框和按钮。ViewGroup作为提供各种布局结构的layouts的父类,例如linear线性布局,表格布局和绝对布局。
一个view对象是一个数据结构,他存储布局参数和屏幕特定区矩形区域的内容。一个view会处理自己所在屏幕区域的测量、布局、绘制、焦点改变、滚动、和按键手势交互。作为用户交互对象,一个view可以作为用户与系统的交互工具,接收事件。
View 结构体系
在Android平台,你要用到View或ViewGroup的层、节点的方式来定义一个Android用户界面,就像下面的图表,这个层次结构树可以按你的需求变得简单或者复杂。你可以用Android系统已经定义好的小控件或者布局,或者自定义一些。
为了能让你的view层次结构在屏幕上渲染,你的activity需要调用setContentView()方法并且传递一个根节点对象的引用。Android系统接收这些配置,并使用他们来进行测量绘制这个树形的视图结构。这个视图结构的根节点要求他的孩子节点自我绘制,反过来说,每个viewGroup节点负责让他们的子节点自我绘制。子节点会在父节点哪里请求到尺寸和位置,但父对象会最终决定他们孩子有多大。Android按顺序解析你的布局上的所有元素,从顶端开始,实例化view并且把他们添加到父对象。因为他们都是按顺序被绘制的,如果某些view超出的显示范围,那么后来绘制的将会覆盖原来的。
关于view结构体系怎样绘制,在后面会有详细的讨论。
布局
通常最多的布局是通过xml来定义。xml提供一个容易阅读的结构,很像html。xml中每个元素都是一个view或者viewGroup对象(或他们的子类)。view在树结构中是叶子节点,ViewGroup对象在非叶子节点(树枝节点,参考上图)。
xml元素名代表着各个类。比如<TextView>元素会创建一个TextView控件,一个<LinearLayout>会创建一个LinearLayout的viewGroup,当你加载一个布局资源,Android系统会初始化运行时对象,即对应的布局元素。
例如,一个简单的垂直布局,里面包含一个textView和一个Button。
[xhtml] view plain copy
- <?xml version="1.0" encoding="utf-8"?>
- <LinearLayout xmlns:android=""
- android:layout_width="fill_parent"
- android:layout_height="fill_parent"
- android:orientation="vertical" >
- <TextView android:id="@+id/text"
- android:layout_width="wrap_content"
- android:layout_height="wrap_content"
- android:text="Hello, I am a TextView" />
- <Button android:id="@+id/button"
- android:layout_width="wrap_content"
- android:layout_height="wrap_content"
- android:text="Hello, I am a Button" />
- </LinearLayout>
注意,linearLayout元素包含着TextView和Button。你可以嵌套另外的LinearLayout,来增加view的长度,或者增加一个更复杂的布局。
更多关于UI布局的信息,请参考 Declaring Layout章节。
你可以在你的布局里用很多种布局方式,使用很多不同类型的viewGroup,你可以定义无限多的子view或者子viewGroup。android提供一些预先定义好的布局,包括:LinearLayout-线性布局, RelativeLayout-关系布局, TableLayout-表格布局, GridLayout 网格布局等。他们提供一些独特的参数用来定义view的位置和布局结构。
Widgets小部件
widget是一个服务于用户与界面交互的view对象。Android提供很多视图小部件,如按钮、寻则狂、文本输入框、到呢个,你可以很快的构建自己的布局。一些小部件很复杂,像日期选择器,一个时钟,缩放控制。但你不会被Android平台所提供的UI部件所限制,你可以自定义UI部件,可以继承或者结合已经存在的UI部件。
UI事件
一旦你向界面添加了view或者widget,你可能会想他们怎样与用户进行交互的,这样你就可以执行一些操作。添加UI事件,你需要做两件事情:
@ 定义事件监听器并注册给view。
多半情况下,这就是你怎样监听事件:view 类包含了一些名如OnXXXListener的监听器,他们都有名为OnXXX()的回调方法。例如:View.onClickListener(这是处理点击事件的),View.onTouchListener(处理触摸事件),View
.onKeyListener(处理按键事件),所以如果你想让view响应点击事件,比如按钮被选中,你需要实现OnClickListener接口并且定义回调方法,并且用setOnClickListener()方法来注册View。
@ 覆盖一个已经存在的回调方法:
如果你失信了自己的View类并且想要监听一些特殊的事件,那你应该用这种方法。例如,你可以处理屏幕触摸事件,处理滚动球事件,按键等事件。它允许你定义默认的事件,即自定义的view的每个事件,确定这个时间是否会传递到一些字view。然后,他们调用view类的回调函数,所以当你自定义一个组件时才有机会用到这种方法。
菜单Menu
应用程序菜单是UI的另一个很重要的部分。Menu提供一些可靠的借口来展示程序的功能和一些设置。通常menu是通过按menu键才显示的。然而,你可以让用户按下或者按住某一项时显示menu菜单。
menu菜单也遵循view的层次结构,但不要自己定义。取而代之的是,你只需为你的activity定义onCreateOptionsMenu()和onCreateContextMenu()两个回调方法即可,在适当的时间,Android会自动的绘制必要的视图结构并且menu的所包含的子项的。
Menu会处理他自己的时间。所以不需要注册事件监听器,当menu中的某一项被选中,系统会调用onOptionsItemSelected()方法或者onContextItemSelected()方法。
和应用程序的布局很像,你可以用xml来配置你的menu项。
高级特征
一旦你了解了创建用户界面的基本原则。你可以浏览一些高级特征来创建更复杂的应用程序接口。
适配器Adapters
一些时候,你不想用“硬代码”来填充一些view的数据,相反,你想让view绑定额外的数据集。要这样的话,你要定义一个AdapterView,每个子View里的数据都会被适配器填充。
适配器视图对象 AdapterView是实现的ViewGroup接口,子类是由被给出的适配器对象决定的。适配器就像你的adapter视图和数据源之间的适配器。这里有几种适配器类的实现方式,对于特殊的任务,例如自定义的适配器从一个Cursor来读取数据库的数据,或者一耳光数组适配器从任意一个数组读取数据。
风格和主题 Styles、Themes
你或许不满意标准控件的外观,你可以定制他们的风格和主题来改变他们。
@ 一个style是一个格式化的属性集,你作为布局的其中一个单元来使用他们。例如,你可以定义某些文本的文字大小和颜色作为特殊的view元素。
@ 一个theme主题是应用程序中整个activity的个格式化的属性集。例如,你可以定义窗体的边框和面板的背景,并且设置menu的字体大小和颜色。它可以应用在整个程序里。
风格和主题属于资源。Android提供一些默认的风格和主题资源来让你使用。或者你也可以自己定制他们。
声明布局
在一个activity里,你的layout就是整个界面架构。它定义了显示给用户的元素。你可以用两种方式声明你的layout:
@ 在XML里定义
android 提供了一些非常直观的视图类及其子类,比如一些widget和layout。
@ 在运行时新建一个实例
你的应用程序可以通过代码建立view或者viewGroup,并且设置它们的属性。
Android框架给了你这两种灵活的方法来管理和声明你的应用程序UI。例如,你可以在xml里声明一个默认的布局,包括用户界面的元素及其属性。你可以在运行时用过代码修改界面元素的包括在xml里声明的。
在xml里定制UI的优点是能让界面与逻辑部分相互独立并且容易iguanli它们的时间。如果UI和代码是分离的,那意味着你可以随时修改界面而不用修改代码后在编译。例如,你可以为横竖屏分别建立布局,不同的界面大小不同的语言。另外,在xml声明布局文件更直观,所以你很容易找出其中的bug,所以,这篇文章会告诉你怎样在xml里声明你的布局。如果你对运行时实例化view和viewGroup感兴趣,那你可以参考这两个ViewGroup和View类。
通常,UI元素的名字和实际的功能非常接近。元素名对应着类名,属性名对应着方法名。实际上,这种对应关系让我们很容易的猜到xml属性所丢应的类方法。或者才出一个类对应着哪个xml元素。然而,不是所有的命名都是相同的。有些情况下,命名会有一些不同。例如,EditText元素有一个text属性,但却对应着EditText.setText()方法。
小贴士:学习更多的布局类型可以参考Common Layout Objects章节,在Hello Views里有大量的创建布局的例子。
编写xml
使用Android xml的词汇表骂你可以很快的设计出UI布局和他们的位置。如同html那样,有一系列的嵌套元素。
每个layout布局文件必须包含一个根元素,这个根元素必须是view 或者 viewGroup。一旦你定义了根元素,你可以添加它的子元素,逐渐形成一个层次的布局。例如,下面是一个LinearLayout包含了一个TextView和Button。
[xhtml] view plain copy
- <?xml version="1.0" encoding="utf-8"?>
- <LinearLayout xmlns:android=""
- android:layout_width="fill_parent"
- android:layout_height="fill_parent"
- android:orientation="vertical" >
- <TextView android:id="@+id/text"
- android:layout_width="wrap_content"
- android:layout_height="wrap_content"
- android:text="Hello, I am a TextView" />
- <Button android:id="@+id/button"
- android:layout_width="wrap_content"
- android:layout_height="wrap_content"
- android:text="Hello, I am a Button" />
- </LinearLayout>
在xml声明好layout之后,保存为以xml为后缀名的文件,放到项目的res/layout/目录下,然后他就会被正确的编译。
待会我们再来讨论其中的具体元素的含义。
加载xml资源
当你编译完程序后,每个xml都编程一个view资源。你可以从代码中加载这些布局资源,在你的activity。onCreate()方法里。当你调用setContextView()之后,会把资源的引用通过R.layout_file_name的方式传递过去。例如你有了main_layout
.xml配置文件,你可以在activity中这样加载:
[java] view plain copy
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView.(R.layout.main_layout);
- }
当activity运行时,在OnCreate()回调方法会被Android框架所调用。
属性Attributes
每个View和Viewgroup对象都支持xml属性,其中一些是特殊的,例如,textView支持textSize属性,但这些属性也可以继承人和view对象来扩展着各类。一些属性是公共的,因为他们继承自根类,例如ID。其他的属性例如layout parameters 为称作布局参数,这些属性用来描述view的布局,被他们的父view,即viewGroup定义的。
ID
每个View对象都有一个int型Id属性,作为在视图结构中的唯一标识。当一个程序编译完成,id便成为一个int型的引用,但是通常在xml中的id属性中id是一个字符串。这是所有view对象所共有的基本属性,你会经常用到。xml中的书写语法如下:android:id="@+id/my_button"
字符串开始的@符,说明xml解析器会解析@符后面剩余的字符串,并会定义他为一个id资源。“+”符号意味着必须在R.java文件中增加这个资源。android框架会提供大量的id资源。当我们引用一个android资源id时,你不需要“+”符号,但是必须添加android包的命名空间,像这样:android:id="@android:id/empty"
当使用了android包的命名空间,我们便可以使用android.r资源类了。
为了建立view 并且在程序中使用,通常的模式是:
1.在xml中定义一个viewm,并且分配一个id
[xhtml] view plain copy
- <Button android:id="@+id/my_button"
- android:layout_width="wrap_content"
- android:layout_height="wrap_content"
- android:text="@string/my_button_text"/>
2.(通常在onCreate()方法里)在代码中新建一个view对象的引用
[java] view plain copy
- Button myButton = (Button) findViewById(R.id.my_button);
在RelativeLayout相对布局时,定义view对象的id是非常重要的,这种布局下,兄弟view可以通过之间的位置关系来定布局,就是通过这个唯一标识id。
在整个布局结构中,id并不一定是唯一的,保证在当前布局结构中唯一即可,但我们有时会使用到整个布局,所以做好全局唯一。
布局参数
名为layout_something的xml属性定义了在viewGroup里的view的布局参数。
每个viewGroup类实现了一个继承自ViewGroup.LayoutParams类的嵌套类。这个子类包含了一些控制他的子View的大小位置等参数。
正如下面你所看到的,父View定义了子View的布局:
注意每个布局参数子类有自己的设置值的格式语法,每个子元素必须定义适合父view的布局参数,尽管他为自己的子view也定义了不同的布局参数。
所有的viewGroup都包含了宽高属性,而且必须定义它们。很多布局参数也包含了可选的间隙参数和边界参数。
你可以用精确的值来定义宽高,尽管你并不希望经常这样做。更多的时候,你会这样来定义:
@ wrap_content 只占用所需要的尺寸
@ fill_parent 占用父viewGroup可能的最大尺寸。(在API Level 8 里更名为 match_parent)
通常, 不建议使用像素值来定义宽高值,我们经常用相对的单位,如与密度无关的像素单元(dp),或者warp_content或者fill_parent来代替,这样能确保你的程序能运行在大量不同尺寸的设备上。公认的测量类型在 Available Respurces 文档里被定义。
布局位置 Layout Position
view是一个矩形,每个view都有一个位置,包含x,y起始坐标和宽高来确定这个矩形的位置。位置和尺寸的单位是像素pixel。通过调用getLeft()和getTop()方法可以获得view 的位置,两个方法返回矩形的左上角的坐标xy。这些方法返回的是相对于父view的方位。比如,getLeft()返回20,那么他的右边距离父view左边有20个像素。此外,有很多方便的方法,都是为了减少不必要的计算,像getRight()和 getBottom()。(getRight()=getLeft()+getWidth())
大小、填充、边距 Size, Padding and Margins
一个view的大小即他的宽高。一个view 实际上有两套高度宽度值。
第一对值是我们都知道的measured width和measured 高度即测量宽度和测量高度。这组值定义了他们想在父view中有多大,通过 getMeasuredWidth() 和 getMeasuredHeight() 可以获得他们。第二组值为width和height,或者成为 drawing width 和drawing height。这组值定义了view再被绘制到屏幕后,在屏幕中的实际大小。这些值有可能会和第一组值大小不同。通过getWidth()和getHeight()方法可以获得。
为了得到view 的实际尺寸,必须考虑到他的填充。padding属性表示view的左上右下的像素间隙。通过设置一些像素值,padding属性被用来填充视图内容周围。例如,把left padding 设置为2,则view左边 与其父view的左边会有2个像素的间隙。通过setPadding(int,int,int,int)方法和getPaddingLeft()/getPaddingRight()/getPaddingTop()/getPaddingBotton()方法设置和获得。
尽管一个view可以定义padding,但他不支持margins属性,但是viewGroup支持。参考 ViewGroup和ViewGroup.marginlayoutParams类来获得更多信息。
创建菜单
菜单是应用程序重要的组成成分。他提供相似的借口来提供功能和设置。android为开发者提供一个简单的编程借口,针对不同的情况提供标准的程序菜单。
android 提供三种基本的menu类型:
Options Menu
这是一个菜单的基本元素。通过按menu的屏幕键才显示。有两种类型的menu菜单:
Icon Menu
通过按下menu键会出现这些可见按钮的集合。最大可以支持6个选项。只能显示为图标,并且菜单项只能为按钮,不能是选择框。
Expanded Menu
Icon menu有一个more选项,有一个选项集。只有当 Icon Menu 菜单被重写,并且有超过六个的选项时才会被显示。
Context Menu
这个菜单会在你长时间按view时显示。
Submenu
这是一个子菜单,可以添加到 Options Menu 或 Context Menu 菜单的选项中,子菜单不支持嵌套使用。
Options Menu
选项菜单通过按下menu键来显示。当菜单打开时,只显示前六个选项,如果超过六个,多的部分会显示在more里。超过的选项被添加到more菜单里是系统自动添加的。
选项菜单可以包含一些基本的程序功能,或者必要的导航。比如从主界面转到设置界面。你可以添加Submenus 来配置你的显示项,让它包含更多的功能。
当menu第一次被创建时,android系统会调用activity的onCreateOptionsMenu()回调方法。要添加自己的menu只需要重写它即可。你可以在弹出的menu中包含着在xml中定义的资源。或者通过调用add()方法添加每一个选项。这个方法会添加一个MenuItem,并且返回你最新创建的对象。你可以使用它们来获得菜单项,然后添加一些额外的属性,比如设置icon、快捷键等。
有很多种的add()方法,通常用的是能接收一个itemid参数的那个,这个id可以让你识别回调方法。
当一个菜单项从菜单中被选中,你会接收一个回调方法onOptionItemSelected()。这个回调方法会传递你所点击的菜单项,可以通过传来的id来判断是哪个菜单项。一旦你定义了菜单项,就可以添加适当的处理时间处理方法。
这里有一断activity中的代码,你可以这样定义并且处理他们的选择事件:
[java] view plain copy
- /* Creates the menu items */
- public boolean onCreateOptionsMenu(Menu menu) {
- menu.add(0, MENU_NEW_GAME, 0, "New Game");
- menu.add(0, MENU_QUIT, 0, "Quit");
- return true;
- }
- /* Handles item selections */
- public boolean onOptionsItemSelected(MenuItem item) {
- switch (item.getItemId()) {
- case MENU_NEW_GAME:
- newGame();
- return true;
- case MENU_QUIT:
- quit();
- return true;
- }
- return false;
- }
在这个例子中使用的add()方法有四个参数:groupId、itemId、 order 和 title。groupId允许你将要添加的条目添加到groupId躲在项里。这个例子里,我们没有设置。itemid 是我们给MenuItem的唯一的整型值,可以用在在回调方法中识别选中项。order允许我们自定义item显示的顺序,默认情况下按照添加的顺序显示。title,就是显示的标签名,你可以用String resource字符串资源的方式来添加,这有有助于本地化的修改。
如果你想把几个菜单项合成一组,你可以用Submenu来实现。
添加图标 Adding icons
Icons可以通过setIcon()方法来添加。例如
menu.add(0, MENU_QUIT, 0, "Quit").setIcon(R.drawable.menu_quit_icon);
修改菜单 Modifying the menu
如果你想在菜单被添加之后修改它,可以重写onPrepareOptionsMenu()方法,他在菜单每次被打开时调用。他会传递你的menu对象,就像onCreateOptionsMenu()方法那样。如果你想根据程序或者游戏现在的状态来确定是否修改menu 的话,这个方法将会非常有用。
注意:当改变menu里的菜单项时,不提倡直接操作当前选中项。请记住,当在触摸模式下,是没有当前选中项的,相反,你应该使用Context Menu 来做这样的操作:在UI的特定项目里提供这样的功能。
Context Menu
android的 Context Menu 也是类似的,在PC上,即为右键菜单。当一个view注册了Context Menu 菜单后,长按这个view便能显示菜单,提供一些与此view相关的功能。Context menus可以使用任何的view,但通常被注册成listView,这种view会使选中的项目非常的明显。(待会会有一个例子)
注意:Context Menu条目不支持图标和快捷键。
要创建一个Context Menu,你必须重写activity的 Context Menu 回调方法:onCreateContextMenu()和 onContextItemSelected()方法。在onCreateContextMenu()回调方法中,你可以通过add()方法添加菜单项,或者使用xml配置文件添加,然后yon registerForContextMenu()方法注册成为ContextMenu。
例如,下面是在笔记本应用程序中添加contextMenu的例子:
[java] view plain copy
- public void onCreateContextMenu(ContextMenu menu, View v,
- ContextMenuInfo menuInfo) {
- super.onCreateContextMenu(menu, v, menuInfo);
- menu.add(0, EDIT_ID, 0, "Edit");
- menu.add(0, DELETE_ID, 0, "Delete");
- }
- public boolean onContextItemSelected(MenuItem item) {
- AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
- switch (item.getItemId()) {
- case EDIT_ID:
- editNote(info.id);
- return true;
- case DELETE_ID:
- deleteNote(info.id);
- return true;
- default:
- return super.onContextItemSelected(item);
- }
- }
在onCreateContextmenu()方法中,我们不仅仅只能给contextMenu添加菜单项,而且还可以给选中的view或者是ContextMenuInfo对象添加。ContextMenuInfo对象提供了选中对象的一些相关信息。例如,在OnCreateContextMenu()方法中添加两个很普通的item条目。在onContextItemSelected()方法中,我们需要得到菜单项的AdapterContextmenuInfo,来获取关于当前选中项的某些信息。我们只需要选中条目的id即可,所以无论添加或者删除,我们只需要知道AdapterContextMenuInfo.info 这个属性即可。然后这个id会被传递到deitNote()方法或者deleteNote方法来做相应的处理。
现在,为ListView中所有的项添加contextMenu方法,我们把整个ListView传递给registerForContextMenu(View)方法。
registerForContextMenu(getListView());
记住,你可以传递任何view对象来注册 contextMenu菜单,getListView()方法会返回在ListActivity类中使用到的ListView,因此,list中的每一项都会注册一个contextMenu。
子菜单Submenus
一个子菜单可以被添加到任何菜单,但不不能添加到子菜单中。当你的应用程序有很多功能需要被显示的时候非常有用。你可以用add()方法给menu添加额外的条目,例如:
[java] view plain copy
- SubMenu fileMenu = menu.addSubMenu("File");
- SubMenu editMenu = menu.addSubMenu("Edit");
- fileMenu.add("new");
- fileMenu.add("open");
- fileMenu.add("save");
- editMenu.add("undo");
- editMenu.add("redo");
- return result;
- }
子菜单中的回调方法会传递给父菜单的回调方法。如上所示:子菜单的选择结果会传递到父菜单的onOptionsItemSelected();
在xml文件中定义Menus
就像UI布局一样,你可以在xml文件中定义菜单。然后再onCreate()方法中实例化他们。这样会让你的程序代码更加简洁,并且让代码和视图分离,更加可视化。
首先,在res文件夹下建立一个menu文件夹。你可以在这里定义菜单。
在一个菜单的xml布局中,有三个元素:<menu><group><item>。
Item和group元素必须是menu的子元素,但item还可以是group的子元素,menu元素必须有一个子元素,当然了,最外层的根元素必须是menu。
作为一个例子,我们建一个和上面一样的操作菜单,先在res/menu/文件夹下建一个option_menu.xml文件
[xhtml] view plain copy
- <menu xmlns:android="">
- <item android:id="@+id/new_game"
- android:title="New Game" />
- <item android:id="@+id/quit"
- android:title="Quit" />
- </menu>
然后,在onCreateOptionsMenu()方法中,我们用MenuInflater.inflate()方法加载这个资源:
[java] view plain copy
- public boolean onCreateOptionsMenu(Menu menu) {
- MenuInflater inflater = getMenuInflater();
- inflater.inflate(R.menu.options_menu, menu);
- return true;
- }
getMenuInflater()方法会返回activity的菜单解析器,我们可以调用inflate()方法来传递先前定义好的menu资源的指针,在回调方法中可以得到菜单对象。
虽然这种方式看似更加麻烦,但当你处理大量items时会为你省很多事,并且让你的代码看起来更加整洁。
你可以定义menu group,在group元素里包装item来定义menu group,并且在item里创建别的menu,每个元素都支持一些基本属性如快捷键、选择框、图标等。学习更多的属性可以参考XML syntax.
菜单特性
这里有一些大多数菜单项都有的特性
菜单组
当我们添加新的条目到一个菜单中,你可以让所有条目包含在一个组中,菜单组是菜单条目的集合,里面的菜单那项可以共享某些特性,比如是否可见、可用、可选。
一个菜单组被定义为整形(或者在xml中配置一个资源id),往menu中使用add()方法添加菜单项时,如果参数中包含了菜单组的id,那么这个条目会添加到相应的菜单组中。比如add(int,int,int,int)。使用setGroupVisible()方法可以设置整个组是否隐藏。setGroupEnabled()发那个发设置整个组是否可用,setGroupCheckable()设置整个组是否可选。
可选菜单项
任何菜单项都有是否可选的接口。可以是一个独立的选择框、单选框、单选按钮复选框,参考上面截图。
注意:在Icon菜单中,菜单项不能显示为但则狂或者单选按钮。如果你想在icon菜单中让条目可选,必须自己在状态改变时改变条目的现实。
想让一个条目可选,可以使用setCheckable()方法,像这样。
[java] view plain copy
- menu.add(0, VIBRATE_SETTING_ID, 0, "Vibrate")
- .setCheckable(true);
这样会显示一个选择框(前提是他不是一个icon菜单),当条目被选中时,onOptionsItemSelected()回调方法会被调用。这里你必须设置选择框的状态,你可以使用isChecked()查询当前状态或者使用setChecked()方法设置状态。类似于onOptionsItemsSelected()方法。
[java] view plain copy
- switch (item.getItemId()) {
- case VIBRATE_SETTING_ID:
- if (item.isChecked()) item.setChecked(false);
- else item.setChecked(true);
- return true;
- ...
- }
如果想让几个radio选择按钮成为一个单选按钮组,可以设置相同的groupId,然后调用setGroupCheckable()方法即可。这种情况下,不用每个item都调用setCheckable()方法,下面是一个子菜单中的两个单选按钮组:
[java] view plain copy
- SubMenu subMenu = menu.addSubMenu("Color");
- subMenu.add(COLOR_MENU_GROUP, COLOR_RED_ID, 0, "Red");
- subMenu.add(COLOR_MENU_GROUP, COLOR_BLUE_ID, 0, "Blue");
- subMenu.setGroupCheckable(COLOR_MENU_GROUP, true, true);
在setGroupCheckable()方法中,第一个参数为要设置的groupId,第二个为菜单项是否可选,最后一个参数是是否为单选(设为false的则所有item选择情况相互独立,即可以多选),当group设为单选时,每一次有条目被选中时,其他选项自动设置为未选状态(即单选)。
注意:可选菜单按钮是基于会话的,其状态、结果并不会保存在设备上。如截图所示:在地图程序中的设置并不会保存。如果你想把设置的记过保存,可以使用Preferences累,并且使用PreferencesActivity类来管理他们。
Shortcut keys
使用setAlphabeticShortcut(char)方法,可以给菜单项中添加快捷键,使用setNumericShortcut(int)可以设置数字快捷键,或者使用setShortCut(char,int)。大小写不敏感,例如:
[java] view plain copy
- menu.add(0, MENU_QUIT, 0, "Quit")
- .setAlphabeticShortcut('q');
现在,当菜单打开时,或者按下menu键时,按下q键将会选择这个条目。
这个快捷键会当成菜单项的一个小提示来显示,在菜单项标签的下面(icon菜单除外)。
注意:快捷键不能加载Context菜单中。
菜单项的intents
如果你阅读了以前的章节,你会对Android Intents有所熟悉,它允许应用程序绑定到其他程序上,共享信息,各个任务间通信。就像你的程序可以启动一个web浏览器、或者email客户端或者其他的activity,你可以在一个菜单中运行它们。有两种方式:为每个菜单项定义一个intent;或者定义intent然后允许Android自动搜索activity,并为每个符合条件的activity添加菜单项。
关于建立intents和为程序提供服务的详细信息,可以参考Intents and Intent Filter 章节
为单独的菜单项设置intent
如果你想让一个菜单项运行一个新的activity,那么你需要调用菜单项的setIntent()方发来定义intent。
例如,在onCreateOptionMenu()里,你可以这样定义:
[java] view plain copy
- MenuItem menuItem = menu.add(0, PHOTO_PICKER_ID, 0, "Select Photo");
- menuItem.setIntent(new Intent(this, PhotoPicker.class));
当点击菜单项时,android 会自动运行设置好的activity。
注意:这种运行方式不会返回数据,如果你想得到返回数据,那么不能使用setIntent()方法。你应该在onOptionsMenuItemSelected()方法或onContextMenuItemSelected()方法中调用startActivityForResult()方法。
动态添加intents
当前程序或者当前选项有可能会关联很多的activity,所以程序便可以动态的添加菜单项来执行那些操作。
在创建menu菜单时,根据当前选定项的MIME类型,来使用Intent.ALTERNATIVE_CATEGORY或者Intent.SELECTED_ALTERNATIVE这两个参数来设置intent的分类,或者其他的参数来让intent filter (intent过滤器)启动一个新的acticity。然后调用addIntentOptions()来让android搜索到符合要求的服务并且添加到menu菜单中。如果没有合适的相应程序则菜单不添加条目。
注意:SELECTED_ALTERNATIVE 处理当前屏幕里选中项,所以,之有当在onCreateContextMenu()方法和onPrepareOptionsMenu()方法里建立菜单时时才能使用。
下面的例子,展示了程序怎样找到额外的服务来显示到菜单中。
[java] view plain copy
- public boolean onCreateOptionsMenu(Menu menu){
- super.onCreateOptionsMenu(menu);
- // Create an Intent that describes the requirements to fulfill, to be included
- // in our menu. The offering app must include a category value of Intent.CATEGORY_ALTERNATIVE.
- Intent intent = new Intent(null, getIntent().getData());
- intent.addCategory(Intent.CATEGORY_ALTERNATIVE);
- // Search for, and populate the menu with, acceptable offering applications.
- menu.addIntentOptions(
- thisClass.INTENT_OPTIONS, // Menu group
- 0, // Unique item ID (none)
- 0, // Order for the items (none)
- this.getComponentName(), // The current Activity name
- null, // Specific items to place first (none)
- intent, // Intent created above that describes our requirements
- 0, // Additional flags to control items (none)
- null); // Array of MenuItems that correlate to specific items (none)
- return true;
- }
当activity发现有合适的intent过滤器时,便会添加一个相应的menu菜单项,菜单项会显示lable标签的内容。addIntentOptions()方法会返回添加的菜单项的个数。
必须注意:当addIntentOptions()方法被调用时,他将会覆盖第一个参数所指定菜单里的所有项。
如果你想为其他菜单提供服务,你只需要定义一个intent filter,只要再<category>标签里包含 ALTERNATIVE 或者 SELECTED_ALTERNATIVE 即可,例如:
[java] view plain copy
- <intent-filter label="Resize Image">
- ...
- <category android:name="android.intent.category.ALTERNATIVE" />
- <category android:name="android.intent.category.SELECTED_ALTERNATIVE" />
- ...
- </intent-filter>
建立对话框Dialog
Dialog是一个常见的显示在当前activity之上的小窗口。下面的activity会失去焦点,而dialog回接受用户输入。dialog常用在与程序直接相关联的通知和短小的activity中。
Android API支持以下几种dialog:
AlertDialog:
它可以包含0、1、2、3个按钮,或者一个列表或者多选单选按钮等,它是一个功能最强大的dialog接口,详细信息可参考下面的章节。
ProgressDialog:
它会显示一个进度条或者进度环,因为他是AlertDialog的子类,所有野支持按钮。
DatePickerDialog:
用来选择日期的对话框。
TimerPickerDialog:
用来选择时间的。
如果你想要定制自己的dialog,你可以继承Dialog对象,或者它的任何一个子类,并且定义一个新的布局。
显示一个Dialog
Dialog 总是被当做activity的一部分来创建和显示。你可以在activity的onCreateDialog(int)方法中创建一个dialog。当你使用这个方法,android系统会自动的管理每个dialog的状态并且关联到所在的activity中,让这个activity成为dialog的管理者。每个dialog都会继承activity的某些特性。例如,当dialog打开时,按下menu弹出的是所在activity的菜单,调节的是所在activity的音量。
注意:如果你决定在onCreateDialog()方法之外建立dialog,他将不会连接到activity中,此时,你可以使用setOwnerActivity(Activity)方法来绑定activity。
当你显示dialog时,调用showDialog(int)来传递一个dialog的id句柄。
当一个dialog首次显示时,android会在实例化dialog的activity中调用onCreateDialog(int)方法。回调方法会传递相同的id给showDialog(int)。当 创建完一个dialog后,会再方法的最后返回这个对象。
在dialog显示前,android回调用可选的方法 :onPrepareDialog(int,Dialog)。如果你想在每次调用dialog时改变一些配置的话,你可以定义这个方法。OnPrepareDialog(int,Dialog)方法会在每次调用dialog时调用,而onCreateDialog(int)方法只会调用一次。如果你不定义onPrepareDialog()方法,那么打开的dialog会保持上一次的状态。这个方法也会传递dialog的id句柄。
定义这两个onXXX()方法最好使用一个switch结构来检测Id参数,每一个case项都应该创建自己的dialog。例如。想象一个游戏使用两个不同的dialog,一个暂停一个结束游戏:
[java] view plain copy
- static final int DIALOG_PAUSED_ID = 0;
- static final int DIALOG_GAMEOVER_ID = 1;
然后,再onCreateDialog(int)里根据id创建dialog:
[java] view plain copy
- protected Dialog onCreateDialog(int id) {
- Dialog dialog;
- switch(id) {
- case DIALOG_PAUSED_ID:
- // do the work to define the pause Dialog
- break;
- case DIALOG_GAMEOVER_ID:
- // do the work to define the game over Dialog
- break;
- default:
- dialog = null;
- }
- return dialog;
- }
注意:在例子中没有详写,因为定义dialog属于另外的章节。
现在可以调用showDilaog(int)来显示一个dialog了:
[java] view plain copy
- showDialog(DIALOG_PAUSED_ID);
取消Dialog的显示
调用dialog的dismiss()方法可以隐藏正在显示的dialog,如果必要的话,可以调用activity的dismissDialog(int)方法,他俩效果是一样的。如果使用的onCreateDialog(int)方法来管理dialog的状态,那么每次当你的dialog消失时,对话框的状态都会被activity保存着。如果不太需要这个对话框或者不希望activity保留dialog的状态,可以调用removeDialog(int)方法。它会删除任何关于dialog的引用,如果dialog正在显示,此方法会让dialog隐藏。
隐藏dialog监听器的使用
如果你想让activity在dialog隐藏时执行某些动作,那么你可以建立一个监听器。
首先定义DialogInterface.OnDismissListerner 接口,这个接口只有一个方法,onDismiss(DialogInterface),当dialog隐藏时被调用,然后传递OnDismissListener 对象给setOnDismissLister()方法。
然而,注意dialog也可以是取消,用户让这个dialog取消也是一种特殊的情况。当用户按下back键时,或者调用cancel()方法时会发生这种情况。当一个dialog被取消时,OnDismissLister监听器仍然会收到通知,但如果你喜欢的到明确的取消消息,可以注册DialogInterface.OnCancelLister监听器。
AlertDialog的创建
AlertDialog时Dialog的子类,Dilaog绝大多数是这个强大类型,你可以在以下情况下使用:
@ 一个标题
@ 一个文本信息
@ 一个两个或者三个按钮
@ 一个单选或者多选列表
建立AlertDialog,使用AlertDialog.Builder子类。使用AlertDialog.Builder(Context)方法来获得一个Builder,并且使用它的公共方法来定义AlertDialog所有的属性。最后,调用create()方法来显示。
下面显示了如何定义AlertDialog.Builder类的一些属性,如果在onCreateDialog()方法中使用了例子中的代码,你可以返回结果对话框来显示这个dialog。
添加按钮
创建一个上图所示包含按钮的AlertDialog,可以使用setXXXButton()方法:
[java] view plain copy
- AlertDialog.Builder builder = new AlertDialog.Builder(this);
- builder.setMessage("Are you sure you want to exit?")
- .setCancelable(false)
- .setPositiveButton("Yes", new DialogInterface.OnClickListener() {
- public void onClick(DialogInterface dialog, int id) {
- MyActivity.this.finish();
- }
- })
- .setNegativeButton("No", new DialogInterface.OnClickListener() {
- public void onClick(DialogInterface dialog, int id) {
- dialog.cancel();
- }
- });
- AlertDialog alert = builder.create();
首先,通过setMessage(CharSequence)为dialog添加一个message,然后通过setCancelable(boolean)方法让此dialog无法通过按back键来取消。每个按钮都需要调用setXXXButton()方法,例如setPositiveButton()方法,DialogInterface.OnClickListener()类会定义按下按钮所要做的处理。
注意:每种类型的按钮只能加一个,这就是说,你不能添加多于一个的positive按钮。最多能添加三个按钮,positive, neutral, 和 negative.他们名字所显示的功能并未实现,但能帮你记住要实现的功能。
添加一个列表
如上图所示,使用setItems()方法添加可选列表:
[java] view plain copy
- final CharSequence[] items = {"Red", "Green", "Blue"};
- AlertDialog.Builder builder = new AlertDialog.Builder(this);
- builder.setTitle("Pick a color");
- builder.setItems(items, new DialogInterface.OnClickListener() {
- public void onClick(DialogInterface dialog, int item) {
- Toast.makeText(getApplicationContext(), items[item], Toast.LENGTH_SHORT).show();
- }
- });
- AlertDialog alert = builder.create();
首先,使用setTitle(CharSequence)方法设置标题,然后使用setItem()方法添加可选列表,这个列表会接收一个item数组来显示,DialogInterFace.OnClickListener类会定义他们的点击事件。
添加选择框和单选按钮
通过setMultiChoiceItems()方法或 setSingleChoiceItems()方法来分别建立一个多选按钮列表或者单选列表,如果再onCreateDialog()方法中建立了其中一种列表,android会为你管理这个list。当activity处于活动状态时,dialog会记住当才选中项,如果退出了程序,选择结果便会丢失。
注意:当用户离开或者暂停activity时,如果你想保存选择状态,你必须在整个activity的生命周期中保存这个设置。永久的保存所选项,甚至当前进程完全被关闭,你需要使用数据存储方式来保存。建立一个如上图所示的列表dialog,代码和上面的例子相同,只需要把setItems()方法改为setSingleChoiceItems()方法即可。
[java] view plain copy
- final CharSequence[] items = {"Red", "Green", "Blue"};
- AlertDialog.Builder builder = new AlertDialog.Builder(this);
- builder.setTitle("Pick a color");
- builder.setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {
- public void onClick(DialogInterface dialog, int item) {
- Toast.makeText(getApplicationContext(), items[item], Toast.LENGTH_SHORT).show();
- }
- });
- AlertDialog alert = builder.create();
setSingleChoiseItems()方法的第二个参数是checkedItem的id值,从0开始对应着位置,如果返回”-1“表明没有选中任何项。
进度对话框 ProgressDialog 的建立
ProgressDialog时AlertDialog的子类,它会显示一个表示进度的圆形动画,来表示一个进度或者任务正在运行,也可以时一个进度条,能清晰的表示出进度。他也能添加按钮,比如取消一个下载进程。
调用ProgressDialog.show()方法可以显示进程对话框,例如,上图的对话框可通过如下代码生成:
[java] view plain copy
- ProgressDialog dialog = ProgressDialog.show(MyActivity.this, "",
- "Loading. Please wait...", true);
第一个参数是程序的Context引用,四二个为标题,第三个为显示的信息,最后一个为类型,(当创建进度条时才会用到,下节讨论)。
默认的进度条为圆形的样式,如果你想生成一个通过具体数值来显示任务的加载情况的进度条,下一节会讨论。
进度条的显示
显示一个进度条要经过以下几个步骤:
1-使用ProgressDialog(Context)方法初始化
2-使用setProgressStyle(int)方法设置类型。
3-调用show()方法显示,或者在onCreateDialog(int)方法里返回一个ProgressDialog。
4-你可以调用setProgress(int)方法,根据整体的任务完成度来设置一个具体进度值,或者使用incrementPressBy(int)来设置一个增长值。
例如:
[java] view plain copy
- ProgressDialog progressDialog;
- progressDialog = new ProgressDialog(mContext);
- progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
- progressDialog.setMessage("Loading...");
- progressDialog.setCancelable(false);
设置代码非常简单,大部分代码是在dialog参与进程并且更新的功能里。你会发现,另起一个线程来做这个工作是很有必要的,要把消息传递给activity的UI线程里需要用到 Handler 消息机制。如果你并不熟悉使用额外的线程,那么看这个例子:
这个例子使用了第二个线程来跟踪任务的进度(实际上只是在数值上加到100),线程通过 Handler 发了一个Message 给主activity,然后主activity更新ProgressDialog。
[java] view plain copy
- package com.example.progressdialog;
- import android.app.Activity;
- import android.app.Dialog;
- import android.app.ProgressDialog;
- import android.os.Bundle;
- import android.os.Handler;
- import android.os.Message;
- import android.view.View;
- import android.view.View.OnClickListener;
- import android.widget.Button;
- public class NotificationTest extends Activity {
- static final int PROGRESS_DIALOG = 0;
- Button button;
- ProgressThread progressThread;
- ProgressDialog progressDialog;
- /** Called when the activity is first created. */
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.main);
- // Setup the button that starts the progress dialog
- button = (Button) findViewById(R.id.progressDialog);
- button.setOnClickListener(new OnClickListener(){
- public void onClick(View v) {
- showDialog(PROGRESS_DIALOG);
- }
- });
- }
- protected Dialog onCreateDialog(int id) {
- switch(id) {
- case PROGRESS_DIALOG:
- progressDialog = new ProgressDialog(NotificationTest.this);
- progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
- progressDialog.setMessage("Loading...");
- progressThread = new ProgressThread(handler);
- progressThread.start();
- return progressDialog;
- default:
- return null;
- }
- }
- // Define the Handler that receives messages from the thread and update the progress
- final Handler handler = new Handler() {
- public void handleMessage(Message msg) {
- int total = msg.getData().getInt("total");
- progressDialog.setProgress(total);
- if (total >= 100){
- dismissDialog(PROGRESS_DIALOG);
- progressThread.setState(ProgressThread.STATE_DONE);
- }
- }
- };
- /** Nested class that performs progress calculations (counting) */
- private class ProgressThread extends Thread {
- Handler mHandler;
- final static int STATE_DONE = 0;
- final static int STATE_RUNNING = 1;
- int mState;
- int total;
- ProgressThread(Handler h) {
- mHandler = h;
- }
- public void run() {
- mState = STATE_RUNNING;
- total = 0;
- while (mState == STATE_RUNNING) {
- try {
- Thread.sleep(100);
- } catch (InterruptedException e) {
- Log.e("ERROR", "Thread Interrupted");
- }
- Message msg = mHandler.obtainMessage();
- Bundle b = new Bundle();
- b.putInt("total", total);
- msg.setData(b);
- mHandler.sendMessage(msg);
- total++;
- }
- }
- /* sets the current state for the thread,
- * used to stop the thread */
- public void setState(int state) {
- mState = state;
- }
- }
- }
自定义dialog的建立
如果你想自定义dialog的布局,你可以自己创建一个dialog布局。定义好之后,传递根View对象或者资源ID到setContextView(View)方法。
例如,如上图的dialog:
1-建立一个xml布局文件custom_dialog.xml;
[java] view plain copy
- <LinearLayout xmlns:android=""
- android:id="@+id/layout_root"
- android:orientation="horizontal"
- android:layout_width="fill_parent"
- android:layout_height="fill_parent"
- android:padding="10dp"
- >
- <ImageView android:id="@+id/image"
- android:layout_width="wrap_content"
- android:layout_height="fill_parent"
- android:layout_marginRight="10dp"
- />
- <TextView android:id="@+id/text"
- android:layout_width="wrap_content"
- android:layout_height="fill_parent"
- android:textColor="#FFF"
- />
- </LinearLayout>
这个xml在LinearLayout里定义了一个ImageView和TextView。
2-设置上面的布局为dialog的context view ,并且定义ImageView和TextView两个元素。
[java] view plain copy
- Context mContext = getApplicationContext();
- Dialog dialog = new Dialog(mContext);
- dialog.setContentView(R.layout.custom_dialog);
- dialog.setTitle("Custom Dialog");
- TextView text = (TextView) dialog.findViewById(R.id.text);
- text.setText("Hello, this is a custom dialog!");
- ImageView image = (ImageView) dialog.findViewById(R.id.image);
- image.setImageResource(R.drawable.android);
实例化dialog后,使用setContextView(int)方法设置自定义的布局。现在dialog便有了一个自定义的布局,你可以使用findViewById(int)方法来获得或者修改布局。
3-完成了,现在你可以显示自定义的dialog了。
一个dialog必须有一个title,如果你没有调用setTitile()方法,那么会标题处会显示空,但dialog仍然可见,如果你不想显示标题,只有写一个自己的dialog类了。然而,因为一个AlertDialog使用AlertDialog.builder类创建起来非常简单,你不必使用setContextView(int)方法。但必须使用setView(view)方法代替。这个方法会接受一个view参数,你需要从xml中得到根view元素。
得到xml布局,通过LayoutInflater类的getLayoutflater()方法(或者getSystemService()方法),然后调用inflate(int,ViewGroup)方法,第一个参数是xml文件id,第二个参数是根view的id,在这点上,你可以使用inflated 布局来获得xml中的view对象并且定义ImageView和TextView对象,然后实例化AlertDialog.Builder类并且使用setView(View)方法来设置布局。
这有一个自定义dialog布局文件的例子:
[java] view plain copy
- AlertDialog.Builder builder;
- AlertDialog alertDialog;
- Context mContext = getApplicationContext();
- LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(LAYOUT_INFLATER_SERVICE);
- View layout = inflater.inflate(R.layout.custom_dialog,
- (ViewGroup) findViewById(R.id.layout_root));
- TextView text = (TextView) layout.findViewById(R.id.text);
- text.setText("Hello, this is a custom dialog!");
- ImageView image = (ImageView) layout.findViewById(R.id.image);
- image.setImageResource(R.drawable.android);
- builder = new AlertDialog.Builder(mContext);
- builder.setView(layout);
- alertDialog = builder.create();
使用自定义布局这种方式来生成dialog,可以让你使用更高级的特性,比如管理按钮、列表、标题、图标等。
UI事件的处理
在用户的交互中,有不止一种的方法来截获事件。考虑到在用户界面中的事件时,从特殊的与用户交互的view对象中捕获事件,View类提供了一些特殊的方法。
再各种的视图类中,你要编写自己的布局,你可以声明一些公共的回调方法来响应UI事件。当相应的动作发生时,这些方法会被android框架自动调用。例如,当一个view被触摸时,onTouchEvent()方法被调用。然而,为了截获这些方法,我们需要重写这些方法。当然了,重写每一个这样的方法显然时不实际的,这就是为什么为何view类会有一些必须的接口这样你可以更加容易的使用。这些接口,被称作事件监听器 event listeners,这就是捕捉到界面上用户操作的关键。
当你经常在用户交互上使用事件监听器时,有时需要自己写一个继承自view的类,来自定义一个部件。如果你想继承一个Button类来实现更多的功能,这种情况下,你可以借助event handlers 类来定义默认的事件处理类。
事件监听器
事件监听器是包含简单回调方法的view类的一个接口,当用户触发了一些注册过的事件时,android系统框架会自动调用相应的方法。
事件监听器包含以下几个方法:
onCLick()
来自View.onClickListener。 当view被触摸,或者焦点在view上时,用户按了确认键或导航键。
onLongClick()
来自 View.onLongClickListener。当view被触摸超过1秒,或者焦点在view上,用户按了确认或导航键超过1秒时,方法被调用。
onFocysChange()
来自 View.onFocusChangeListener。当焦点离开view时被调用。
onKey()
来自 View.onKeylistener。按下或者弹起某个键时方法被调用。
onTouch()
来自 View.OnTouchListener。当用户操作屏幕时被调用,包括按下释放或者其他的操作。
onCreateContextMenu()
来自 View.onCreateContextMenuListener。当一个Context Menu菜单被建立时调用。
这些方法都有自己的接口方法。如果想定义这些方法来处理自己的事件,只要在activity里面使用匿名类即可。然后使用View.setXXXListener()方法,将匿名类传递给view。
下面的例子演示了怎样给一个Button注册一个监听器:
[java] view plain copy
- // Create an anonymous implementation of OnClickListener
- private OnClickListener mCorkyListener = new OnClickListener() {
- public void onClick(View v) {
- // do something when the button is clicked
- }
- };
- protected void onCreate(Bundle savedValues) {
- ...
- // Capture our button from layout
- Button button = (Button)findViewById(R.id.corky);
- // Register the onClick listener with the implementation above
- button.setOnClickListener(mCorkyListener);
- ...
- }
你会发现让activity实现监听器接口是非常方便的,他可以让你的程序避免多余的对象分配。
[java] view plain copy
- public class ExampleActivity extends Activity implements OnClickListener {
- protected void onCreate(Bundle savedValues) {
- ...
- Button button = (Button)findViewById(R.id.corky);
- button.setOnClickListener(this);
- }
- // Implement the OnClickListener callback
- public void onClick(View v) {
- // do something when the button is clicked
- }
- ...
- }
注意,上面例子中的onClick()回调方法没有返回值,但其他的时间监听器必须返回一个boolean类型的返回值,这是由监听器的类型决定的,例如:
onLongClick()
这个方法会返回一个布尔值,来说明这个事件正在进行,也就是说,返回true表明此事件正在被处理不会被继续传递了。
onKey()
也会返回一个布尔值,返回true的话说明此按键事件将会被处理并不会被继续响应。如果你没有处理或者希望事件继续被其他监听器响应,那么返回false。
onTouch()
返回同上,也是返回true就不再被传递。重点是有很多类型的事件与这个事件有关,例如,当接收到键被按下的事件时,如果你此时返回false,那么表明你将不会处理这个按键事件。因此,你不会处理这个事件,例如手势或者其他后续事件。
记住这些按键事件总会让当前veiw成为当前焦点,他们从view层次结构的顶端开始被一级级传递,直到到达应该被响应的地方。如果你的view或者子view当前拥有焦点,那么你可以看到事件怎样传递到dispatchKeyEvent()方法。作为一种捕捉按键事件的替代方法,你可以接收activity里的所有的onKeyDown()和onKeyUp()事件。
注意:Android会首先调用事件处理程序,然后再调用自定义的事件处理类。例如:返回true将会阻止事件被继续传递给下一层,也会阻止系统做一些默认的处理,所以如果你确定要终止这个事件就返回true。
事件处理器
如果你创建了一个自定义的view组件,那么你要定义几种回调方法来。在Building Custom Components文档中,你会学习到以下几个回调事件:
onKeyDown(int,ketEvent);键被按下
onKeyUp(int,keyEvent);键弹起
onTrackballEvent(MotionEvent);轨迹球事件
onTouchEvent(MotionEvent);触摸屏幕事件
onFocusChanged(boolean,int,Rect);焦点改变事件
这里有一些你需要知道的方法,他们不是view类的一部分,但是会直接影响到你对事件的处理。所以遇到十分复杂的布局时,可以考虑以下的几个方法:
Activity.dispatchTouchEvent(MotionEvent)
它允许你的activity拦截所有的触摸事件
ViewGroup.onInterceptTouchEvent(MotionEvent)
允许VeiwGroup来观察子view的事件
ViewParent.requestDisallowInterceptTouchEvent(boolean)
告诉父View不应该使用相关方法来拦截事件。
触摸模式
当用户正在使用导航键或者轨迹球来与手机交互时,有必要给当前互动的item例如button一个焦点,来让用户看到接收输入、或者说当前的控件。如果一个设备支持触摸,那么操作时就不需要用上面的高亮显示的方式来告诉用户。因此,便有了这种触摸模式。对于有触摸功能的设备来说,一旦用户触摸了屏幕,设备便会进入触摸模式。只有那些isFocusableInTouchMode()返回true的控件才可以获得焦点,例如文本编辑框。别的view是touchable的,例如按钮,但被点击时不会显示焦点。当被按下时,他们的事件监听器将会无效。
任何时候用户点击了导航键或者轨迹球,设备都会退出touch模式,并且找一个view来显示焦点。现在,用户可以不用触摸屏幕来与设备进行交互了。
Touch模式存在于整个系统中。包括窗口和activity。可以用isinTouchMode()方法来查询当前模式。
焦点的处理
框架会处理常规的焦点改变事件来响应用户的输入。包括一些veiw的显示和隐藏。view通过isFocusable()方法来设定是否可以得到焦点。调用setFocusable()方法可以改变focusable状态。当view在触摸模式,你可以通过调用isFocusableInTouchMode()方法查询到是否支持,通过setFocusableInTouchMode()来设置。
焦点的运动是根据给定方向最近的一个view来确定的。在极少情况下,默认的这种算法或许不符合开发者预期的要求。这种情况下,可以通过xml来明确确定焦点的转移情况。例如:
[java] view plain copy
- <LinearLayout
- android:orientation="vertical"
- ... >
- <Button android:id="@+id/top"
- android:nextFocusUp="@+id/bottom"
- ... />
- <Button android:id="@+id/bottom"
- android:nextFocusDown="@+id/top"
- ... />
- </LinearLayout>
一般的,在垂直的布局里,往下或者往上移动轨迹球或是导航键多不能移动焦点,现在可以通过xml的定义来达到移动焦点的目的。
如果你想要声明可以获得焦点的view,可以在xml里添加android:focusable这个属性,设置为true,你也可以在Touch模式下添加android:focusableInTouchMode。
使用requestFocus()方法可以使一个特定的师徒取的焦点。
使用onFocusChange()方法来监听焦点事件。
更多推荐
Android学习笔记3
发布评论