Android的事件处理

1 android事件处理概述　　

　　不论是桌面应用还是手机应用程序，面对最多的就是用户，经常需要处理用户的动作-------也就是需要为用户动作提供响应，这种为用户动作提供响应的机制就是事件处理。android提供了两套事件处理机制：

• 基于监听的事件处理

　　主要做法就是为Android界面组件绑定特定的事件监听器；android还允许在界面布局文件中为UI组件的android:onClick属性指定事件监听方法，该方式需要开发者在activity中定义该事件监听方法（该方法必须带有一个View类型的形参，该形参代表被单击的UI组件，当用户单击该组件时，系统将会激发android:onClick属性所指定的方法）

• 基于回调的事件处理

主要做法是重写android组件特定的回调方法，或者重写Activity的回调方法。（基于回调的事件处理可以用于处理一些具有通用性的事件（业务逻辑比较固定），某些特定事件处理，仍需事件监听机制。）

2 基于监听的事件处理

2.1 监听的处理模型

2.1.1 事件监听的处理模型中，主要涉及如下三类对象

• Event Source（事件源）：事件发生场所，通常是指各个组件，如按钮、窗口、菜单等
• Event（事件）：事件封装了界面组件上发生的特定事情，Event包含所发生事件的相关信息
• Event Listener（事件监听器）：负责监听事件源所相关事件的发生，并对并对发生事件作出反应

2.1.2 事件处理流程图

　　

2.1.3 基于监听的时间处理模型的编程步骤

• 获取普通界面组件的对象（事件源），即被监听对象
• 实现事件监听器类，该监听器类是一个特殊的java类，必须实现一个xxxListener接口
• 调用事件源的setXxxListener方法将监听对象注册给事件源

2.2 内部类作为事件监听器类

• 可以在当前父类中复用该监听器
• 可自由访问外部类的所有界面组件

2.3 外部类作为事件监听器类

2.3.1 该形式比较少见，主要有两点原因：

• 事件监听器对应于具体的组件，定义成外部类，不利于提高程序的内聚性
• 外部类不能够自由访问创建GUI界面类的组件，编程不够简洁

2.3.2 若某个监听器需要被多个GUI界面组件所共享，且主要是完成某种业务逻辑的实现，则可考虑外部类的形式

2.4 Activity本身作为监听器

　　直接用Activity本身作为监听器类，这种形式非常简洁，但这种做法有两个缺陷：

• 这种程序结构可能造成混乱，Activity的主要职责应该是完成界面初始化工作
• Activity类本身还要实现监听接口，显得结构臃肿

2.5 匿名内部类作为事件监听器

• 由于大部分时候事件处理器都没有什么复用价值，因此大部分都是一次性使用，故造成此方法为最常用方法

2.6 直接绑定到标签

• 该方法结构简洁
• 但是结构也相对比较固定，适用范围有限（只支持onClick）

3 基于回调的事件处理

3.1 回调机制与监听机制

• 事件监听机制是一种委托式的事件处理，事件源和事件监听器分离，事件源发生器特定的事件后，该事件交给事件监听器负责处理
• 基于回调的事件模型来说，事件源与事件监听器是统一的，事件发生后，还是又事件源本身负责处理
• 为了使组件自身处理事件，则必须为组件对象添加方法，方法无法动态添加，故预置处理接口，继承重写方法即可

3.2 android为所有GUI组件都提供了一些事件处理的回调方法，以View为例，该类包含以下方法：

• onKeyDown，当用户在该组件上按下某个按键时触发该方法
• onKeyLongPress，当用户在组件上长按某个按键时触发该方法
• onKeyShortcut，当一个键盘快捷事件发生时触发该方法
• onKeyUp，当用户在该组件上松开某个按钮时触发该方法
• onTouchEvent ，当用户在该组件上触发触摸屏事件时触发该方法
• onTrackballEvent，当用户在该组件上触发轨迹球屏事件时触发该方法

3.3 基于回调的事件传播

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

• 如果处理事件的回调方法返回true，表明该处理方法已经完全处理该事件，该事件不会传播出去
• 如果处理时间的回调方法返回false，则表明处理方法并未完全处理事件，该事件会传播出去，
• 事件触发顺序为：事件源监听处理器---->事件源本身回调函数----->事件源父组件（递归而上）

3.4 两种处理模型的区别

• 基于监听的事件模型分工更明确，事件源、事件监听分别有两个类分开实现，因此具有更好的可维护性
• Android的事件处理机制保证基于监听的事件监听器会被优先触发

3.5 示例

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:gravity="center_horizontal">

    <EditText
        android:id="@+id/address"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:hint="请填写收信号码"
        />
    <EditText
        android:id="@+id/content"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:hint="请填写短信内容"
        android:lines="3"
        />
    <com.example.penghuster.myfirstapp.MyButton
        android:id="@+id/send"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="发送" />

</LinearLayout>

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

public class MainActivity extends Activity {
    EditText address;
    EditText content;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        address = (EditText) findViewById(R.id.address);
        content = (EditText) findViewById(R.id.content);
        MyButton btn = (MyButton) findViewById(R.id.send);
        btn.requestFocus();
        btn.setFocusableInTouchMode(true);

        btn.setOnKeyListener(new View.OnKeyListener() {
            public boolean onKey(View source, int value, KeyEvent event) {
                if (event.getAction() == KeyEvent.ACTION_DOWN) {
                    Log.v("--Listener--", "the keydown ");
                }
                return false;
            }
        });

    }

    public boolean onKeyDown(int keyCode, KeyEvent event){
        super.onKeyDown(keyCode, event);
        Log.v("--activity---", "ddd");
        return false;
    }
}

class MyButton extends Button{
    public MyButton(Context context, AttributeSet set){
        super(context, set);
    }

    public boolean onKeyDown(int keyCode, KeyEvent event){
        super.onKeyDown(keyCode, event);
        Log.v("MyButton", "the onKeyDown in MyButton");
        return  false;
    }
}

4 响应系统设置的事件

　　在开发Android应用时，有时可能需要让应用程序随系统设置而进行调整，比如判断屏幕方向、判断系统方向的方向导航设备等。除此之外，有时还需要让应用程序监听系统设置的更改，并作出响应。

4.1 Configuration类

4.1.1 简介

• Configuration类专门用于描述手机设备上的配置信息，包括用户特定的配置项、系统的动态配置
• Configuration类的对象构建：Configuration cfg = Activity.getResources().getConfiguration()
• Configuration对象提供常用的获取系统配置信息的属性：
  • public float fontScale:获取当前用户设置的字体缩放因子
  • public int keyboard：获取当前设备所关联的键盘类型。该属性可能返回如下值：KEYBOARD_NOKEYS/KEYBOARD_QWERTY/KEYBOARD_12KEY
  • public int keyboardHidden:该属性返回一个boolean值用于标识当前键盘是否可用。该属性不仅判断系统的硬件键盘、也判断系统的软键盘。如果该系统的硬件键盘不可用，软件键盘可用，也会返回KEYBOARDHIDDEN_NO;只有当两者都不可用用时，才返回KEYBOARDHIDDEN_YES
  • public Locale locale：获取当前用户的Local，国家地区
  • public int mcc：获取移动信号的国家码
  • public int mnc:获取移动信号的网络码
  • public int navigation:判断系统上方向导航设备的类型。该属性可能返回值：NAVIGATION_NONAV(无导航)、NAVIGATION_DPAD(DPOR导航)、NAVIGATION_TRACKBALL(轨迹球导航)、NAVIGATION_WHEEL(滚轮导航)
  • public int orientation：获取系统屏幕的方向，该属性可能返回值ORIENTATION_LANDSCAPE(横向屏幕)、ORIENTATION_PORTRAIT(竖向屏幕)、ORIENTATION_SQUARE(方形屏幕)
  • public int touchscreen：获取系统触摸屏的触摸方式，该属性可能返回TOUCHSCREEN_NOTOUCH(无触摸屏)、TOUCHSCREEN_STYLUS(触摸笔式触摸屏)、TOUCHSCREEN_FINGER(接受手指的触摸屏)

4.1.2 重写onConfigurationChanged响应系统设置更改

　　如果程序需要监听系统设置的更改，则可以考虑重写Activity的onConfiguration（Configuration newConfig）方法，该方法是一个基于回调的事件处理方法，当系统设置发生更改时，该方法会被自动触发。在程序中，可以动态调用setRequestedOrientation(int)方法来修改屏幕方向

4.1.3 示例：监听屏幕方向改变

Mainfest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.penghuster.myfirstapp" >

    <uses-sdk
        android:maxSdkVersion="12"
        android:minSdkVersion="10" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:configChanges="orientation|screenSize"
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

activity.java

import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.os.Bundle;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class MainActivity extends Activity {
    EditText address;
    EditText content;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        address = (EditText) findViewById(R.id.address);
        content = (EditText) findViewById(R.id.content);
        MyButton btn = (MyButton) findViewById(R.id.send);

        btn.setOnClickListener(new View.OnClickListener() {
            public void onClick(View source) {
                Configuration cfg = getResources().getConfiguration();

                if (cfg.orientation == Configuration.ORIENTATION_LANDSCAPE)
                    MainActivity.this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

                if (cfg.orientation == Configuration.ORIENTATION_PORTRAIT)
                    MainActivity.this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

            }
        });

    }

    public void onConfigurationChanged(Configuration configuration) {
        super.onConfigurationChanged(configuration);
        String screen = configuration.orientation == Configuration.ORIENTATION_LANDSCAPE ?
                "横向屏幕" : "竖向屏幕";
        Toast.makeText(this, "系统屏幕方向改变\n" + "修改后屏幕方向为：" + screen, Toast.LENGTH_LONG).show();
    }
}

5 Handler消息传递机制

5.1 UI线程

• Android的UI操作并不是线程安全的，多线程操作可能导致线程安全
• android制定一条简单的规则：只允许UI线程修改Activity里的UI组件
• UI线程：当一个程序第一次启动时，Android会同时启动一条主线程（main thread），负责处理与UI相关的事件，并把相关的事件分发到对应的组件进行处理
• 问题：由于只允许UI线程修改Activity里的组件，导致新启动的线程无法动态改变界面组件的属性值，但实际开发中，往往需要让新启动的线程周期性地改变界面组件的属性值，这就需要借助Handler的消息传递机制

5.2 Handler类简介

5.2.1 Handler类的主要作用

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

5.2.2 handler类消息处理原理

• 通过回调方式来实现，重写Handler类中处理消息的方法
• 新线程的发送消息时，消息会发送到与之关联的MessageQueue
• Handler会不断从MessageQueue中获取并处理消息

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

• void handlerMessage(Message msg)：处理消息的方法，该方法通常用于被重写
• final boolean hasMessages(int what, Object object)：检查消息队列中是否包含what属性为指定值且object属性为指定对象的消息
• 多个重载的Message obtainMessage():获取消息
• final boolean sendEmptyMessageDelayed(int what, long delayMillis)：指定多少毫秒后发送空消息 　　
• final boolean sendMessage(Message msg):立即发送消息
• final boolean sendMessageDelayed(Message msg, long delayMillis)：指多少毫秒之后发送消息

5.3 Handler、Loop、MessageQueue的工作原理

5.3.1 相关组件介绍

• Message：Handle接收和处理的消息对象
• Looper：每个线程只能拥有一个Looper，其loop方法负责读取MessageQueue中的消息，读到消息之后会把消息交给发送该消息的Handler进行处理。Looper的构造器使用private修饰，表明程序员无法通过构造器创建Looper对象
• MessageQueue：消息队列，采用先进先出的方式管理Message。程序创建Looper对象时，会在他的构造器中创建Looper对象。

5.3.2 Looper对象的创建

　　由于Looper对象没有提供public构造器，但是Handler正常工作，必须要求当前线程中有一个Looper对象，为了保证当前线程中有Looper对象，可分以下两种情况：

• 主UI线程中，系统已经初始化了一个Looper对象，因此程序直接创建Handler即可，让后通过Handler来发送、处理消息
• 程序员自己启动的子线程，程序员必须自己调用Looper类的静态方法repare()创建一个Looper对象，并启动它

5.3.3 在新线程中使用Handler的步骤：

• 调用Looper的prepare()方法为当前线程创建Looper对象，创建Looper对象时，它的构造器会创建与之配套的MessageQueue
• 有了Looper之后，创建Handler子类的实例，重写HandleMessage()方法，该方法负责处理来自其他线程的消息
• 调用Looper的loop()方法启动Looper

5.3.4 示例：使用新线程计算质数

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends Activity {
    EditText address;
    EditText content;
    static final String UPPER_NUM = "upper";
    CalThread calThread;

    class CalThread extends Thread {
        public Handler mHandler;
        public void run(){
            Looper.prepare();
            mHandler = new Handler(){
                public void handleMessage(Message 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(MainActivity.this, nums.toString(), Toast.LENGTH_LONG).show();
                    }
                }
            };
            Looper.loop();
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        address = (EditText) findViewById(R.id.address);
        content = (EditText) findViewById(R.id.content);
        MyButton btn = (MyButton) findViewById(R.id.send);

        calThread = new CalThread();
        calThread.start();

        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Message msg = new Message();
                msg.what = 0x123;
                Bundle bundle = new Bundle();
                bundle.putInt(UPPER_NUM, Integer.parseInt(address.getText().toString()));
                msg.setData(bundle);
                calThread.mHandler.sendMessage(msg);
            }
        });

    }

}

6 异步任务

6.1 为了解决新线程不能更新UI组件的问题，android提供了如下几种解决方案。

• 使用Handler实现线程之间的通信
• Activity.runOnUiThread(Runnable)
• View.post(Runnable)
• View.postDelayed(Runnable, long)
• AsyncTask异步任务

6.2 AsyncTask(异步任务)

• AsyncTask<>是一个抽象类，通常用于被继承，继承AsyncTask需要指定如下三个泛型参数：Params，启动任务执行的输入参数类型；Progress，后台任务完成的进度值的类型；Result，后台任务执行完成后返回的结果类型

6.3 使用AsyncTask的步骤：

• 创建AsyncTask的子类，并为三个泛型参数指定类型，如果某个参数不需要，则指定为Void
• 根据需要选择性实现如下方法
  • doInBackground(Params):重写该方法就是后台线程将要完成的任务，该方法可以调用publishProgress（Progress values）方法更新任务执行进度
  • onProgressUpdate（Progress values）在doInBackground中调用publishProgress更新进度后，将会触发该方法
  • onPreExecute():该方法将在执行后台耗时操作前被调用，通常该方法用于完成一些初始化的准备工作，比如在界面上显示进度条等
  • onPostExecute（Result result）：该方法在doInBackground（）完成后，系统自动调用，并将doInBackground的返回值传给Result参数
• 调用AsyncTask子类实例的execute（）开始执行耗时任务

6.4 使用AsyncTask时必须遵守如下规则

• 必须在UI线程中创建AsyncTask的实例
• 必须在UI线程中调用AsyncTask的execute方法
• doInBackground(Params)，onProgressUpdate（Progress values），onPreExecute()，onPostExecute（Result result）等方法都是由系统负责调用
• 每个AsyncTask只能被执行一次，多次调用将会引发异常

6.5 示例：使用异步任务下载

import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;

public class MainActivity extends Activity {
    TextView address;
    TextView content;

    class DownTask extends AsyncTask<URL, Integer, String> {
        ProgressDialog pDialog;
        int hasRead = 0;
        Context mContext;

        public DownTask(Context ctx) {
            mContext = ctx;
        }

        protected String doInBackground(URL... params) {
            StringBuilder sb = new StringBuilder();
            try {
                URLConnection conn = params[0].openConnection();
                BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(),
                        "utf-8"));
                String line = null;
                while ((line = br.readLine()) != null) {
                    sb.append(line + "\n");
                    hasRead++;
                    publishProgress(hasRead);
                }

                return sb.toString();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            return null;
        }

        protected void onPostExecute(String result) {
            address.setText(result);
            pDialog.dismiss();
        }

        protected void onPreExecute() {
            pDialog = new ProgressDialog(mContext);
            pDialog.setTitle("任务执行中");
            pDialog.setMessage("任务执行中，敬请期待");
            pDialog.setCancelable(false);
            pDialog.setMax(202);
            pDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
            pDialog.setIndeterminate(true);
            pDialog.show();
        }

        protected void onProgressUpdate(Integer... values) {
            content.setText("已经读取了" + values[0] + "行！");
            pDialog.setProgress(values[0]);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        address = (TextView) findViewById(R.id.address);
        content = (TextView) findViewById(R.id.content);
        MyButton btn = (MyButton) findViewById(R.id.send);

        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    DownTask task = new DownTask(MainActivity.this);
                    task.execute(new URL("http://www.cnblogs.com/renqingping/archive/2012/10/25/Parcelable.html"));
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        });

    }

}