Android的事件处理

时间 2019-11-10

原文原文链接

1 android事件处理概述　　html

　　不管是桌面应用仍是手机应用程序，面对最多的就是用户，常常须要处理用户的动做-------也就是须要为用户动做提供响应，这种为用户动做提供响应的机制就是事件处理。android提供了两套事件处理机制：java

基于监听的事件处理

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

基于回调的事件处理

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

2 基于监听的事件处理编程

2.1 监听的处理模型安全

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

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

2.1.2 事件处理流程图多线程

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

获取普通界面组件的对象（事件源），即被监听对象
实现事件监听器类，该监听器类是一个特殊的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>

View Code

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;
    }
}

View Code

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>

View Code

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();
    }
}

View Code

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);
            }
        });

    }

}

View Code

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();
                }
            }
        });

    }

}

View Code