IntentService源码分析

    private volatile Looper mServiceLooper; // 这2者都是和HandlerThread关联的，只是没明白这里为什么需要volatile关键字
    private volatile ServiceHandler mServiceHandler; // 看起来他们都只是在UI线程中被访问了，似乎并没有什么并发问题。。。
    private String mName;
    private boolean mRedelivery;

    /**
     * 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;
    }

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) { // 基于我们前面关于Handler的介绍，这些代码都很容易理解
            onHandleIntent((Intent)msg.obj); // 注意这个Template方法，这是我们的子类中真正处理请求的地方
            stopSelf(msg.arg1);              // 注意看这里调用的是带参数的stopSelf并不是无参版本的stopSelf()，
        }                                    // 这是因为IntentService并不是处理完一个请求就退出，而是所有请求。
    }

    /**
     * Sets intent redelivery preferences.  Usually called from the constructor
     * with your preferred semantics.
     *
     * <p>If enabled is true,
     * {@link #onStartCommand(Intent, int, int)} will return
     * {@link Service#START_REDELIVER_INTENT}, so if this process dies before
     * {@link #onHandleIntent(Intent)} returns, the process will be restarted
     * and the intent redelivered.  If multiple Intents have been sent, only
     * the most recent one is guaranteed to be redelivered.
     *
     * <p>If enabled is false (the default),
     * {@link #onStartCommand(Intent, int, int)} will return
     * {@link Service#START_NOT_STICKY}, and if the process dies, the Intent
     * dies along with it.
     */
    public void setIntentRedelivery(boolean enabled) { // 设置是否重新发送Intent，一般在ctor中设置
        mRedelivery = enabled; // 具体内容请详细阅读方法的doc
    }

    @Override
    public void onCreate() { // 此方法只在第一次需要创建service的时候调用
        // 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(); // 启动接下来处理客户端异步请求的HandlerThread

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper); // 拿到与之关联的Handler，用来向它发送待处理的消息（即客户端请求）
    }

    @Override
    public void onStart(Intent intent, int startId) { // 其所作的事情就是根据参数获得一个对应的Message，
        Message msg = mServiceHandler.obtainMessage(); // send一个Message而已，消息的处理会在ServiceHandler
        msg.arg1 = startId;                            // 的handleMessage方法中进行
        msg.obj = intent;                             // 稍后我们分析下这里的startId咋来的 
        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; // 根据mRedelivery返回不同的策略值
    }

    private int lastStartId;    // identifier of most recent start request.

    public int getLastStartId() {
        return lastStartId;
    }

    public int makeNextStartId() { // 此方法的调用是在ActiveServices中
        lastStartId++;
        if (lastStartId < 1) { // 通过代码我们可以看到startId是从1开始的正整数，每次+1
            lastStartId = 1;   // 你可以理解成客户端请求的次数(即startService调用的次数)
        }
        return lastStartId;
    }

    /**
     * Stop the service, if it was previously started.  This is the same as
     * calling {@link android.content.Context#stopService} for this particular service.
     *  
     * @see #stopSelfResult(int)
     */
    public final void stopSelf() { // 内部调用参数为-1的版本，此方法会停止service
        stopSelf(-1);
    }

    /**
     * Old version of {@link #stopSelfResult} that doesn‘t return a result.
     *  
     * @see #stopSelfResult
     */
    public final void stopSelf(int startId) { // 参数startId要么是-1要么是从1开始的正整数，只有它等于我们最后一次调用
        if (mActivityManager == null) {       // startService时，onStartCommand里传递进来的startId值时，
            return;                           // service才会停止，否则并不会停止service。service会在处理完
        }                                     // 所有的客户端请求后自动停止。比如客户端调用了10次startService来
        try {                                 // 发出多个请求，那么只有当这里的startId == 10的时候，service才会停止，
            mActivityManager.stopServiceToken(// 其onDestroy方法才会被调用。另外由于我们的请求总是串行处理的，所以永远不会
                    new ComponentName(this, mClassName), mToken, startId); // 出现先stopSelf(10)再stopSelf(9)这种情况。
        } catch (RemoteException ex) {
        }
    }
    
    /**
     * Stop the service if the most recent time it was started was 
     * <var>startId</var>.  This is the same as calling {@link 
     * android.content.Context#stopService} for this particular service but allows you to 
     * safely avoid stopping if there is a start request from a client that you 
     * haven‘t yet seen in {@link #onStart}. 
     * 
     * <p><em>Be careful about ordering of your calls to this function.</em>.
     * If you call this function with the most-recently received ID before
     * you have called it for previously received IDs, the service will be
     * immediately stopped anyway.  If you may end up processing IDs out
     * of order (such as by dispatching them on separate threads), then you
     * are responsible for stopping them in the same order you received them.</p>
     * 
     * @param startId The most recent start identifier received in {@link 
     *                #onStart}.
     * @return Returns true if the startId matches the last start request
     * and the service will be stopped, else false.
     *  
     * @see #stopSelf()
     */
    public final boolean stopSelfResult(int startId) { // 此方法基本同上，不赘述，后面我们刨根问底下stopServiceToken到底咋实现的，
        if (mActivityManager == null) {                // 看看这里startId是-1和正整数到底有啥区别。
            return false;
        }
        try {
            return mActivityManager.stopServiceToken(
                    new ComponentName(this, mClassName), mToken, startId);
        } catch (RemoteException ex) {
        }
        return false;
    }

    @Override
    public void onDestroy() { // 处理完所有客户端请求，stop service的时候会被调到，退出looper。
        mServiceLooper.quit();
    }

    /**
     * Unless you provide binding for your service, you don‘t need to implement this
     * method, because the default implementation returns null. 
     * @see android.app.Service#onBind
     */
    @Override
    public IBinder onBind(Intent intent) { // 当你只是个started service的时候，默认实现就足够了。
        return null;
    }

    /**
     * This method is invoked on the worker thread with a request to process.
     * Only one Intent is processed at a time, but the processing happens on a
     * worker thread that runs independently from other application logic.
     * So, if this code takes a long time, it will hold up other requests to
     * the same IntentService, but it will not hold up anything else.
     * When all requests have been handled, the IntentService stops itself,
     * so you should not call {@link #stopSelf}.
     *
     * @param intent The value passed to {@link
     *               android.content.Context#startService(Intent)}.
     */
    protected abstract void onHandleIntent(Intent intent); // handleMessage中定义的模板方法，也即我们处理请求的逻辑发生的地方

    public boolean stopServiceToken(ComponentName className, IBinder token, // ActivityManagerService.java中的方法
            int startId) {
        synchronized(this) {
            return mServices.stopServiceTokenLocked(className, token, startId);
        }
    }

    boolean stopServiceTokenLocked(ComponentName className, IBinder token, // ActiveServices.java中的方法
            int startId) {
        if (DEBUG_SERVICE) Slog.v(TAG, "stopServiceToken: " + className
                + " " + token + " startId=" + startId);
        ServiceRecord r = findServiceLocked(className, token, UserHandle.getCallingUserId());
        if (r != null) {
            if (startId >= 0) { // 注意这个判断，和我们猜测的一样
                // Asked to only stop if done with all work.  Note that
                // to avoid leaks, we will take this as dropping all
                // start items up to and including this one.
                ServiceRecord.StartItem si = r.findDeliveredStart(startId, false);
                if (si != null) {
                    while (r.deliveredStarts.size() > 0) {
                        ServiceRecord.StartItem cur = r.deliveredStarts.remove(0);
                        cur.removeUriPermissionsLocked();
                        if (cur == si) {
                            break;
                        }
                    }
                }

                if (r.getLastStartId() != startId) { // 这句代码是所有疑惑的答案
                    return false; // 如果不是最后一个请求的startId，直接返回了，并没有往下面执行；
                }                 // 这也就解释了为啥非last startId不能让service停止的原因。

                if (r.deliveredStarts.size() > 0) {
                    Slog.w(TAG, "stopServiceToken startId " + startId
                            + " is last, but have " + r.deliveredStarts.size()
                            + " remaining args");
                }
            }

            synchronized (r.stats.getBatteryStats()) {
                r.stats.stopRunningLocked();
            }
            r.startRequested = false;
            if (r.tracker != null) {
                r.tracker.setStarted(false, mAm.mProcessStats.getMemFactorLocked(),
                        SystemClock.uptimeMillis());
            }
            r.callStart = false;
            final long origId = Binder.clearCallingIdentity();
            bringDownServiceIfNeededLocked(r, false, false); // 真正让service停止的代码
            Binder.restoreCallingIdentity(origId);
            return true;
        }
        return false;
    }