美文网首页Android_ele
如何在BroadcastReceiver中执行耗时操作

如何在BroadcastReceiver中执行耗时操作

作者: Coralline_xss | 来源:发表于2017-04-13 18:07 被阅读1358次

        在回答这个问题之前,首先简单介绍一下 BroadcastReceiver的用法应注意的地方及其生命周期。

    一、BroadcastReceiver 注册方式

        BroadcastReceiver 有两种注册方式,一是使用 { Context.registerReceiver()} 动态注册,另一种是在 AndroidManifest.xml中通过 <receiver><receiver/>元素静态注册。

    Note:
        如果你在Activity的 onResume() 方法中注册广播,就需要在 onPause()方法中取消注册,当Activity处于暂停状态时,就不会接收到广播。一般是在 onCreate() 方法中 register,在 onDestroy() 方法中 unregister。

    1、安全性
    • 因为 Intent 的命名空间是全局性的,就需要保证 Intent 的 action 具有唯一性,否则就会同其他应用产生冲突。
    • 在使用 Context.registerReceiver() 时,任何应用都可以向该 registered receiver 发送广播,可以通过对广播添加权限来控制。
    • 在 AndroidManifest.xml 中静态注册广播并且明确 intent-filters时,任何应用都可以忽略 intent-filter 给你发送广播,可以设置 <code>android:exported="false"</code>.
    • 解决以上本应用的广播可能会被其他应用接收,最好的方法是使用本地广播 LocalBroadcastManager,这样发出的 intents意图只能被本应用接收。
    2、进程生命周期

        一个进程如果正在执行BroadcastReceiver的 onReceive() 方法,就会被当做一个前台进程,不易被系统杀死。
        当 onReceive() 执行完毕,BroadcastReceiver 就不再活跃,其所在进程会被系统当做一个空进程,随时有可能被系统杀死。

    3、Receiver 生命周期

        BroadcastReceiver的生命周期很短,从 onReceiver() 方法开始执行到结束,为其有效期,之后系统会销毁BraodcastReceiver对象,所以在 onReceive 方法中执行异步请求操作,很可能请求结果没有返回,BroadcastReceiver就被系统回收了。

    通过上述,可知如何正确地使用BroadcastReceiver:
    • 如果要在 BroadcastReceiver 中执行耗时操作,通过创建子线程的方式是不可靠的,因为 BroadcastReceiver 的生命周期很短,一旦结束,其所在进程属于空进程(没有任何活动组件的进程),极易在系统内存不足时优先被杀死,如此,正在工作的子线程也会被杀死。
    • 在 BroadcastReceiver 中执行耗时操作,可开启一个 Service 将耗时操作交给 Service ,这样可以提高宿主进程优先级,保证耗时操作执行完成。
    • 在 BroadcastReceiver 中不建议 show Dialog,如果要弹对话框,可以做成一个全局的对话框,需要声明 SYSTEM_ALERT_WINDOW 权限;也不能 bindService ,因为 bindService 绑定者与调用者在一起,调用者一旦退出,服务就停止了。

    二、如何在BroadcastReceiver中执行耗时操作

        在Android 开发中,一般耗时操作都会尽可能交给 Service 做,如上传图片,因为上传的过程可能应用被置于后台,Activity就会存在被系统回收的可能,如果担心 Service 被回收,还可通过 <code>startForeground(int, Notification)</code>提升其优先级。

        我们知道,Service 是工作在主线程的,所以不能直接在里面执行耗时操作,一般需要开启子线程去做,而IntentService 是 Service 的子类,正是可以用来处理异步请求的,同Service 有两个好处:一是其内部开启了一个异步处理工作线程 HandlerThread ,不用我们自己去 new Thread 了;二是不需要考虑什么时候关闭该 Service,当完成所有的任务后会自动关闭。

    Note:IntentService执行过程简单说明:

    • HandlerThread 是Thread的子类,同普通线程相比,里面会创建Looper,线程会拥有 MessageQueue,然后处于无限循环中,这个Looper对象将被用来创建 Handler,如此便可以从这个线程的消息队列中一直取Message消息,进行处理。
    • Handler创建是在 IntentService 完成的,在IntentService 的 onCreate() 方法中会先开启 HandlerThread 异步消息处理线程,然后获取该线程的Looper对象来创建 Handler。
    • 每次 startService()时,如果IntentService还有消息未处理完毕,就会只执行 onStartCommand(Intent, int, int startId);方法,在该方法中会将 Intent的参数 和 startId 封装成 Message ,通过 handler.sendMessage()方法发送到消息队列中。
    • Handler的 handleMessgae()消息处理方法中值执行两步操作:一是提供回调方法供获取外部参数进行耗时操作。用户可以自定义;二是当消息队列为空时,通过 Message 中封装的 startId 停止IntentService.

    [ 注:此时的 Handler 处理消息是在 HandleThread 子线程中处理的,因为是通过子线程的 looper 创建的,同主线程无关。]

        接下来看一个完整的在BroadcastReceiver 中使用 IntentService 执行耗时操作的例子。

    三、实例代码

        主线程代码部分:

        public class BroadcastTestActivity extends AppCompatActivity implements View.OnClickListener {
        public static final String TAG = "MainThread";
    
        public static final String ACTION_SEND_MSG_BY_MYINTENTSERVICE = "com.xss.download.by.myIntentService";
        public static final String ACTION_FROM_INTENTSERVICE = "com.xss.download.intentService";
    
        private Button btn_send_intent_service;
        private TextView tv_msg, tv_msg_intent_service;
    
        private DownloadBroadcastReceiver downloadBroadcastReceiver;
    
        // 使用本地广播 LocalBroadcast 会更好些
        class DownloadBroadcastReceiver extends BroadcastReceiver {
    
            @Override
            public void onReceive(Context context, Intent intent) {
                // Skipped 5999 frames!  目前只提示丢帧,没有出现 ANR 弹窗
                // SystemClock.sleep(100000);
    
                tv_msg.append("--onReceive: action = " + intent.getAction());
                tv_msg.append("\n");
                String data = intent.getStringExtra("data");
    
                // 3. 执行耗时操作
                if (ACTION_SEND_MSG_BY_MYINTENTSERVICE.equals(intent.getAction())) {
                    tv_msg_intent_service.append("--onReceiver: process time-consuming by IntentService !");
                    tv_msg_intent_service.append("\n");
    
                    // 方式二:使用 IntentService 处理耗时操作,并且通过广播回传处理成功的回调
                    sendMsgByIntentService(context, data);
    
                } else if (ACTION_FROM_INTENTSERVICE.equals(intent.getAction())) {
    
                    // 方式二回调结果:Service通过广播发送数据,更新UI
                    tv_msg_intent_service.append("\n");
                    tv_msg_intent_service.append("--onReceiver: received data from IntentService !");
                    tv_msg_intent_service.append("\n");
                    tv_msg_intent_service.append("--data = " + intent.getStringExtra("data_from_intent_service"));
                    tv_msg_intent_service.append("\n");
    
                }
            }
        }
        
        /**
         * 策略二:使用 IntentService处理
         * @param data
         */
        private void sendMsgByIntentService(Context context, String data) {
            Intent intent = new Intent(context, MyIntentService.class);
            intent.setAction("com.xss.startIntentService");
            intent.putExtra("data", data);
            context.startService(intent);
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_broadcast_test);
    
             // 1. 注册广播
            registerBroadcast();
    
            initView();
        }
    
       private void registerBroadcast() {
            downloadBroadcastReceiver = new DownloadBroadcastReceiver();
            IntentFilter intentFilter = new IntentFilter("");
            intentFilter.addAction(ACTION_SEND_MSG_BY_MYHANDLERTHREAD);
            intentFilter.addAction(ACTION_SEND_MSG_BY_MYINTENTSERVICE);
            intentFilter.addAction(ACTION_FROM_INTENTSERVICE);
            registerReceiver(downloadBroadcastReceiver, intentFilter);
       }
    
        private void initView() {
            tv_msg = (TextView) findViewById(R.id.tv_msg);
    
            tv_msg_handler_thread = (TextView) findViewById(R.id.tv_msg_handler_thread);
            btn_send_my_handler_thread = (Button) findViewById(R.id.btn_send_my_handler_thread);
            tv_msg_intent_service = (TextView) findViewById(R.id.tv_msg_intent_service);
            btn_send_intent_service = (Button) findViewById(R.id.btn_send_intent_service);
    
            btn_send_my_handler_thread.setOnClickListener(this);
            btn_send_intent_service.setOnClickListener(this);
        }
    
        private void sendBroadcast(String action) {
            // 2. 发送广播
            Intent intent = new Intent(action);
            intent.putExtra("data", "hello, This is a msg from broadcast to send to you !");
            sendBroadcast(intent);
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.btn_send_intent_service:
                    tv_msg_intent_service.append("--onClick: begin to send broadcast !--\n");
                    sendBroadcast(ACTION_SEND_MSG_BY_MYINTENTSERVICE);
                    break;
    
                default:
                    break;
            }
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            unregisterReceiver(downloadBroadcastReceiver);
            stopService(new Intent());
        }
        }
    

        自定义的 IntentService,只需要继承 IntentSerive,重写其 onHandleIntent() 方法即可,代码如下:

         // 该方法是在 HandlerThread异步消息处理线程的消息队列中取出消息进行处理,当所有的msg处理完,messageQueue为空,IntentService 就会调用 stopSelf 方法停止
        @Override
        protected void onHandleIntent(@Nullable Intent intent) {
            Log.d(TAG, "IntentService is handling intent msg");
    
            if ("com.xss.startIntentService".equals(intent.getAction())) {
                String msg = intent.getStringExtra("data");
    
                Log.d(TAG, Thread.currentThread().getName());
                Log.d(TAG, "Msg received from main handler thread: broadcast send = " + msg);
                // 处理耗时请求
                SystemClock.sleep(5000);
                Log.d(TAG, "Is Broadcast ANR ?");
    
                // 子线程处理消息后,给主线程发消息,说"我执行完了"
                Message mainMsg = new Message();
                mainMsg.what = 0x22;
                mainMsg.obj = "Msg from child handler thread: I have done !";
    
                // 使用广播将处理耗时操作的数据发送给主线程
                Intent intent0 = new Intent(BroadcastTestActivity.ACTION_FROM_INTENTSERVICE);
                intent0.putExtra("data_from_intent_service", "Msg from MyIntentService: I have done !");
                sendBroadcast(intent0);
    
                // 如果消息队列为空,就会直接结束Service,接着执行onDestroyed方法
            }
        }
    

    相关文章

      网友评论

        本文标题:如何在BroadcastReceiver中执行耗时操作

        本文链接:https://www.haomeiwen.com/subject/inavattx.html