onkeydown事件的作用 简述android_android onkeydown事件 - CSDN
  • public boolean onKeyDown(int keyCode, KeyEvent event); 第一个参数是用户按下键时,当前所接收到的按键代号; 第二个参数是按键事件的对象。 使用方法: 如果要使用这个方法。直接在主 acivity 中重写即可...

    函数原型:

    public boolean onKeyDown(int keyCode, KeyEvent event);

    第一个参数是用户按下键时,当前所接收到的按键代号;

    第二个参数是按键事件的对象。

     

    使用方法:

          如果要使用这个方法。直接在主 acivity 中重写即可,一般使用开关语句 switch 来把keyCode 和 (event.按键类型) 对比来执行对应的操作。

    下面我们来看下event 的按键属性都有哪些。

          在上面的函数中,按住control 加 鼠标左键点击 KeyEvent,就可以点进去看到很多东西。

      1 public class KeyEvent extends InputEvent implements Parcelable {
      2     /** Key code constant: Unknown key code. */
      3     public static final int KEYCODE_UNKNOWN         = 0;
      4     /** Key code constant: Soft Left key.
      5      * Usually situated below the display on phones and used as a multi-function
      6      * feature key for selecting a software defined function shown on the bottom left
      7      * of the display. */
      8     public static final int KEYCODE_SOFT_LEFT       = 1;
      9     /** Key code constant: Soft Right key.
     10      * Usually situated below the display on phones and used as a multi-function
     11      * feature key for selecting a software defined function shown on the bottom right
     12      * of the display. */
     13     public static final int KEYCODE_SOFT_RIGHT      = 2;
     14     /** Key code constant: Home key.
     15      * This key is handled by the framework and is never delivered to applications. */
     16     public static final int KEYCODE_HOME            = 3;
     17     /** Key code constant: Back key. */
     18     public static final int KEYCODE_BACK            = 4;
     19     /** Key code constant: Call key. */
     20     public static final int KEYCODE_CALL            = 5;
     21     /** Key code constant: End Call key. */
     22     public static final int KEYCODE_ENDCALL         = 6;
     23     /** Key code constant: '0' key. */
     24     public static final int KEYCODE_0               = 7;
     25     /** Key code constant: '1' key. */
     26     public static final int KEYCODE_1               = 8;
     27     /** Key code constant: '2' key. */
     28     public static final int KEYCODE_2               = 9;
     29     /** Key code constant: '3' key. */
     30     public static final int KEYCODE_3               = 10;
     31     /** Key code constant: '4' key. */
     32     public static final int KEYCODE_4               = 11;
     33     /** Key code constant: '5' key. */
     34     public static final int KEYCODE_5               = 12;
     35     /** Key code constant: '6' key. */
     36     public static final int KEYCODE_6               = 13;
     37     /** Key code constant: '7' key. */
     38     public static final int KEYCODE_7               = 14;
     39     /** Key code constant: '8' key. */
     40     public static final int KEYCODE_8               = 15;
     41     /** Key code constant: '9' key. */
     42     public static final int KEYCODE_9               = 16;
     43     /** Key code constant: '*' key. */
     44     public static final int KEYCODE_STAR            = 17;
     45     /** Key code constant: '#' key. */
     46     public static final int KEYCODE_POUND           = 18;
     47     /** Key code constant: Directional Pad Up key.
     48      * May also be synthesized from trackball motions. */
     49     public static final int KEYCODE_DPAD_UP         = 19;
     50     /** Key code constant: Directional Pad Down key.
     51      * May also be synthesized from trackball motions. */
     52     public static final int KEYCODE_DPAD_DOWN       = 20;
     53     /** Key code constant: Directional Pad Left key.
     54      * May also be synthesized from trackball motions. */
     55     public static final int KEYCODE_DPAD_LEFT       = 21;
     56     /** Key code constant: Directional Pad Right key.
     57      * May also be synthesized from trackball motions. */
     58     public static final int KEYCODE_DPAD_RIGHT      = 22;
     59     /** Key code constant: Directional Pad Center key.
     60      * May also be synthesized from trackball motions. */
     61     public static final int KEYCODE_DPAD_CENTER     = 23;
     62     /** Key code constant: Volume Up key.
     63      * Adjusts the speaker volume up. */
     64     public static final int KEYCODE_VOLUME_UP       = 24;
     65     /** Key code constant: Volume Down key.
     66      * Adjusts the speaker volume down. */
     67     public static final int KEYCODE_VOLUME_DOWN     = 25;
     68     /** Key code constant: Power key. */
     69     public static final int KEYCODE_POWER           = 26;
     70     /** Key code constant: Camera key.
     71      * Used to launch a camera application or take pictures. */
     72     public static final int KEYCODE_CAMERA          = 27;
     73     /** Key code constant: Clear key. */
     74     public static final int KEYCODE_CLEAR           = 28;
     75     /** Key code constant: 'A' key. */
     76     public static final int KEYCODE_A               = 29;
     77     /** Key code constant: 'B' key. */
     78     public static final int KEYCODE_B               = 30;
     79     /** Key code constant: 'C' key. */
     80     public static final int KEYCODE_C               = 31;
     81     /** Key code constant: 'D' key. */
     82     public static final int KEYCODE_D               = 32;
     83     /** Key code constant: 'E' key. */
     84     public static final int KEYCODE_E               = 33;
     85     /** Key code constant: 'F' key. */
     86     public static final int KEYCODE_F               = 34;
     87     /** Key code constant: 'G' key. */
     88     public static final int KEYCODE_G               = 35;
     89     /** Key code constant: 'H' key. */
     90     public static final int KEYCODE_H               = 36;
     91     /** Key code constant: 'I' key. */
     92     public static final int KEYCODE_I               = 37;
     93     /** Key code constant: 'J' key. */
     94     public static final int KEYCODE_J               = 38;
     95     /** Key code constant: 'K' key. */
     96     public static final int KEYCODE_K               = 39;
     97     /** Key code constant: 'L' key. */
     98     public static final int KEYCODE_L               = 40;
     99     /** Key code constant: 'M' key. */
    100     public static final int KEYCODE_M               = 41;
    101     /** Key code constant: 'N' key. */
    102     public static final int KEYCODE_N               = 42;
    103     /** Key code constant: 'O' key. */
    104     public static final int KEYCODE_O               = 43;
    105     /** Key code constant: 'P' key. */
    106     public static final int KEYCODE_P               = 44;
    107     /** Key code constant: 'Q' key. */
    108     public static final int KEYCODE_Q               = 45;
    109     /** Key code constant: 'R' key. */
    110     public static final int KEYCODE_R               = 46;
    111     /** Key code constant: 'S' key. */
    112     public static final int KEYCODE_S               = 47;
    113     /** Key code constant: 'T' key. */
    114     public static final int KEYCODE_T               = 48;
    115     /** Key code constant: 'U' key. */
    116     public static final int KEYCODE_U               = 49;
    117     /** Key code constant: 'V' key. */
    118     public static final int KEYCODE_V               = 50;
    119     /** Key code constant: 'W' key. */
    120     public static final int KEYCODE_W               = 51;
    121     /** Key code constant: 'X' key. */
    122     public static final int KEYCODE_X               = 52;
    123     /** Key code constant: 'Y' key. */
    124     public static final int KEYCODE_Y               = 53;
    125     /** Key code constant: 'Z' key. */
    126     public static final int KEYCODE_Z               = 54;
    127     /** Key code constant: ',' key. */
    128     public static final int KEYCODE_COMMA           = 55;
    129     /** Key code constant: '.' key. */
    130     public static final int KEYCODE_PERIOD          = 56;
    131     /** Key code constant: Left Alt modifier key. */
    132     public static final int KEYCODE_ALT_LEFT        = 57;
    133     /** Key code constant: Right Alt modifier key. */
    134     public static final int KEYCODE_ALT_RIGHT       = 58;
    135     /** Key code constant: Left Shift modifier key. */
    136     public static final int KEYCODE_SHIFT_LEFT      = 59;
    137     /** Key code constant: Right Shift modifier key. */
    138     public static final int KEYCODE_SHIFT_RIGHT     = 60;
    139     /** Key code constant: Tab key. */
    140     public static final int KEYCODE_TAB             = 61;
    141     /** Key code constant: Space key. */
    142     public static final int KEYCODE_SPACE           = 62;
    143     /** Key code constant: Symbol modifier key.
    144      * Used to enter alternate symbols. */
    145     public static final int KEYCODE_SYM             = 63;
    146     /** Key code constant: Explorer special function key.
    147      * Used to launch a browser application. */
    148     public static final int KEYCODE_EXPLORER        = 64;
    149     /** Key code constant: Envelope special function key.
    150      * Used to launch a mail application. */
    151     public static final int KEYCODE_ENVELOPE        = 65;
    152     /** Key code constant: Enter key. */
    153     public static final int KEYCODE_ENTER           = 66;
    154     /** Key code constant: Backspace key.
    155      * Deletes characters before the insertion point, unlike {@link #KEYCODE_FORWARD_DEL}. */
    156     public static final int KEYCODE_DEL             = 67;
    157     /** Key code constant: '`' (backtick) key. */
    158     public static final int KEYCODE_GRAVE           = 68;
    159     /** Key code constant: '-'. */
    160     public static final int KEYCODE_MINUS           = 69;
    161     /** Key code constant: '=' key. */
    162     public static final int KEYCODE_EQUALS          = 70;
    163     /** Key code constant: '[' key. */
    164     public static final int KEYCODE_LEFT_BRACKET    = 71;
    165     /** Key code constant: ']' key. */
    166     public static final int KEYCODE_RIGHT_BRACKET   = 72;
    167 .
    168 .
    169 .
    170 .
    171 .
    172 下面还很多...

    根据英语的提示,我们可以很容易地识别出,这些按键的类型,下面举个例子;

    1 @Override
    2  2     public boolean onKeyDown(int keyCode, KeyEvent event) {
    3  3         // TODO Auto-generated method stub
    4  4         
    5  5         if(keyCode==KeyEvent.KEYCODE_BACK){//back,返回键
    6  6             Toast.makeText(this,"你按了返回键",LENGTH_LONG).show();
    7 33         }
    8 35         return super.onKeyDown(keyCode, event);
    9 36     }

     

    上面是简单的一个按键时间。一般要处理很多事件的时候,用 switch - case

     

     1 @Override
     2     public boolean onKeyDown(int keyCode, KeyEvent event) {
     3         // TODO Auto-generated method stub
     4         if(event.getRepeatCount()==0) {//限制重复次数,防止用户过多点击
     5             switch(keyCode) {
     6                 case KeyEvent.KEYCODE_SEARCH:
     7 
     8                     break;
     9                 case KeyEvent.KEYCODE_CAMERA:
    10 
    11                     break;
    12                 case KeyEvent.KEYCODE_DPAD_CENTER:
    13 
    14                     break;
    15 
    16                 default:
    17                     break;
    18             }
    19         }
    20         return super.onKeyDown(keyCode, event);
    21     }

     

    转载于:https://www.cnblogs.com/linguanh/p/4431751.html

    展开全文
  • Android事件处理

    2017-12-15 19:38:44
    (一)基于回调的事件处理 事件事件 ... 实现事件监听的四种形式 1.内部类形式 ...3.Activity本身作为事件监听器 ...Android为所有的GUI都提供了一些事件处理回调的方法,以View为例 boolean onKeyDown(in
    (一)基于回调的事件处理
    事件源
    事件
    事件监听器(注册一个监听器要实现View.XxxListener()接口即可)
    实现事件监听的四种形式
    1.内部类形式
    2.外部类形式
    3.Activity本身作为事件监听器
    4.匿名内部类形式
    (二)基于监听的事件处理
    Android为所有的GUI都提供了一些事件处理回调的方法,以View为例
    boolean onKeyDown(int  keyCode,KeyEvent  event)
    boolean onKeyLongPress(int keyCode,KeyEvent  event)
    boolean onKeyShortcut(int  keyCode,KeyEvent  event)
    boolean onKeyUp(int  keyCode,KeyEvent  event)
    boolean onTouchEvent(int  keyCode,KeyEvent  event)
    boolean onTrackballEvent(MotionEvent  event)
    该布尔返回值用于标识该处理方法能否完全处理该事件
    Android系统最开始触发的是按键上绑定的事件监听器,然后再触发该组件提供的事件回调方法,最后会传播到该组件所在的Activity
    (三)直接绑定到标签
    定义一个方法
    public void clickXxx(View source){
    //通过findViewById获取组件
    .......
    }
    在XML文件中定义
    android:onClick="clickXxx"
    (四)响应系统设置的事件
    Configuration类简介
    系统可以通过如下方法获取Configuration对象
    Configuration cfg = getResources().getConfiguration();
    该对象具有如下常用的属性
    public float fontScale 字体的缩放因子
    public int keyboard 当前设备所关联的设备类型
    public int keyboardHidden 当前键盘是否可用
    public Locale locale 获取用户当前的Locale
    public int mcc 移动信号的国家码
    public int mnc 移动信号的网络码
    public int navigation 系统方向导航设备的类型
    public int orientation 系统屏幕方向返回值可能是ORIENTATION_LANDSCAPE(横向屏幕),
    ORIENTATION_PORTRAIT(竖屏屏幕),ORIENTATION_SQUARE(方形屏幕)
    public int touchscreen 触摸方式
    重写onConfigurationChanged方法响应系统设置更改
    设置屏幕方向
    MainActivity.this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    为了让Activity能够监听屏幕方向改变
    指定android:configChanges属性,支持mcc.mnc,orientation、、、等属性值
    其中orientation|screenSize指定可以监听屏幕方向改变的属性值
    (五)Handler消息传递机制
    只允许UI线程(主线程)修改Activity里面的UI组件
    1.Handler类简介
    Handler类的主要作用有两个
    1.在新启动的线程中发送消息
    2.在主线程中获取,处理消息
    final Handler myHandler = new Handler(){
    @Override
    public void handleMessage(Message msg){

             if(msg.what==0xXXX){
    ........
    }
    }
    }
    new Thread(new Runnable(){
    @Override
    public void run(){
    myHandler.sendMessage(Message msg);
    //myHandler.sendEmptyMessage(int what)
    }
    }).start();
    2.理解Handler,Looper,MessageQueue的工作原理
    Handler负责处理和接收消息
    Looper负责读取MessageQueue的消息
    MessageQueue负责保存消息
    MessageQueue是由Looper对象进行管理的。为了保证Looper对象正常工作。分两种情况
    1.在主UI线程中,系统已经初始化一个Looper对象了,因此程序可以直接创建Handler即可
    2.程序员自己启动子线程,必须自己创建一个Looper对象,并启动它。调用其prepare()方法即可
    在线程中使用Handler的步骤如下:
    1.调用Looper的prepare()方法创建Looper对象(Looper.prepare();)
    2.创建Handler实例,重写HandlerMessage方法(在run()方法里面重写),该方法负责处理来自于其他线程的消息
    调用loop()方法启动Looper(Looper.loop();)
    Android默认约定当UI线程堵塞20s时将会引发ANR异常,所以不要在UI线程中执行耗时的操作。
    3.异步任务
    为了解决新线程不能更新UI组件的问题,Android提供了如下几种解决方案
    1.使用Handler实现线程之间的通信
    2.Activity.runOnUiThread(Runable)
    3.View.post(Runable)
    4.View.postDelayed(Runable,long)
    AsyncTask<Params,Progress,Result>是一个抽象类,被继承时通常要指定三个泛型参数
    1.Params:启动任务执行的输入参数类型
    2.Progress:后台任务完成进度值的类型
    3.Result:后台执行任务完成后返回结果的类型
    如果某个参数不需要指定,则指定它为void
    根据需要实现AsyncTask的如下方法
    1.doInBackground(Params...)重写该方法就是后台线程将要完成的任务,该方法调用publishProgress(Params... values)方法更新任务的执行进度
    2.onProgressUpdate(Progress... values)在doInBackground()方法中调用publishProgress()方法更新任务的执行进度后,就会触发该方法
    3.onPreExecute()该方法将在执行后台耗时操作前调用,通常该方法用于完成一些初始化的准备工作,比如在界面上显示进度条。
    4.onPostExecute()方法,当doInbackground()方法会自动执行该方法,并将doInbackground方法的返回值传给该方法
    使用规则
    1.在UI线程中必须创建AsyncTask实例
    2.在UI线程中调用AsyncTask的execute()方法
    3.AsyncTask的onPreExecute().....方法将由android系统调用,不应该由程序员调用
    4.每个AsyncTask只能被执行一次,多次调用将会引发系统异常
    展开全文
  • android事件监听机制

    2019-06-20 16:25:02
    当键盘按下时 首先触发dispatchKeyEvent 然后触发onUserInteraction 再次onKeyDown 如果按下紧接着松开,则是两步 紧跟着触发dispatchKeyEvent 然后触发onUserInteraction 再次onKeyUp ...

    当键盘按下时 
    首先触发dispatchKeyEvent
    然后触发onUserInteraction
    再次onKeyDown
    如果按下紧接着松开,则是两步
    紧跟着触发dispatchKeyEvent
    然后触发onUserInteraction
    再次onKeyUp

    展开全文
  • Android事件处理机制

    2018-09-21 16:21:12
    事件是可以被识别的操作,如按下确定按钮,选择某个单选按钮或者复选框,到达某个时间点。每一种控件有自己可以识别的事件,如窗体的加载、单击、双击等事件,编辑框(文本框)的文本改变事件等等。事件有系统事件和...

    事件是可以被识别的操作,如按下确定按钮,选择某个单选按钮或者复选框,到达某个时间点。每一种控件有自己可以识别的事件,如窗体的加载、单击、双击等事件,编辑框(文本框)的文本改变事件等等。事件有系统事件和用户事件。系统事件由系统激发,如时间每隔24小时,银行储户的存款发生变更。用户事件由用户的操作激发,如用户点击按钮,在文本框中输入文本。

    在前端程序开发过程中,事件处理是一份重要的工作,应用程序必须为用户或者系统的事件提供响应,这种响应就是事件处理。Android支持两种事件处理机制:基于监听的事件处理机制和基于回调的事件处理机制,下面来讲解这两种事件处理机制。

    1、基于监听的事件处理机制

    在基于监听的事件处理机制中,主要涉及三类对象:

    1)事件源:事件发生的组件。

    2)事件:是对整个事件信息的封装,例如对于触控的操作,事件对象中分装了触摸的坐标点;

    3)事件处理器:完成具体的事件处理;

     监听机制下,事件处理采用委托机制,也就是说当事件源发生事件后,触发事件监听器,事件监听器根据注册的事件处理程序,将具体的事件委托给具体的处理程序进行处理。

    下面给出最常用的两种监听事件处理程序注册机制:

    1、在布局标签中直接指定事件处理函数

    我们可以直接在布局文件中,指定事件处理函数,如下所示:

    布局文件:

    <?xml version="1.0" encoding="utf-8"?>

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:orientation="vertical">

        <Button

            android:id="@+id/loginButton"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:onClick="loginButtonClick"

            android:text="登陆" />

    </LinearLayout>

           Activity

    package com.zhangw.kailyard;

     

    import android.app.AlertDialog;

    import android.support.v7.app.AppCompatActivity;

    import android.os.Bundle;

    import android.view.View;

     

    public class MainActivity extends AppCompatActivity {

     

        @Override

        protected void onCreate(Bundle savedInstanceState) {

            super.onCreate(savedInstanceState);

            setContentView(R.layout.activity_main);

        }

     

        public void loginButtonClick (View view){

            AlertDialog.Builder builder = new AlertDialog.Builder(this);

            builder.setMessage("登陆成功");

            builder.show();

        }

    }

    我们在Activity中定义了loginButtonClick方法,并在布局文件中通过指定按钮的onclick属性为方法名称,完成事件的绑定。

    2、通过具体的对象实现事件处理

    更多的情况下,我们采用对象完成具体的事件处理。为了能够处理特定的事件,对象必须满足一定的契约,也就是要实现特定的接口。通常我们是通过匿名类来实现给定的接口,完成事件处理程序的注册,也可以通过内部类,外部类完成时间处理程序的注册。下面给出一个通过匿名类实现事件处理的代码。

           布局文件

    <?xml version="1.0" encoding="utf-8"?>

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:orientation="vertical">

        <Button

            android:id="@+id/loginButton"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:text="登陆" />

    </LinearLayout>

    Activity

    package com.zhangw.kailyard;

     

    import android.app.AlertDialog;

    import android.support.v7.app.AppCompatActivity;

    import android.os.Bundle;

    import android.view.View;

    import android.widget.Button;

     

    public class MainActivity extends AppCompatActivity {

        private Button loginButton;

     

        @Override

        protected void onCreate(Bundle savedInstanceState) {

            super.onCreate(savedInstanceState);

            setContentView(R.layout.activity_main);

     

            loginButton = findViewById(R.id.loginButton);  // 根据ID查找组件

            loginButton.setOnClickListener(new View.OnClickListener() {

                @Override

                public void onClick(View view) {

                    AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);

                    builder.setMessage("登录成功");

                    builder.show();

                }

            });

        }

    }

           这里需要讲解一下,首先我们通过findViewById,根据按钮的ID获取按钮对象,然后调用setOnClickListener给按钮注册Click事件的处理程序。

    setOnClickListener的方法说明说下图所示:

    根据方法的签名,我们知道需要传递一个实现了View.OnClickListener接口(View类的内部接口)的对象,我们可以看到View.OnClickListener接口只有一个方法:

    我们通过匿名类实现了该接口,并传递给了setOnClickListener方法。

    这里还需要注意内部匿名类中,如何访问外部对象的this指针。代码如下图所示:

    注意:

    AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);

    builder.setMessage("登录成功");

    builder.show();

    这段代码用于弹出一个提示框,后期课程将会给大家详细讲解。

    2、基于回调的事件处理机制

    下面介绍基于回调的事件处理机制,所谓基于回调的事件处理机制是指事件源和事件处理程序统一了,当事件发生时,直接调用事件源相关的方法完成具体事件处理。针对View对象,Android提供了很多默认的事件处理方法,例如onTouchEvent、onKeyDown等,当我们自定义View时,只需要重新这些方法,就可以按照自己的业务逻辑去完成具体的事件处理。

    下面通过一个简单的自定义View演示基于回调的事件处理机制。

    自定义TouchButton代码:

    package com.practise.salary.hello;

     

    import android.content.Context;

    import android.util.AttributeSet;

    import android.util.Log;

    import android.view.KeyEvent;

    import android.view.MotionEvent;

    import android.widget.Button;

     

    public class TouchButton extends Button {

        public TouchButton(Context context, AttributeSet attributeSet) {

            super(context, attributeSet);

        }

     

        @Override

        public boolean onTouchEvent(MotionEvent motionEvent){

            super.onTouchEvent(motionEvent);

            Log.v("基于回调的onTouchEvent事件处理", "按钮中" + motionEvent.toString());

            return true;

        }

     

        @Override

        public boolean onKeyDown(int keyCode, KeyEvent keyEvent){

            super.onKeyDown(keyCode, keyEvent);

            Log.v("基于回调的onKeyDown事件处理", "按钮中" + keyEvent.toString());

            return true;

        }

    }

    布局文件使用自定的Button

    <?xml version="1.0" encoding="utf-8"?>

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:background="#fff"

        >

     

        <com.practise.salary.hello.TouchButton

            android:layout_width="match_parent"

            android:layout_height="match_parent"

            android:text="点击测试回调事件" />

     

    </LinearLayout>

    运行的结果如下图所示:

    在事件处理过程中,有一个重要的概念就是事件传播。也就是说当我们触发了事件后,是否激发后续的事件处理函数。

    大家注意,上述的事件回调方法都返回一个boolean值,如果方法返回true,则表示方法已经处理完成了事件,不会传播出去,如果为false,则表示未处理完成事件,需要传播。我们修改一下上面的样例,演示一下事件传播的过程。

    首先我们自定义一个布局容器,如下所示:

    自定义布局文件

    package com.practise.salary.hello;

     

    import android.content.Context;

    import android.util.AttributeSet;

    import android.util.Log;

    import android.view.MotionEvent;

    import android.widget.LinearLayout;

     

    public class CustLinearLayout extends LinearLayout {

        public CustLinearLayout(Context context, AttributeSet attributeSet){

            super(context, attributeSet);

        }

     

        @Override

        public boolean onTouchEvent(MotionEvent motionEvent){

            super.onTouchEvent(motionEvent);

            Log.v("基于回调的onTouchEvent事件处理", "布局中" + motionEvent.toString());

            return true;

        }

    }

    其次,我们修改MainActivity,重写onTouchEvent方法,如下所示:

    MainActivity代码

    package com.practise.salary.hello;

     

    import android.app.Activity;

    import android.os.Bundle;

    import android.util.Log;

    import android.view.MotionEvent;

     

    public class MainActivity extends Activity {

        @Override

        protected void onCreate(Bundle savedInstanceState) {

            super.onCreate(savedInstanceState);

            setContentView(R.layout.activity_main);

        }

     

        @Override

        public boolean onTouchEvent(MotionEvent motionEvent){

            super.onTouchEvent(motionEvent);

            Log.v("基于回调的onTouchEvent事件处理", "Activity中" + motionEvent.toString());

            return true;

        }

    }

    最后,我们使用两个自定的空间完成页面的设计。

    Layout代码

    <?xml version="1.0" encoding="utf-8"?>

    <com.practise.salary.hello.CustLinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:background="#fff"

        >

     

        <com.practise.salary.hello.TouchButton

            android:layout_width="match_parent"

            android:layout_height="match_parent"

            android:text="点击测试回调事件" />

     

    </com.practise.salary.hello.CustLinearLayout>

           Ok,我们运行后,点击按钮,发现只是回调了按钮中的onTouchEvent方法,如下图所示:

    下面我们把按钮控件中的onTouchEvent的返回值改成false,再次运行,我们会发现触发了自定义布局的onTouchEvent事件,如下图所示:

    最后,我们把布局中的onTouchEvent事件的返回值改成false,运行后我们发现,触发了Activity的onTouchEvent事件,如下图所示:

    事件传播只能传播到Activity。

    下面我们修改MainActivity代码,在为TouchButton注册一个事件处理程序,代码如下:

    修改的后的MainAcitvity代码

    package com.practise.salary.hello;

     

    import android.app.Activity;

    import android.os.Bundle;

    import android.util.Log;

    import android.view.MotionEvent;

    import android.view.View;

     

    public class MainActivity extends Activity {

        private TouchButton touchButton;

     

        @Override

        protected void onCreate(Bundle savedInstanceState) {

            super.onCreate(savedInstanceState);

            setContentView(R.layout.activity_main);

            touchButton = (TouchButton)findViewById(R.id.touchButton);

     

            touchButton.setOnTouchListener(new View.OnTouchListener() {

                @Override

                public boolean onTouch(View v, MotionEvent event) {

                    Log.v("基于事件的onTouchEvent事件处理", "onTouch事件中" + event.toString());

                    return false;

                }

            });

        }

     

        @Override

        public boolean onTouchEvent(MotionEvent motionEvent){

            super.onTouchEvent(motionEvent);

            Log.v("基于回调的onTouchEvent事件处理", "Activity中" + motionEvent.toString());

            return true;

        }

    }

    运行后如下图所示:

    我们发现委托的事件处理优先于回调的事件处理。

    下面我们把onTouch的事件处理方法返回值改成true,在此运行,如下图所示,

    我们会发现事件的传播被阻止了。

    事件传播不一定是从下到上,也有可能是从上到下,下面我们分析一下onInterceptTouchEvent事件。

    onInterceptTouchEvent是ViewGoup里面的一个事件,他用来拦截Touch操作的。下面我们修改上述代码,并新增加一个MiddleLinearLayout布局。下面给出源代码:

    MainAcitvity

    package com.practise.salary.hello;

     

    import android.app.Activity;

    import android.os.Bundle;

     

    public class MainActivity extends Activity {

        @Override

        protected void onCreate(Bundle savedInstanceState) {

            super.onCreate(savedInstanceState);

            setContentView(R.layout.activity_main);

        }

    }

           CustLinearLayout

    package com.practise.salary.hello;

     

    import android.content.Context;

    import android.util.AttributeSet;

    import android.util.Log;

    import android.view.MotionEvent;

    import android.widget.LinearLayout;

     

    public class CustLinearLayout extends LinearLayout {

        public CustLinearLayout(Context context, AttributeSet attributeSet){

            super(context, attributeSet);

        }

     

        @Override

        public boolean onInterceptTouchEvent(MotionEvent motionEvent){

            super.onInterceptTouchEvent(motionEvent);

            Log.v("onInterceptTouchEvent", "布局中" + motionEvent.toString());

            return true;

        }

     

        @Override

        public boolean onTouchEvent(MotionEvent motionEvent){

            super.onTouchEvent(motionEvent);

            Log.v("基于回调的onTouchEvent事件处理", "布局中" + motionEvent.toString());

            return false;

        }

    }

           MiddleLinearLayout

    package com.practise.salary.hello;

     

    import android.content.Context;

    import android.util.AttributeSet;

    import android.util.Log;

    import android.view.MotionEvent;

    import android.widget.LinearLayout;

     

    public class MiddleLinearLayout extends LinearLayout {

        public MiddleLinearLayout(Context context, AttributeSet attributeSet){

            super(context, attributeSet);

        }

     

        @Override

        public boolean onInterceptTouchEvent(MotionEvent motionEvent){

            super.onInterceptTouchEvent(motionEvent);

            Log.v("onInterceptTouchEvent", "MiddleLinearLayout布局中" + motionEvent.toString());

            return true;

        }

     

        @Override

        public boolean onTouchEvent(MotionEvent motionEvent){

            super.onTouchEvent(motionEvent);

            Log.v("基于回调的onTouchEvent事件处理", "MiddleLinearLayout布局中" + motionEvent.toString());

            return false;

        }

    }

           TouchButton

    package com.practise.salary.hello;

     

    import android.content.Context;

    import android.util.AttributeSet;

    import android.util.Log;

    import android.view.MotionEvent;

    import android.widget.Button;

     

    public class TouchButton extends Button {

        public TouchButton(Context context, AttributeSet attributeSet) {

            super(context, attributeSet);

        }

     

        @Override

        public boolean onTouchEvent(MotionEvent motionEvent){

            super.onTouchEvent(motionEvent);

            Log.v("基于回调的onTouchEvent事件处理", "按钮中" + motionEvent.toString());

            return false;

        }

    }

    activity_main

    <?xml version="1.0" encoding="utf-8"?>

    <com.practise.salary.hello.CustLinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:background="#fff"

        >

        <com.practise.salary.hello.MiddleLinearLayout

            android:layout_width="match_parent"

            android:layout_height="match_parent">

            <com.practise.salary.hello.TouchButton

                android:id="@+id/touchButton"

                android:layout_width="match_parent"

                android:layout_height="match_parent"

                android:text="点击测试回调事件" />

        </com.practise.salary.hello.MiddleLinearLayout>

     

    </com.practise.salary.hello.CustLinearLayout>

    下面我们运行,结果如下图所示:

           我们发现只是触发了CustLinearLayout中的相关事件,子元素的所有事件都没有触发。

           下面我们把CustLinearLayout的onInterceptTouchEvent方法返回值改成false,再次运行如下图所示:

           我们发现除了CustLinearLayout中的相关事件,MiddleLinearLayout中的相关事件也被触发了。

    最后我们把MiddleLinearLayout的onInterceptTouchEvent方法返回值改成false,再次运行,如下图所示

    我们发现所有的事件都触发了。

    下图我们总结了一下Touch相关的事件触发顺序

           从上图中我们可以明显看出来,onInterceptTouchEvent事件的传递是从上到下的。

           Android的事件处理机制比较凌乱,所幸大多数情况下我们只是简单的通过监听机制完成事件的处理,大家如果在具体的工作中遇到了问题,一定要细心分析,多做一些模拟程序测试一下。本节内容就到此,希望通过本节大家掌握Android的事件处理原理,至于各种组件具体有哪些的事件,我们在学习Android组件时在给大家详细介绍。

    (张伟:2018年9月20日)

    (转载时请注明来源)

    展开全文
  • Android提供了强大的事件处理机制,包括两套事件处理机制: ------------------基于监听的事件处理。 ------------------基于回调的事件处理(适合处理那种处理逻辑比较固定的View)。 对于基于监听的事件模型...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • Android中常用的事件回调方法(几乎所有回调方法都有一个boolean 的返回值 true 表示该事件已被处理,不会在传播出去; false 表示事件未被处理,会继续传播至到被处理)如: boolean onKeyDown(int keyCode, ...
  • Android提供了强大的事件处理机制,它包括两套处理机制: 1.基于监听的事件处理 2.基于回调的事件处理 对于Android基于监听的事件处理,主要的做法是为Android界面组件绑定特定的事件监听器。 对于Android基于回...
  • 方法一: 为每个按键设置一个onClick事件 Button button = (Button)findViewById(R.id.button); button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { ...
  •  为用户动作提供响应的机制就叫做事件处理,Android有两种事件处理机制:基于回调的事件处理和基于监听的事件处理; 基于监听的事件处理: 1、监听的处理模型:  Event Source(事件源):事件发生的场所吗...
  • UI编程通常都会伴随事件处理,Android也不例外,它提供了两种方式的事件处理:基于回调的事件处理和基于监听器的事件处理。 对于基于监听器的事件处理而言,主要就是为Android界面组件绑定特定的事件监听器;对于...
  • Android平台的事件处理机制有两种,一种是基于回调机制的,一种是基于监听接口的,现介绍第一种:基于回调机制的事件处理。Android平台中,每个View都有自己的处理事件的回调方法,开发人员可以通过重写View中的这些...
  • Android平台的事件处理机制有两种  基于回调机制的事件处理:Android平台中,每个View都有自己的处理事件的回调方法,开发人员可以通过重写View中的这些回调方法来实现需要的响应事件。 基于监听接口的事件...
  • Android中到处可见接口回调机制,尤其是UI事件处理方面。熟悉回调机制之后,我们就可以利用这个机制为自定义组件创建我们自己的事件监听接口和回调方法。
  • android的监听模型的理解吧
  • Android事件处理概述

    2020-03-30 17:52:50
    Android中有俩种事件处理方式:基于监听的事件处理、基于回调的事件处理 基于监听的事件处理: 主要是为UI组件绑定特定的事件监听器。在事件监听的处理模型中主要有三类对象:1.事件监听器:主要用于监听事件源所...
  • 随时随地阅读更多技术实战干货,获取项目源码、学习资料,请关注源代码社区公众号(ydmsq666)、博主微信(guyun297890152)、QQ技术交流群(183198395)。...Android提供了两套事件处理机制:  基于监听的事件...
  • Android提供2种方式的事件处理: 1:基于回调 2:基于监听 基于监听的处理模型 1:事件源---EventSource:事件发生的场所,通常是各个组件,例如按钮,菜单,窗口等。 2:事件---Event:事件封装了界面...
  • 1 2 ... 今天起,在工作之余记录下一年以来Android所学,虽然都是基础知识,但是整理出来也是非常重要。 Activity作为Android最重要的组件之一,也是初学者第一个会接触到的。 ...
  • Android闪屏示例程序

    2012-04-30 00:24:09
    那么,在Android中怎样实现这样的效果呢?  1、新建一个Android项目,命名为SplashyDemo,结构如下所示: 2、 添加资源图片: 首先我们得有闪屏时候显示的图片资源文件,并将图片放在res/drawable目录下,命名...
1 2 3 4 5 ... 14
收藏数 274
精华内容 109
关键字:

onkeydown事件的作用 简述android