IntentService

迈不过友情╰ 2021-12-14 01:31 216阅读 0赞

> IntentService，可以看做是Service和HandlerThread的结合体，在完成了使命之后会自动停止，适合需要在工作线程处理UI无关任务的场景。

*  IntentService 是继承自 Service 并处理异步请求的一个类，在 IntentService 内有一个工作线程来处理耗时操作。
 *  当任务执行完后，IntentService 会自动停止，不需要我们去手动结束。
 *  如果启动 IntentService 多次，那么每一个耗时操作会以工作队列的方式在 IntentService 的 onHandleIntent 回调方法中执行，依次去执行，使用串行的方式，执行完自动结束。

**例子**  
    下面是一个例子，点击开始启动一个IntentService去更新进度条，更新完毕IntentService会自动结束。如果多次点击开始，就会执行多遍，多遍执行完之后IntentService才会执行onDestroy方法。

![Image 1][]

image.png

IntentService:

package com.bourne.android_common.ServiceDemo;
    
    import android.app.IntentService;
    import android.content.Intent;
    import android.support.v4.content.LocalBroadcastManager;
    
    import com.bourne.common_library.utils.Logout;
    
    public class MyIntentService extends IntentService {
    
        /**
         * 是否正在运行
         */
        private boolean isRunning;
    
        /**
         *进度
         */
        private int count;
    
        /**
         * 广播
         */
        private LocalBroadcastManager mLocalBroadcastManager;
    
        public MyIntentService() {
            super("MyIntentService");
            Logout.e("MyIntentService");
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            Logout.e("onCreate");
            mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
        }
    
        @Override
        protected void onHandleIntent(Intent intent) {
            Logout.e("onHandleIntent");
            try {
                Thread.sleep(1000);
                isRunning = true;
                count = 0;
                while (isRunning) {
                    count++;
                    if (count >= 100) {
                        isRunning = false;
                    }
                    Thread.sleep(50);
                    sendThreadStatus("线程运行中...", count);
                }
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 发送进度消息
         */
        private void sendThreadStatus(String status, int progress) {
            Intent intent = new Intent(IntentServiceActivity.ACTION_TYPE_THREAD);
            intent.putExtra("status", status);
            intent.putExtra("progress", progress);
            mLocalBroadcastManager.sendBroadcast(intent);
        }
    
        @Override
        public void onDestroy() {
            super.onDestroy();
            Logout.e("线程结束运行..." + count);
        }
    }

启动之后会先执行构造方法，然后执行onCreate方法，再到onHandleIntent方法。在onHandleIntent让进度自增，每次自增睡眠50ms并向Activity发送广播并传递进度的数据。

**IntentServiceActivity:**

package com.bourne.android_common.ServiceDemo;
    
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.support.v4.content.LocalBroadcastManager;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.ProgressBar;
    import android.widget.TextView;
    
    import com.bourne.android_common.R;
    
    import butterknife.BindView;
    import butterknife.ButterKnife;
    import butterknife.OnClick;
    
    public class IntentServiceActivity extends AppCompatActivity {
        /**
         * 状态文字
         */
        @BindView(R.id.tv_status)
        TextView tv_status;
    
        /**
         * 进度文字
         */
        @BindView(R.id.tv_progress)
        TextView tv_progress;
    
        /**
         * 进度条
         */
        @BindView(R.id.progressbar)
        ProgressBar progressbar;
    
        private LocalBroadcastManager mLocalBroadcastManager;
        private MyBroadcastReceiver mBroadcastReceiver;
        public final static String ACTION_TYPE_THREAD = "action.type.thread";
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_intent_service);
            ButterKnife.bind(this);
    
            //注册广播
            mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
            mBroadcastReceiver = new MyBroadcastReceiver();
            IntentFilter intentFilter = new IntentFilter();
            intentFilter.addAction(ACTION_TYPE_THREAD);
            mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, intentFilter);
    
            initView();
        }
    
        public void initView() {
            tv_status.setText("线程状态：未运行");
            progressbar.setMax(100);
            progressbar.setProgress(0);
            tv_progress.setText("0%");
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            //注销广播
            mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);
        }
    
        public class MyBroadcastReceiver extends BroadcastReceiver {
            @Override
            public void onReceive(Context context, Intent intent) {
                switch (intent.getAction()) {
    
                    case ACTION_TYPE_THREAD:
                        //更改UI
                        int progress = intent.getIntExtra("progress", 0);
                        tv_status.setText("线程状态：" + intent.getStringExtra("status"));
                        progressbar.setProgress(progress);
                        tv_progress.setText(progress + "%");
                        if (progress >= 100) {
                            tv_status.setText("线程结束");
                        }
                        break;
                }
            }
        }
    
        @OnClick({R.id.btn_start})
        public void onClick(View view) {
            switch (view.getId()) {
                case R.id.btn_start:
                    Intent intent = new Intent(IntentServiceActivity.this, MyIntentService.class);
                    startService(intent);
                    break;
            }
        }
    }

点击开始按钮，会启动MyIntentService。mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, intentFilter)注册广播，接收广播消息和数据，并时刻更改进度条进度。

**注册MyIntentService**

\*\* IntentService源码分析\*\*

package android.app;
    
    import android.annotation.WorkerThread;
    import android.annotation.Nullable;
    import android.content.Intent;
    import android.os.Handler;
    import android.os.HandlerThread;
    import android.os.IBinder;
    import android.os.Looper;
    import android.os.Message;
    
    public abstract class IntentService extends Service {
        private volatile Looper mServiceLooper;
        private volatile ServiceHandler mServiceHandler;
        private String mName;
        private boolean mRedelivery;
    
        private final class ServiceHandler extends Handler {
            public ServiceHandler(Looper looper) {
                super(looper);
            }
    
            @Override
            public void handleMessage(Message msg) {
                onHandleIntent((Intent)msg.obj);
                stopSelf(msg.arg1);
            }
        }
    
        /**
         * Creates an IntentService.  Invoked by your subclass's constructor.
         */
        public IntentService(String name) {
            super();
            mName = name;
        }
    
        /**
         * Sets intent redelivery preferences.  Usually called from the constructor
         */
        public void setIntentRedelivery(boolean enabled) {
            mRedelivery = enabled;
        }
    
        @Override
        public void onCreate() {
            // TODO: It would be nice to have an option to hold a partial wakelock
            // during processing, and to have a static startService(Context, Intent)
            // method that would launch the service & hand off a wakelock.
    
            super.onCreate();
            HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
            thread.start();
    
            mServiceLooper = thread.getLooper();
            mServiceHandler = new ServiceHandler(mServiceLooper);
        }
    
        @Override
        public void onStart(@Nullable Intent intent, int startId) {
            Message msg = mServiceHandler.obtainMessage();
            msg.arg1 = startId;
            msg.obj = intent;
            mServiceHandler.sendMessage(msg);
        }
    
        /**
         * You should not override this method for your IntentService. Instead,
         */
        @Override
        public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
            onStart(intent, startId);
            return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
        }
    
        @Override
        public void onDestroy() {
            mServiceLooper.quit();
        }
    
        /**
         * Unless you provide binding for your service, you don't need to implement this
         */
        @Override
        @Nullable
        public IBinder onBind(Intent intent) {
            return null;
        }
    
        /**
         */
        @WorkerThread
        protected abstract void onHandleIntent(@Nullable Intent intent);
    }

IntentService继承自Service，内部有一个HandlerThread对象。

在onCreate的时候会创建一个HandlerThread对象，并启动线程。紧接着创建ServiceHandler对象，ServiceHandler继承自Handler，用来处理消息。ServiceHandler将获取HandlerThread的Looper就可以开始正常工作了。

每启动一次onStart方法，就会把数消息和数据发给mServiceHandler，相当于发送了一次Message消息给HandlerThread的消息队列。mServiceHandler会把数据传个onHandleIntent方法，onHandleIntent是个抽象方法，需要在IntentService实现，所以每次onStart方法之后都会调用我们自己写的onHandleIntent方法去处理。处理完毕使用stopSelf通知HandlerThread已经处理完毕，HandlerThread继续观察消息队列，如果还有未执行玩的message则继续执行，否则结束。

**启动 IntentService 为什么不需要新建线程？**  
IntentService内部的HandlerThread 继承自 Thread，内部封装了 Looper，在这里新建线程并启动，所以启动 IntentService 不需要新建线程。

**为什么不建议通过 bindService() 启动 IntentService？**

@Override
    public IBinder onBind(Intent intent) {
        return null;
    }

IntentService 源码中的 onBind() 默认返回 null；不适合 bindService() 启动服务，如果你执意要 bindService() 来启动 IntentService，可能因为你想通过 Binder 或 Messenger 使得 IntentService 和 Activity 可以通信，这样那么 onHandleIntent() 不会被回调，相当于在你使用 Service 而不是 IntentService。

--------------------

**为什么多次启动 IntentService 会顺序执行事件，停止服务后，后续的事件得不到执行？**

@Override
    public void onStart(Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }
    
    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

IntentService 中使用的 Handler、Looper、MessageQueue 机制把消息发送到线程中去执行的，所以多次启动 IntentService 不会重新创建新的服务和新的线程，只是把消息加入消息队列中等待执行，而如果服务停止，会清除消息队列中的消息，后续的事件得不到执行。

作者：Winterfell\_Z  
链接：[https://www.jianshu.com/p/be97093783d6][https_www.jianshu.com_p_be97093783d6]  
来源：简书

[Image 1]: 
[https_www.jianshu.com_p_be97093783d6]: https://www.jianshu.com/p/be97093783d6