从源码分析IntentService

不管学什么知识点最好从其基本用法开始,然后在深入到源码层学习会比较容易理解源码带给我们的思想。所以咱们先来看看IntentService的基本用法。

其实很简单,遵守一定的套路就可以
1. 继承IntentService并生成构造方法通过super()来完成父类的基本初始化操作
2. 重写父类的onHandleIntent方法并执行需要完成的后台任务操作(上传文件等)
3. 重写onDestroy来完成些清理工作

比如:

public class MyIntentService extends IntentService {
    private static final String ACTION_BAZ = "com.example.comp.action.BAZ";

    private static final String EXTRA_PARAM1 = "com.example.comp.extra.PARAM1";
    private static final String EXTRA_PARAM2 = "com.example.comp.extra.PARAM2";

    public MyIntentService() {
        super("MyIntentService");
        setIntentRedelivery(false);
    }
    //用于启动此服务的辅助方法
    public static void startActionBaz(Context context, String param1, String param2) {
        Intent intent = new Intent(context, MyIntentService.class);
        intent.setAction(ACTION_BAZ);
        intent.putExtra(EXTRA_PARAM1, param1);
        intent.putExtra(EXTRA_PARAM2, param2);
        context.startService(intent);
        Log.d("MyIntentService","startActionBaz");
        Log.d("MyIntentService","threadID:" + Thread.currentThread().getId());
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        Log.d("MyIntentService","onHandleIntent:" + Thread.currentThread().getId());
        if (intent != null) {
            final String action = intent.getAction();
            if (ACTION_BAZ.equals(action)) {
                final String param1 = intent.getStringExtra(EXTRA_PARAM1);
                final String param2 = intent.getStringExtra(EXTRA_PARAM2);
                handleActionBaz(param1, param2);
            }
        }
    }

    private void handleActionBaz(String param1, String param2) {
        Log.d("MyIntentService","handleActionBaz:" + Thread.currentThread().getId());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("MyIntentService","onDestroy:" + Thread.currentThread().getId());
    }
}

在前台activity中通过 MyIntentService.startActionBaz来启动服务,大家可以注意log日志的输出查看对应的方法是在哪个线程中执行的(通常主[ui]线程id为1,如果在对应的方法中输出的线程id为1表明是在ui线程中执行的,那么千万就不要在这样的方法中执行费时操作了,以避免ANR[程序未响应]的异常)。
辅助方法中是通过startService来启动服务的,想必大家都知道在启动成功后将调用Service的onCreate和onStartCommand方法,那 我们就可以从这两个方法开始着手进入源码分析。
- IntentService.java

  public void onCreate() {
      super.onCreate();
      HandlerThread thread = new   HandlerThread("IntentService[" + mName + "]");
    thread.start();
      mServiceLooper = thread.getLooper();
      mServiceHandler = new ServiceHandler(mServiceLooper);
     }

    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }
    public void onDestroy() {
        mServiceLooper.quit();//退出Looper消息循环
    }

大概可以得出结论:
1. 启动Service时在onCreate方法中启动了一个HandlerThread的线程并生成了一个Looper用来分发消息之类的,同时创建了一个ServiceHandler的Handler用来处理消息
2. onStartCommand中调用了onStart方法,那么在onStart方法中做了些什么操作呢?
- IntentService.java
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}
很明显就是通过ServiceHandler来发送消息(发送到了HandlerThread的Looper消息队列中),消息携带了intent对象(start Service启动Service时的intent),那么有发送消息就一定有处理消息的代码。继续查看ServiceHandler的代码发现其是IntentService的内部类,定义如下:

    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);
        }
    }

可以看出在handleMessage中调用了onHandleIntent方法并在方法结束后stopSelf停止了Service。继续查看onHandleIntent方法的定义
IntentService.java
protected abstract void onHandleIntent(Intent intent);
OK,这个抽象方法必须在IntentService的子类中重写,那么在ServiceHandler的handleMessage中调用的将是子类中重写的onHandleIntent方法,所以在我们的MyIntentService类中的onHandleIntent方法被调用(通过Java的多态机制实现了一个“模版方法”的设计模式)

到此源码基本分析结束,可以得出结论如下:
1. 启动IntentService类型的Service后,系统通过ServiceHandler将携带的Intent消息放入由HandlerThread线程生成的Looper的消息队列中,Looper依次处理队列中的消息并通过dispatchMessage将消息交给ServiceHandler的Handler来具体执行(其实就是Handler的用法,和我们在Activity中创建Handler并在handleMessage中更新ui的用法一样,只不过这里的handleMessage是在HandlerThread这样的后台线程而不是ui线程中执行的)
2. 调用子类的onHandleIntent方法(用来执行费时操作),结束后关闭Service
总之,这种机制通常用于希望按顺序执行(串行)而非并发(并行)执行的费时操作,其中每个任务执行完毕的时间是未知的的应用场景。如果希望在任务结束后通知前台可以通过sendBroadCast的方式发送广播。

HandlerThread类的关键代码(Service的onCreate方法中创建并start启动了线程):

/**
典型的创建Looper步骤:
//生成Looper实例
Looper.prepare();
Looper.myLooper();
//启动Looper循环
Looper.loop();
*/
public void run() {
    mTid = Process.myTid();
    Looper.prepare();
    synchronized (this) {
        mLooper = Looper.myLooper();
        notifyAll();
    }
    Process.setThreadPriority(mPriority);
    onLooperPrepared();
    Looper.loop();
    mTid = -1;
}
public Looper getLooper() {
    if (!isAlive()) {
        return null;
    }
    synchronized (this) {
        while (isAlive() && mLooper == null) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
    }
    return mLooper;
}

这里比较难理解的是线程的安全同步代码,在onCreate方法中调用顺序如下:

HandlerThread thread = new HandlerThread();
thread.start();
thread.getLooper();

想必大家都知道线程的基本知识,这里就不多介绍了。在线程调用start后并不一定run方法立刻得到执行(异步调用的),所以在执行thread.getLooper()时这个时候run还没有执行。so,getLooper方法内部通过加锁并有条件的wait()来一直等待mLooper不为空。在run方法中可以看到如果mLooper被初始化后会调用notifyAll()来通知所有正处于wait的线程继续执行,这时getLooper方法中的return mLooper;将得到执行。

你可能感兴趣的:(源码,android,service,启动服务)