Copyright notice: This article is the blogger’s original article, welcome to reprint!

Reprint please indicate the source: blog.csdn.net/guiying712/… This article is from: [Zhang Huayang’s blog]

In this article, I will introduce IntentService in Android. While analyzing the principle of IntentService, I will also analyze HandlerThread used in IntentService.

IntentService

IntentService inherits Service from Android’s four main components. The difference between IntentService and Service is that it can handle asynchronous requests. As we all know, the code in Service runs on the main thread by default. ANR problems can easily occur if time-consuming tasks are handled directly in a Service, whereas IntentService works directly in child threads. In addition, when we start IntentService with the startService(Intent) method, IntentService will process each Intent in the worker thread and stop itself after completing the task.

Before analyzing the source code, let’s look at how to use IntentService:

public class MyIntentService extends IntentService { public MyIntentService() { super("MyIntentService"); Override protected void onHandleIntent(Intent Intent) {// Print the name of the current thread, Log.d("MyIntentService", "Thread id is "+ thread.currentThread ().getName()); } @Override public void onDestroy() { super.onDestroy(); Log.d("MyIntentService", "onDestroy"); }}Copy the code

IntentService: IntentService: IntentService: IntentService: IntentService: IntentService: IntentService: IntentService: IntentService: IntentService: IntentService: IntentService: IntentService: IntentService In the onHandleIntent method, you can handle some specific business logic without worrying about ANR because the method is already running in a child thread.

IntentService IntentService

public class IntentService extends Service { private volatile Looper mServiceLooper; private volatile ServiceHandler mServiceHandler; private String mName; 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); } } @WorkerThread protected abstract void onHandleIntent(@Nullable Intent intent); /** * Creates an IntentService. Invoked by your subclass's constructor. * * @param name Used to name the worker thread, important only for debugging. */ public IntentService(String name) { super(); mName = name; } @Override public void onCreate() { 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); } @Override public void onDestroy() { mServiceLooper.quit(); }}Copy the code

The reason why the constructor of MyIntentService must call the parent’s argument constructor is because IntentService needs to give its worker thread a name that can be used to distinguish between them when we debug. We can verify this with this code in the onCreate() method:

HandlerThread thread = new HandlerThread(” IntentService[” + mName + “] “); // mName is the argument we passed in the constructor

IntentService (Context, Intent) : IntentService (Context, Intent) : IntentService (Context, Intent) : IntentService (Context, Intent) : IntentService (Context, Intent) : IntentService (Context, Intent) : IntentService (Context, Intent) : IntentService (Context, Intent)

1. First create a HandlerThread in the onCreate() callback and start the thread. Then get the Looper created in the HandlerThread and use the Looper to create a ServiceHandler.

OnStart (@nullable Intent Intent Intent, int startId); Make the Message carry our request parameters, and then send the Message out via ServiceHandler. If you don’t understand how Handler works, check out this article: Android Handler source code parsing.

The Message sent by ServiceHandler is eventually distributed to the handleMessage(Message MSG) method of ServiceHandler, an inner class of IntentService. IntentService’s abstract method onHandleIntent(@nullable Intent Intent) is called and annotated with @workerthread, indicating that the method was called in the WorkerThread. The stopSelf method of the Service is then called to stop the Service, so you don’t need to call the stopSelf method.

Once IntentService calls stopSelf, onDestroy() is called back, and the Looper we created in HandlerThread exits the loop.

Note the following when using IntentService:

OnHandleIntent (IntentService) : IntentService (IntentService) : IntentService (IntentService) : IntentService (IntentService) : IntentService (IntentService) : IntentService (IntentService) : IntentService (IntentService) : IntentService (IntentService) : IntentService (IntentService) : IntentService (IntentService)

2. Do not provide Service onBind in your IntentService. You do not need to implement this method because IntentService implements it by default and returns null.

HandlerThread

public class HandlerThread extends Thread { Looper mLooper; private @Nullable Handler mHandler; protected void onLooperPrepared() { } @Override public void run() { ... Looper.prepare(); synchronized (this) { mLooper = Looper.myLooper(); notifyAll(); }... onLooperPrepared(); Looper.loop(); . } public Looper getLooper() { if (! isAlive()) { return null; } // If the thread has been started, wait until the looper has been created. synchronized (this) { while (isAlive() && mLooper == null) { try { wait(); } catch (InterruptedException e) { } } } return mLooper; } public boolean quit() { Looper looper = getLooper(); if (looper ! = null) { looper.quit(); return true; } return false; }}Copy the code