Android基础知识(2)—事件处理

来源：互联网发布：守望网络初始化失败编辑：程序博客网时间：2024/05/22 03:10

阅读前，请浏览此处上方目录。

Android事件处理概述

本章内容为个人笔记，参考书籍有：《疯狂的android》第3版、《第一行代码》

　　我觉得应用程序需要处理最多的就是用户动作，也就是需要为用户动作提供响应，这种为用户动作提供响应的机制就是事件处理。Android提供了两套事件处理机制：

基于监听的事件处理：主要做法是为Android界面组件绑定特定的事件监听器；
基于回调的事件处理：主要做法是重写Android组件特定的回调方法或者重写Activity的回调方法；

一、基于监听的事件处理：

（一）监听的处理模型：

　　1.Event Source(事件源)：事件发生的组件；
　　2.Event(事件)：一次用户的操作；
　　3.Event Listener(事件监听器)：负责监听事件源发生的事件，并对各事件做出相应的响应；

　　（注：我举个例子来说明一下：当用户单击按钮或单击一个菜单项时，这些动作就会激发一个相应的事件，该事件就会触发事件源上已注册的事件监听器，事件监听器调用相应的事件处理器来做出相应的响应。）

（二）事件和事件监听器：

    1、事件源最容易创建，任意界面组件都可以作为事件源；
    2、事件的产生无需程序员关心，它是由系统自动产生；
    3、实现事件监听器是整个事件处理的核心；

（三）在程序中实现事件监听器，通常有以下几种形式：

　　第一种：内部类形式作为事件监听器
【实例】当单击按钮时，文本框内容改变

布局文件代码如下：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    xmlns:tools="http://schemas.android.com/tools"    android:layout_width="match_parent"    android:layout_height="match_parent"    tools:context="songsong.com.eventtest.Event_Qs">    <TextView        android:id="@+id/tv1"        android:layout_width="wrap_content"        android:layout_height="wrap_content" />    <Button        android:id="@+id/btn1"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="按钮" /></LinearLayout>

Java文件代码如下：

public class Event_Qs extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_event_qs);        Button button = (Button) findViewById(R.id.btn1);        button.setOnClickListener(new MyClickListener());    }    class MyClickListener implements View.OnClickListener {        @Override        public void onClick(View v) {            TextView textView = (TextView) findViewById(R.id.tv1);            textView.setText("按钮被单击了");        }    }}

　　第二种：匿名内部类形式作为事件监听器

大部分时候，事件处理器都没有什么复用价值，（可复用代码通常都被抽象成了业务逻辑方法），因此大部分事件监听器知识临时使用一次，所以使用匿名内部类形式的事件监听器更合适。实际上这种形式是目前使用最广泛的事件监听器。

public class Event_Qs extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_event_qs);        Button button = (Button) findViewById(R.id.btn1);                button.setOnClickListener(new View.OnClickListener() {            //实现事件处理方法            @Override            public void onClick(View v) {                TextView textView = (TextView) findViewById(R.id.tv1);                textView.setText("按钮被单击了");            }        });    }}

　　第三种：Activity本身作为事件监听器

这种形式使用Activity本身作为监听器类，可以直接在Activity类中定义时间处理器方法。这种形式非常简洁，但使用过程一定要注意程序结构。

public class Event_Qs extends Activity implements View.OnClickListener {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_event_qs);        Button btn1 = (Button) findViewById(R.id.btn1);        Button btn2 = (Button) findViewById(R.id.btn2);        btn1.setOnClickListener(this);        btn2.setOnClickListener(this);    }    @Override    public void onClick(View v) {        TextView textView = (TextView) findViewById(R.id.tv1);        switch (v.getId()){            case R.id.btn1:                textView.setText("按钮1被单击了");                break;            case R.id.btn2:                textView.setText("按钮2被单击了");                break;        }    }}

　　第四种：直接绑定到标签作为事件监听器

Android还有一种更简洁的绑定事件监听器方式，那就是直接在界面布局文件为指定标签绑定事件处理方法。

以下是布局文件代码：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    xmlns:tools="http://schemas.android.com/tools"    android:layout_width="match_parent"    android:layout_height="match_parent"    tools:context="songsong.com.eventtest.Event_Qs">    <TextView        android:id="@+id/tv1"        android:layout_width="wrap_content"        android:layout_height="wrap_content" />    <Button        android:id="@+id/btn1"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:onClick="btnclick"        android:text="按钮" /></LinearLayout>

java文件代码如下：

public class Event_Qs extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_event_qs);        Button btn1 = (Button) findViewById(R.id.btn1);    }//定义了一个事件处理方法 public void btnclick(View source) {        TextView textView = (TextView) findViewById(R.id.tv1);        textView.setText("按钮被单击了");    }}

上面程序中定义了一个btnclick(View source)方法，并在xml文件的按钮中添加了android:onClick="btnclick"的属性，当用户单击按钮时，该方法就会被激发并处理btn1按钮的单击事件。

二、基于回调的事件处理

正如文章开头所说基于回调的事件处理的主要做法是重写Android组件特定的回调方法或者重写Activity的回调方法，那么相对于基于监听事件处理来说，事件源与事件监听器就合为一体。或者说，事件监听器就消失了。

（一）回调与监听：

为了实现回调机制的事件处理，Android为所有GUI组件都提供了一些事件处理的回调方法，以View为例，该类包含如下方法。

1、boolean onKeyDown(int,KeyEvent)：当按下某组件时触发；
2、boolean onKeyLongPress(int,KeyEvent)：当长按某组件时触发；
3、boolean onKeyShortcut(int,KeyEvent)：当键盘快捷键事件发生时触发；
4、boolean onKeyUp(int,KeyEvent)：当组件上松开某个按键时触发；
5、boolean onKeyTouchEvent(event)：当用户在组件上触摸时触发；
6、boolean onTrackball(event)：当用户在组件上触发轨迹球事件时触发；

【实例】通过自定义View来实现基于回调的事件处理机制，自定义View时重写该View的事件处理方法。

public class MyButton extends Button {    public MyButton(Context context, AttributeSet attrs) {        super(context, attrs);    }    @Override    public boolean onKeyDown(int keyCode, KeyEvent event) {        super.onKeyDown(keyCode, event);        Log.v("songsong.com.eventtest", "The onkeydown in MyButton" );        return true;    }}

在上面自定义了MyButton类中，重写Button类的onKeyDown(int keyCode, KeyEvent event)方法。
接下来是在界面布局中使用自定义View：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    xmlns:tools="http://schemas.android.com/tools"    android:layout_width="match_parent"    android:layout_height="match_parent"    tools:context="songsong.com.eventtest.Event_Qs">        <songsong.com.eventtest.MyButton        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="按钮1" /></LinearLayout>

运行上面程序，先把焦点定位到该按钮上，接着单击模拟器上任意按钮就可以看到效果:

小结：

对于基于监听的事件处理模型来说，事件源和事件监听器是分离的。当事件源上发生特定事件时，该事件交给事件监听器负责处理；
对于基于回调的事件处理模型来说，事件源和事件监听器是统一的。当事件源发生特等事件时，该事件还是由事件源本身负责处理；

（二）基于回调的事件传播：

几乎所有基于回调的时间处理方法都有一个boolean类型的返回值，该返回值用于标识该处理方法是否能完全处理该事件：

如果处理事件的回调方法返回是true，表明该处理方法已经完成处理该事件，不会继续传播。
如果处理事件的回调方法返回是false，表明处理方法并未完全处理该事件，会继续传播。

【实例】分别在Activity中重写onKeyDown和Button类中重写onKeyDown，最后为按钮添加OnKeyListener处理OnKeyDown事件，返回值皆为false.

public class MyButton extends Button {    public MyButton(Context context, AttributeSet attrs) {        super(context, attrs);    }    @Override    public boolean onKeyDown(int keyCode, KeyEvent event) {        super.onKeyDown(keyCode, event);        Log.v("songsong.com.eventtest", "The onkeydown in MyButton");        return false;    }}

上面Mybutton子类重写了OnKeyDown，由于返回了false，事件还将继续传播。

public class Event_Qs extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_event_qs);        Button btn1 = (Button) findViewById(R.id.btn1);        btn1.setOnKeyListener(new View.OnKeyListener() {            @Override            public boolean onKey(View v, int keyCode, KeyEvent event) {                //只处理按下键的事件                if (event.getAction() == KeyEvent.ACTION_DOWN)                    Log.v("songsong.com.eventtest", "The onkeydown in OnKeyListener");                return false;//继续外传            }        });    }    @Override    public boolean onKeyDown(int keyCode, KeyEvent event) {        super.onKeyDown(keyCode, event);        Log.v("songsong.com.eventtest", "The onkeydown in Activity");        return false;    }

上面Activity中重写了OnKeyDown，为按钮添加OnKeyListener处理OnKeyDown事件，返回值皆为false。
效果图：

当事件在传播的过程，最先触发的是按钮上绑定的事件监听器，然后才触发组件提供的事件回调方法，最后才会传播到该组件所在的Activity。当然，如果返回值是true，那么就没然后了。

三、响应系统设置的事件：

开Android应用时，有时候可能要让应用程序随系统设置而进行调整，比如系统的屏幕方向、判断系统方向的导航设备等等，需要对系统设置的更改做出响应。

（一）Configuration类：

Configuration类专门用于描述手机设备上的配置信息，这些配置信息既包括用户特定的配置项，也包括系统的动态设置配置。

Configuration cf = getResources().getConfiguration();

当获取完Configuration对象就可以调用该对象提供的属性来取得系统配置信息：

1、public int KeyboardHidden：该属性返回布尔值来标识键盘是否可用，如果软键盘可用 KEYBOARDHIDDEN_NO，硬软键盘都不可用就YES；
2、public int mcc：获取移动信号的国家码；
3、public int mnc：获取移动信号的网络码；
4、public int navigation：判断系统上方向导航设备的类型；
5、public intorientation：获取系统屏幕的方向，ORIENTATION_LANDSCAPE (横向)，ORIENTATION_PORTRAIT(竖向)；
6、public inttouchscreen：获取系统触摸屏的触摸方式；

【实例】获取系统设备状态

首先定义4个文本框来显示系统信息，通过一个按钮触发。布局文件代码因为太简单以至于不贴出来了：

MainActivity.java代码内容：

public class ConfigurationTest extends Activity {    TextView ori, nav, touch, mnc;    Button btncg;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_configuration);        ori = (TextView) findViewById(R.id.ori);  //屏幕方向        nav = (TextView) findViewById(R.id.nav);  //方向导航设备类型        touch = (TextView) findViewById(R.id.touch);  //触摸方式        mnc = (TextView) findViewById(R.id.mnc);    //移动信号的网络码        btncg = (Button) findViewById(R.id.btncg);        btncg.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View v) {                Configuration cf = getResources().getConfiguration();                String ori_str = cf.orientation == Configuration.ORIENTATION_LANDSCAPE ? "横向屏幕" : "纵向屏幕";                String mnc_str = cf.mnc + "";                String nav_str = cf.navigation == Configuration.NAVIGATION_NONAV ? "没有方向控制" :                        cf.navigation == Configuration.NAVIGATION_WHEEL ? "滚轮控制方向" :                                cf.navigation == Configuration.NAVIGATION_DPAD ? "方向键控制方向" : "轨迹球控制方向";                String touch_str = cf.touchscreen == Configuration.TOUCHSCREEN_NOTOUCH ? "无触摸屏" : "支持触摸屏";                ori.setText(ori_str);                nav.setText(nav_str);                touch.setText(touch_str);                mnc.setText(mnc_str);            }        });    }}

效果如下：

（二）重写onConfigurationChanged方法响应系统设置：

如果想监听系统设置的更改，就可以重写Activity的onConfigurationChanged()方法，该方法是一个基于回调的事件处理方法：当系统设置发送更改时，该方法会被自动触发。

【实例】动态更改屏幕方向
布局文件中只有一个按钮，通过对单击按钮事件动态修改系统屏幕的方向。

public class Changecfg extends Activity {    Button btnchange;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_changecfg);        btnchange = (Button) findViewById(R.id.btnchange);        btnchange.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View v) {                Configuration cfg = getResources().getConfiguration();                if (cfg.orientation == Configuration.ORIENTATION_LANDSCAPE) {   //如果当前是横屏的话                    //设置为竖屏                    Changecfg.this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);                }                if (cfg.orientation == Configuration.ORIENTATION_PORTRAIT) {   //如果当前是竖屏的话                    //设置为横屏                    Changecfg.this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);                }            }        });    }    @Override    public void onConfigurationChanged(Configuration newConfig) {   //用于监听系统设置的更改        super.onConfigurationChanged(newConfig);        String screen = newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE ? "横屏" : "竖屏";        Toast.makeText(this, "当前屏幕方向为：" + screen, Toast.LENGTH_SHORT).show();    }}

在运行之前还要在配置Activity时加上 android:configChanges="orientation|screenSize"，为了就是要监听屏幕方向改变的事件。

 <activity            android:name=".Changecfg"            android:configChanges="orientation|screenSize"            android:label="@string/title_activity_changecfg">            <intent-filter>                <action android:name="android.intent.action.MAIN" />                <category android:name="android.intent.category.LAUNCHER" />            </intent-filter>        </activity>

效果：

四、Handler消息传递机制：

出于性能优化的考虑，Android制定了一条简单的规则：只允许UI线程修改Activity里的UI组件。这样的话就会导致新启动的线程无法动态改变界面组件的属性值，但在实际开发中，尤其是涉及动画的游戏开发中，想要新启动的线程周期性的改变界面组件的属性值就要借助Handler的消息传递机制实现了。

（一）Handler类简介：

根据书上所说，Handler类的主要作用有两个：

在新启动的线程中发送消息；
在主线程中获取、处理消息；

那么我们要解决的问题就是：

新启动的线程何时发送消息？
主线程何时去获取并处理消息？

显然，我们这章节的内容是事件处理，那么我们通过回调的方式来实现。开发者只需重写Handler类中处理消息的方法，当新启动的线程发送消息时，消息会发送到与之关联的MessageQueue，而Handler会不断地从MessageQueue中获取并处理消息。

Handler类包含如下方法用于发送、处理消息：

void handleMessage(Message msg) ：进程通过重写这个方法来处理消息。
final boolean hasMessage(int what)：检查消息队列中是否包含what属性为指定值的消息。
final boolean hasMessage(int what,Object object)：检查消息队列中是否有指定值和指定对象的消息。
Message obtainMessage()：获取消息，可被多种方式重载。
sendEmptyMessage(int what): 发送空消息；
final boolean sendEmptyMessageDelayed(int what, long delayMillis)：指定多少毫秒之后发送空消息。
final boolean sendMessage(Message msg)：立即发送消息。
final boolean sendMessageDelayed(Message msg, long delayMillis)：指定多少毫秒之后发送空消息

【实例】自动播放图片
通过一个新的线程来周期性地修改ImageVIew所显示的图片，布局文件中只定义了ImageVIew组件。

public class HandlerTest extends Activity {    int[] imagesID = new int[]{            R.drawable.a1,            R.drawable.a2,            R.drawable.a3,            R.drawable.a4,    };    int currentImageID = 0;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_handler_test);        final ImageView show = (ImageView) findViewById(R.id.iv1);        final Handler handler = new Handler() {            @Override            public void handleMessage(Message msg) {                super.handleMessage(msg);                if (msg.what == 0x1233) {                    show.setImageResource(imagesID[currentImageID++ % imagesID.length]); //动态修改所显示的图片                }            }        };        new Timer().schedule(new TimerTask() {            @Override            public void run() {                handler.sendEmptyMessage(0x1233);  //发送空消息            }        }, 0, 1200);    }}

上面程序中的代码通过Timer周期性地执行指定任务。由于Android 不允许在新线程中访问Activity里的界面组件，因此程序只能在新的线程里发送一条消息，通知系统更新ImageView组件。

（二）深入理解Handler的工作机制：

为了更好理解Handler的工作原理，先了解与Handler一起工作的几个组件：

Looper：每个线程只有一个Looper，它负责管理MessageQueue，会不断的从MessageQueue中取出消息，并将消息分给对应的Handler处理。
MessageQueue：由Looper负责管理，它采用先进先出FIFO的方式来管理Message。
Handler：它能把消息发给Looper管理的MessageQueue，并负责处理Looper分给它的消息。
Message：Handler接收和处理的消息对象。

以下是工作流程图：

在线程中使用Handler的步骤如下：

调用Looper的prepare()方法为当前线程创建Looper对象，创建Looper对象时，它的构造器会自动创建配套的MessageQueue。
有了Looper之后，创建Handler子类的实例，重写handleMessage()方法。
调用Looper的loop()方法启动Looper。

【实例】在线程中计算质数

为了防止在UI线程中执行一个耗时的操作，而导致UI线程被阻塞，令应用程序失去响应，让新线程来计算该数值范围内的所有质数。

import android.app.Activity;import android.os.Handler;import android.os.Looper;import android.os.Message;import android.os.Bundle;import android.view.View;import android.widget.EditText;import android.widget.Toast;import java.util.ArrayList;import java.util.List;public class Handler_Looper extends Activity {    static final String UPPER_NUM = "upper";    EditText etNum;    CalThread calThread;    // 定义一个线程类    class CalThread extends Thread {        public Handler myhandler;        public void run() {            Looper.prepare();   //创建Looper对象            myhandler = new Handler() {                @Override                public void handleMessage(Message msg) {                    super.handleMessage(msg);                    if (msg.what == 0x123) {                        int upper = msg.getData().getInt(UPPER_NUM);                        List<Integer> nums = new ArrayList<Integer>();                        outer:                        for (int i = 2; i <= upper; i++) {                            for (int j = 2; j <= Math.sqrt(i); j++) {                                if (i != 2 && i % j == 0) {                                    continue outer;                                }                            }                            nums.add(i);                        }                        Toast.makeText(Handler_Looper.this, nums.toString(), Toast.LENGTH_LONG).show();                    }                }            };            Looper.loop();        }    }    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_handler__looper);        etNum = (EditText) findViewById(R.id.et1);        calThread = new CalThread();        calThread.start();    }    public void cal(View v) {        Message msg = new Message();        msg.what = 0x123;        Bundle bundle = new Bundle();        bundle.putInt(UPPER_NUM,Integer.parseInt(etNum.getText().toString()));        msg.setData(bundle);        calThread.myhandler.sendMessage(msg);    }}