Android之Service自启动流程

 当Service被异常销毁后，默认都会自动重启，但Service的自动重启是如何实现的尼？下面就来梳理一下Service的自动重启流程。
 无论Service是启动还是绑定成功，都会调用ActiveServices的serviceDoneExecutingLocked方法，来看一下这个方法的实现。

    void serviceDoneExecutingLocked(ServiceRecord r, int type, int startId, int res) {
   
        boolean inDestroying = mDestroyingServices.contains(r);
        if (r != null) {
   
            if (type == ActivityThread.SERVICE_DONE_EXECUTING_START) {
   
                // This is a call from a service start...  take care of
                // book-keeping.
                //默认调用Service的startCommand这个方法
                r.callStart = true;
                switch (res) {
   
                    case Service.START_STICKY_COMPATIBILITY:
                    case Service.START_STICKY: {
   
                        // We are done with the associated start arguments.
                        r.findDeliveredStart(startId, true);
                        // Don't stop if killed.
                        //被异常kill掉，允许重启该Service
                        r.stopIfKilled = false;
                        break;
                    }
                    case Service.START_NOT_STICKY: {
   
                        // We are done with the associated start arguments.
                        r.findDeliveredStart(startId, true);
                        if (r.getLastStartId() == startId) {
   
                            // There is no more work, and this service
                            // doesn't want to hang around if killed.
                            //被异常kill掉，不允许重启该Service
                            r.stopIfKilled = true;
                        }
                        break;
                    }
                    case Service.START_REDELIVER_INTENT: {
   
                        // We'll keep this item until they explicitly
                        // call stop for it, but keep track of the fact
                        // that it was delivered.
                        ServiceRecord.StartItem si = r.findDeliveredStart(startId, false);
                        if (si != null) {
   
                            si.deliveryCount = 0;
                            si.doneExecutingCount++;
                            // Don't stop if killed.
                            //被异常kill掉，不允许重启。但后面会依靠deliveredStarts触发重启
                            r.C= true;
                        }
                        break;
                    }
                    case Service.START_TASK_REMOVED_COMPLETE: {
   
                        // Special processing for onTaskRemoved().  Don't
                        // impact normal onStartCommand() processing.
                        r.findDeliveredStart(startId, true);
                        break;
                    }
                    default:
                        throw new IllegalArgumentException(
                                "Unknown service start result: " + res