Android进阶系列之3：IntentService

1 IntentService有什么优势和限制?

考虑一个场景：在 Android中点击一个按钮下载一个文件。
常规实现一般都是如此：启动一个Activity，Activity中放置一个按钮，点击按钮，启动一个Service来下载文件。由于UI线程不能进行耗时操作。而Service默认运行在UI线程，所以Service中必须启动一个Thread来下载文件。文件下载完毕以后，我们还需要在手动或者自动的停止这个Service。
回头来看看Service都需要做什么：
1) 启动一个Thread用于下载任务;
2) 下载完成以后，停止Service;
考虑到这样一个简单的任务，需要做这么多繁琐的事情。对于一个懒惰的程序猿，可能会想，是否有方法优化这个操作，让一切变得简单，能让我们提高自己的工作效率。
Android已经考虑到我们的需求，提供IntentService来满足我们的需求。
IntentServie的优势：
1) IntentService会自动启动一个WorkThread来处理后台耗时任务;
2) 后台耗时任务处理完成以后，会自动关闭Service（这样只需要启动IntentService即可，后面就不用关注IntentService的关闭了)
当然IntentService也有其限制：其实现时，多个任务会放到任务队列，顺序执行。所以任务会有先后顺序的限制，如果要几个任务同时并发处理，就不适合使用IntentService了.

以下暂时一个最简单的使用InentService：

2 InentService的简单使用例子

（1）建立一个页面，放置一个按钮，并设置好按钮的点击事件，点击事件为启动IntentService

public class MyActivity extends Activity {
    /**
     * Called when the activity is first created.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Button btn = (Button) findViewById(R.id.btn);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Intent intent1 =  new Intent(MyActivity.this, WorkIntentService.class);
                        intent1.putExtra("arg", "seq_1");
                        startService(intent1);

                        Intent intent2 =  new Intent(MyActivity.this, WorkIntentService.class);
                        intent2.putExtra("arg", "seq_2");
                        startService(intent2);

                        Intent intent3 =  new Intent(MyActivity.this, WorkIntentService.class);
                        intent3.putExtra("arg", "seq_3");
                        startService(intent3);
                    }
                }).start();
            }
        });
    }
}

（2） 实现ServiceIntent

public class WorkIntentService extends IntentService {
    private static final String TAG = "WorkIntentServie";
    public WorkIntentService() {
        super("WorkIntentService");
        setIntentRedelivery(true);
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate");
    }

    @Override
    public void onStart(Intent intent, int startId) {
        super.onStart(intent, startId);
        Log.d(TAG, "onStart startId = " + startId + "; arg = " + intent.getStringExtra("arg"));
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand flags = " + flags + " ; startId = " + startId);
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        Log.d(TAG, "onHandleIntent work : arg = " + intent.getStringExtra("arg"));
    }
}

以上将IntentService的生命周期也打印出来了，onHandleIntent为实际完成任务的地方（这里可以加入诸如文件下载，耗时计算等任务）
。
（3）AndroidManifest.xml添加IntentService

 <service android:name=".WorkIntentService"/>

（4） 结果
点击按钮，可以看到结果如下：

08-13 07:18:12.799  10739-10739/com.example.myapp D/WorkIntentServie﹕ onCreate
08-13 07:18:12.800  10739-10739/com.example.myapp D/WorkIntentServie﹕ onStartCommand flags = 0 ; startId = 1
08-13 07:18:12.800  10739-10739/com.example.myapp D/WorkIntentServie﹕ onStart startId = 1; arg = seq_1
08-13 07:18:12.800  10739-11479/com.example.myapp D/WorkIntentServie﹕ onHandleIntent work : arg = seq_1
08-13 07:18:12.800  10739-10739/com.example.myapp D/WorkIntentServie﹕ onStartCommand flags = 0 ; startId = 2
08-13 07:18:12.800  10739-10739/com.example.myapp D/WorkIntentServie﹕ onStart startId = 2; arg = seq_2
08-13 07:18:12.801  10739-10739/com.example.myapp D/WorkIntentServie﹕ onStartCommand flags = 0 ; startId = 3
08-13 07:18:12.801  10739-10739/com.example.myapp D/WorkIntentServie﹕ onStart startId = 3; arg = seq_3
08-13 07:18:12.801  10739-11479/com.example.myapp D/WorkIntentServie﹕ onHandleIntent work : arg = seq_2
08-13 07:18:12.801  10739-11479/com.example.myapp D/WorkIntentServie﹕ onHandleIntent work : arg = seq_3
08-13 07:18:12.802  10739-10739/com.example.myapp D/WorkIntentServie﹕ onDestroy

从结果分析可知。由于连续三次startService(intent)启动WorkIntentService，中间没有间隔，所以WorkIntentService的onCreate调用一次, onStartCommand分别调用3次，onHandleIntent也会调用3次，而且onHandleIntent也是顺序调用的， 最后完成任务以后，调用一次onDestroy，自己把自己退出。

由此可见，这验证了本文开头所说的IntentService的两个优势：

一个问题： onCreate一直都是只调用一次么？
如果上述代码中，startService之间加入时间间隔，会看到onHandleIntent任务完成以后，会立即调用onDestroy，下一个任务到来时，会再次调用onCreate/onHandleIntent/onDestroy。
所以只有当ServiceIntent中的任务队列有intent任务时，才不会立即退出。只有等所有任务完成以后才会退出。

3 IntentService源码分析

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

从上面可以看到IntentService为Service子类，ServiceHandler继承自Handler，handleMessage调用onHandleIntent处理任务以后，会调用stopSelf，这也就是为什么IntentService完成任务以后，会自动退出。

  @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(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 {@link #onHandleIntent}, which the system calls when the IntentService
     * receives a start request.
     * @see android.app.Service#onStartCommand
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

从onCreate可以看到： IntentService自动创建一个 HandlerThread并启动，所以使用IntentService的时候，不需要手动创建Thread，同时HandlerThread的looper和ServiceHandler关联起来。这样ServiceHandler的消息处理就会在HandlerThread工作线程中（不是UI线程）.
Service启动以后，会自动调用onStartCommand/onStart， onStart会使用ServiceHandler发射消息，并带上intent，这样HandlerThread县城中，ServiceHandler会从消息队列中取出消息并执行。
最后一点也特别重要：onDestroy：ServiceHandler处理完毕所有的消息以后，会调用stopSelf退出，此时会导致onDestroy调用，mServiceLooper.quit()语句可以退出looper。
这样整个循环的建立，完成任务，service退出，looper就全部运转起来了。

   @WorkerThread
    protected abstract void onHandleIntent(Intent intent);

整个IntentService有一个抽象方法onHandleIntent，在使用IntgentService需要实现这个方法，耗时的任务代码就放在这个方法里面。
以上就是IntentService的整个实现原理。