消息处理Handler

Posted 2020-07-06

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了消息处理Handler相关的知识，希望对你有一定的参考价值。

关于Message
-----------------------------------
Message是“消息机制”中“消息”的载体。
Message的常用属性有：
int what：表示消息的类型标识，可以由开发者随意指定，通常应该使用静态常量，而且，各消息的int值应该不相同
int arg1：表示在消息中需要封装的int类型数据，该属性的值应该是有数值含义的
int arg2：参考arg1
Object obj：作用参考arg1
创建Message对象：
尽管Message类提供了无参数的公有的构造方法，但是，并不推荐使用new Message()这样的语法创建对象，而应该使用Message.obtain()系列方法获取对象，
因为Message类的内部实现了对消息对象的创建、管理等系统功能。
如果使用Message的obtain()系列方法时，在obtain()方法中指定了Handler对象，则最后应该使用Message对象的sendToTarget()方法执行消息的发送。

public class MainActivity extends Activity {
    private TextView tvTime;
    private boolean isRunning;
    private Handler handler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        tvTime = (TextView) findViewById(R.id.tv_time);
        handler = new InnerHandler();
    }

    public void startShowTime(View v) {
        isRunning = true;
        new ShowTimeThread().start();
    }
    
    private static final int MESSAGE_UPDATE_TIME = 999;
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
    private Date date = new Date();
    
    private class InnerHandler extends Handler {
        private String timeString;
        @Override
        public void handleMessage(Message msg) {
            if(msg.what == MESSAGE_UPDATE_TIME) {
                date.setTime(System.currentTimeMillis());
                timeString = sdf.format(date);
                tvTime.setText(timeString);
            }
        }
    }
    
    private class ShowTimeThread extends Thread {
        @Override
        public void run() {
            while(isRunning) {
                handler.sendEmptyMessage(MESSAGE_UPDATE_TIME);
                
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    @Override
    protected void onDestroy() {
        isRunning = false;
        super.onDestroy();
    }
    
}

public class ShowProgressActivity extends Activity {
    private ProgressBar pbProgress;
    private Handler handler;
    private static final int MESSAGE_UPDATE_PROGRESS = 999999;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_show_progress);
        
        pbProgress = (ProgressBar) findViewById(R.id.pb_progress);
        
        handler = new InnerHandler();
    }
    
    private class UpdateProgressThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                Message msg = new Message();
                msg.what = MESSAGE_UPDATE_PROGRESS;
                msg.arg1 = i + 1;
                handler.sendMessage(msg);
                // handler.sendEmptyMessage(MESSAGE_UPDATE_PROGRESS);

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    private class InnerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            if(MESSAGE_UPDATE_PROGRESS == msg.what) {
                pbProgress.setProgress(msg.arg1);
            }
        }
    }
    
    public void startProgress(View v) {
        new UpdateProgressThread().start();
    }

    // 主线程
    // ---------------------------
    // 1. 声明成员变量handler
    // 
    // 子线程
    // ---------------------------
    // 1. 自定义线程UpdateProgressThread，继承自Thread
    // 2. 重写run()方法，循环100次，实时修改全局变量progress的值，每隔100毫秒休眠
    // 3. 在循环中，使用handler发空白消息，消息的what使用MESSAGE_UPDATE_PROGRESS
    //
    // Handler
    // ---------------------------
    // 1. 自定义类InnerHandler，继承自Handler
    // 2. 重写handleMessage()方法
    // 3. 在方法中，判断msg的what值
    // 4. 更新进度，即根据全部局量progress，调用ProgressBar的setProgress()
    //
    // 其它
    // ---------------------------
    // 1. 在Activity的onCreate()中创建handler
    // 2. 添加按钮的点击事件，点击时，开启线程

}

public class ShowProgressActivity extends Activity {
    private ProgressBar pbProgress;
    private Handler handler;
    private static final int MESSAGE_UPDATE_PROGRESS = 999999;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_show_progress);
        
        pbProgress = (ProgressBar) findViewById(R.id.pb_progress);
        
        handler = new InnerHandler();
    }
    
    private class UpdateProgressThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
//                Message msg = Message.obtain(handler);
//                msg.what = MESSAGE_UPDATE_PROGRESS;
//                msg.arg1 = i + 1;
//                msg.sendToTarget();
                
                // 参数1：消息的发送者与处理者(handler)
                // 参数2：消息的标识(what)
                // 参数3：消息中的数据(arg1)
                // 参数4：消息中的数据(arg2，本例中没有使用到)
                Message.obtain(handler, MESSAGE_UPDATE_PROGRESS, i+1, 0).sendToTarget();
                
                // handler.sendMessage(msg);
                // handler.sendEmptyMessage(MESSAGE_UPDATE_PROGRESS);
                
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    private class InnerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            if(MESSAGE_UPDATE_PROGRESS == msg.what) {
                pbProgress.setProgress(msg.arg1);
            }
        }
    }
    
    public void startProgress(View v) {
        new UpdateProgressThread().start();
    }

    // 主线程
    // ---------------------------
    // 1. 声明成员变量handler
    // 
    // 子线程
    // ---------------------------
    // 1. 自定义线程UpdateProgressThread，继承自Thread
    // 2. 重写run()方法，循环100次，实时修改全局变量progress的值，每隔100毫秒休眠
    // 3. 在循环中，使用handler发空白消息，消息的what使用MESSAGE_UPDATE_PROGRESS
    //
    // Handler
    // ---------------------------
    // 1. 自定义类InnerHandler，继承自Handler
    // 2. 重写handleMessage()方法
    // 3. 在方法中，判断msg的what值
    // 4. 更新进度，即根据全部局量progress，调用ProgressBar的setProgress()
    //
    // 其它
    // ---------------------------
    // 1. 在Activity的onCreate()中创建handler
    // 2. 添加按钮的点击事件，点击时，开启线程

}

public class ShowProgressActivity extends Activity {
    private ProgressBar pbProgress;
    private Handler handler;
    private static final int MESSAGE_UPDATE_PROGRESS = 999999;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_show_progress);

        pbProgress = (ProgressBar) findViewById(R.id.pb_progress);

        handler = new Handler();
        // handler = new Handler(new InnerHandlerCallback());
    }

    // private class InnerHandlerCallback implements Handler.Callback {
    // @Override
    // public boolean handleMessage(Message msg) {
    // if (MESSAGE_UPDATE_PROGRESS == msg.what) {
    // pbProgress.setProgress(msg.arg1);
    // }
    // return false;
    // }
    // }

    // private class InnerHandler extends Handler {
    // @Override
    // public void handleMessage(Message msg) {
    // if (MESSAGE_UPDATE_PROGRESS == msg.what) {
    // pbProgress.setProgress(msg.arg1);
    // }
    // }
    // }

    private class UpdateProgressThread extends Thread {
        private int i = 0;
        @Override
        public void run() {
            for (; i < 100; i++) {
                Message msg = Message.obtain(handler, new Runnable() {
                    @Override
                    public void run() {
                        pbProgress.setProgress(i + 1);
                    }
                });
                msg.sendToTarget();

                // Message msg = Message.obtain(handler);
                // msg.what = MESSAGE_UPDATE_PROGRESS;
                // msg.arg1 = i + 1;
                // msg.sendToTarget();
                // handler.sendMessage(msg);
                // handler.sendEmptyMessage(MESSAGE_UPDATE_PROGRESS);

                // 参数1：消息的发送者与处理者(handler)
                // 参数2：消息的标识(what)
                // 参数3：消息中的数据(arg1)
                // 参数4：消息中的数据(arg2，本例中没有使用到)
                // Message.obtain(handler, MESSAGE_UPDATE_PROGRESS, i + 1, 0)
                // .sendToTarget();

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void startProgress(View v) {
        new UpdateProgressThread().start();
    }

    // 主线程
    // ---------------------------
    // 1. 声明成员变量handler
    //
    // 子线程
    // ---------------------------
    // 1. 自定义线程UpdateProgressThread，继承自Thread
    // 2. 重写run()方法，循环100次，实时修改全局变量progress的值，每隔100毫秒休眠
    // 3. 在循环中，使用handler发空白消息，消息的what使用MESSAGE_UPDATE_PROGRESS
    //
    // Handler
    // ---------------------------
    // 1. 自定义类InnerHandler，继承自Handler
    // 2. 重写handleMessage()方法
    // 3. 在方法中，判断msg的what值
    // 4. 更新进度，即根据全部局量progress，调用ProgressBar的setProgress()
    //
    // 其它
    // ---------------------------
    // 1. 在Activity的onCreate()中创建handler
    // 2. 添加按钮的点击事件，点击时，开启线程

}

//引导界面
public class GuideActivity extends Activity {
    private static final int MESSAGE_UPDATE_COUNTER = 0;
    private Handler handler;
    private TextView tvCounter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_guide);

        tvCounter = (TextView) findViewById(R.id.tv_counter);
        handler = new Handler(new InnerHandlerCallback());
        
        new CounterThread().start();

        // handler.sendEmptyMessageDelayed(0, 3000);

        // handler = new Handler();
        // handler.postDelayed(new Runnable() {
        // @Override
        // public void run() {
        // Intent intent = new Intent(GuideActivity.this, MainActivity.class);
        // startActivity(intent);
        // finish();
        // }
        // }, 3000);
    }

    private class CounterThread extends Thread {
        @Override
        public void run() {
            for (int i = 3; i >= 0; i--) {
                Message.obtain(handler, MESSAGE_UPDATE_COUNTER, i, 0)
                        .sendToTarget();

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

以上是关于消息处理Handler的主要内容，如果未能解决你的问题，请参考以下文章

Android Handler消息机制核心代码

handler

金蝶handler中 collection 代码片段理解

handler笔记（sendXXpostXX延迟处理）

消息处理Handler