在Android開發(fā)中，會(huì)存在這么些場(chǎng)景 : 你需要在稍后的某個(gè)時(shí)間點(diǎn)或者當(dāng)滿足某個(gè)特定的條件時(shí)執(zhí)行一個(gè)任務(wù)，例如當(dāng)設(shè)備接通電源適配器或者連接到WIFI。幸運(yùn)的是在API 21 ( Android 5.0，即Lollipop )中，google提供了一個(gè)新叫做JobScheduler API的組件來處理這樣的場(chǎng)景。

當(dāng)一系列預(yù)置的條件被滿足時(shí)，JobScheduler API為你的應(yīng)用執(zhí)行一個(gè)操作。與AlarmManager不同的是這個(gè)執(zhí)行時(shí)間是不確定的。除此之外，JobScheduler API允許同時(shí)執(zhí)行多個(gè)任務(wù)。這允許你的應(yīng)用執(zhí)行某些指定的任務(wù)時(shí)不需要考慮時(shí)機(jī)控制引起的電池消耗。

JobScheduler簡(jiǎn)單使用

1. 創(chuàng)建Job Service

public class MyJobService extends JobService {
private static final String LOG_TAG ="ms" ;
@Override
public boolean onStartJob(JobParameters params) {
    if (isNetWorkConnected()){
    //在這里執(zhí)行下載任務(wù)
        new SimpleDownloadTask().execute(params);
        return true;
    }
    return false;
}
@Override
public boolean onStopJob(JobParameters params) {
    return false;
}

當(dāng)任務(wù)開始時(shí)會(huì)執(zhí)行onStartJob(JobParameters params)方法，因?yàn)檫@是系統(tǒng)用來觸發(fā)已經(jīng)被執(zhí)行的任務(wù)。正如你所看到的，這個(gè)方法返回一個(gè)boolean值。如果返回值是false,系統(tǒng)假設(shè)這個(gè)方法返回時(shí)任務(wù)已經(jīng)執(zhí)行完畢。如果返回值是true,那么系統(tǒng)假定這個(gè)任務(wù)正要被執(zhí)行，執(zhí)行任務(wù)的重?fù)?dān)就落在了你的肩上。當(dāng)任務(wù)執(zhí)行完畢時(shí)你需要調(diào)用jobFinished(JobParameters params, boolean needsRescheduled)來通知系統(tǒng)

當(dāng)系統(tǒng)接收到一個(gè)取消請(qǐng)求時(shí)，系統(tǒng)會(huì)調(diào)用onStopJob(JobParameters params)方法取消正在等待執(zhí)行的任務(wù)。很重要的一點(diǎn)是如果onStartJob(JobParameters params)返回false,那么系統(tǒng)假定在接收到一個(gè)取消請(qǐng)求時(shí)已經(jīng)沒有正在運(yùn)行的任務(wù)。換句話說，onStopJob(JobParameters params)在這種情況下不會(huì)被調(diào)用。

需要注意的是這個(gè)job service運(yùn)行在你的主線程，這意味著你需要使用子線程，handler, 或者一個(gè)異步任務(wù)來運(yùn)行耗時(shí)的操作以防止阻塞主線程

2. 創(chuàng)建一個(gè)JobScheduler對(duì)象，并關(guān)聯(lián)起來

  //他是系統(tǒng)服務(wù) 
JobScheduler mJobScheduler= (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);

當(dāng)你想創(chuàng)建定時(shí)任務(wù)時(shí)，你可以使用JobInfo.Builder來構(gòu)建一個(gè)JobInfo對(duì)象，然后傳遞給你的Service。JobInfo.Builder接收兩個(gè)參數(shù)，第一個(gè)參數(shù)是你要運(yùn)行的任務(wù)的標(biāo)識(shí)符，第二個(gè)是這個(gè)Service組件的類名。

 ComponentName componentName = new ComponentName(this,MyJobService.class);
   JobInfo job=new JobInfo.Builder(i,componentName)
                .setMinimumLatency(5000)//最小延時(shí) 5秒
                .setOverrideDeadline(60000)
                .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)//任意網(wǎng)絡(luò)
                .build();
  //調(diào)用schedule
        mJobScheduler.schedule(job);

JobInfo其他的設(shè)置方法：

.setMinimumLatency(5000)//5秒 最小延時(shí)、
.setOverrideDeadline(60000)//maximum最多執(zhí)行時(shí)間  
 .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED)//免費(fèi)的網(wǎng)絡(luò)---wifi 藍(lán)牙 USB
.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)//任意網(wǎng)絡(luò)---
  /**
   設(shè)置重試/退避策略，當(dāng)一個(gè)任務(wù)調(diào)度失敗的時(shí)候執(zhí)行什么樣的測(cè)量采取重試。
    initialBackoffMillis:第一次嘗試重試的等待時(shí)間間隔ms
    *backoffPolicy:對(duì)應(yīng)的退避策略。比如等待的間隔呈指數(shù)增長(zhǎng)。
    */
  .setBackoffCriteria(long initialBackoffMillis, int backoffPolicy)
.setBackoffCriteria(JobInfo.MAX_BACKOFF_DELAY_MILLIS, JobInfo.BACKOFF_POLICY_LINEAR)
  //.setPeriodic (long intervalMillis)//設(shè)置執(zhí)行周期，每隔一段時(shí)間間隔任務(wù)最多可以執(zhí)行一次。
//.setPeriodic(long intervalMillis,long flexMillis)//在周期執(zhí)行的末端有一個(gè)flexMiliis長(zhǎng)度的窗口期，任務(wù)就可以在這個(gè)窗口期執(zhí)行。
 //設(shè)置設(shè)備重啟后，這個(gè)任務(wù)是否還要保留。需要權(quán)限：  RECEIVE_BOOT_COMPLETED //ctrl+shift+y/u x
//.setPersisted(boolean isPersisted);
// .setRequiresCharging(boolean )//是否需要充電
// .setRequiresDeviceIdle(boolean)//是否需要等設(shè)備出于空閑狀態(tài)的時(shí)候
// .addTriggerContentUri(uri)//監(jiān)聽uri對(duì)應(yīng)的數(shù)據(jù)發(fā)生改變，就會(huì)觸發(fā)任務(wù)的執(zhí)行。
// .setTriggerContentMaxDelay(long duration)//設(shè)置Content發(fā)生變化一直到任務(wù)被執(zhí)行中間的最大延遲時(shí)間
 //設(shè)置Content發(fā)生變化一直到任務(wù)被執(zhí)行中間的延遲。如果在這個(gè)延遲時(shí)間內(nèi)content發(fā)生了改變，延遲時(shí)間會(huì)重寫計(jì)算。
  // .setTriggerContentUpdateDelay(long durationMilimms)

JobScheduler源碼分析

JobScheduler是系統(tǒng)服務(wù)JobSchedulerService，JobScheduler是一個(gè)抽象類；以下是JobScheduler的源碼：

public abstract class JobScheduler {
public static final int RESULT_FAILURE = 0;
public static final int RESULT_SUCCESS = 1;
//這個(gè)是提交一個(gè)工作任務(wù)JobInfo
public abstract int schedule(JobInfo job);
public abstract int scheduleAsPackage(JobInfo job, String packageName, int userId, String tag);
 //這個(gè)是取消一個(gè)工作任務(wù)
public abstract void cancel(int jobId);
//這個(gè)是取消所有的工作任務(wù)
public abstract void cancelAll();
  //得到所有將來要執(zhí)行的工作任務(wù)
public abstract @NonNull List<JobInfo> getAllPendingJobs();
//根據(jù)Jobid獲得將來要執(zhí)行的工作任務(wù)
public abstract @Nullable JobInfo getPendingJob(int jobId);

}
JobScheduler的實(shí)現(xiàn)類是JobSchedulerImpl;

public class JobSchedulerImpl extends JobScheduler {
IJobScheduler mBinder;

/* package */ JobSchedulerImpl(IJobScheduler binder) {
    mBinder = binder;
}

@Override
public int schedule(JobInfo job) {
    try {
        //這個(gè)mBinder是JobSchedulerService中的IJobScheduler.Stub，
        return mBinder.schedule(job);
    } catch (RemoteException e) {
        return JobScheduler.RESULT_FAILURE;
    }
}

@Override
public void cancel(int jobId) {
    try {
        mBinder.cancel(jobId);
    } catch (RemoteException e) {}

}

@Override
public void cancelAll() {
    try {
        mBinder.cancelAll();
    } catch (RemoteException e) {}

}

@Override
public List<JobInfo> getAllPendingJobs() {
    try {
        return mBinder.getAllPendingJobs();
    } catch (RemoteException e) {
        return null;
    }
}
}

在代碼中 調(diào)用mJobScheduler.schedule(job);其實(shí)是調(diào)了JobScheduler的實(shí)現(xiàn)類JobSchedulerImpl中的schedule方法；然后再調(diào)了mBinder.schedule(job);這個(gè)mBinder就是JobSchedulerService，調(diào)用了JobSchedulerService類里面IJobScheduler.Stub內(nèi)部類的schedule方法；
JobSchedulerService是在哪里啟動(dòng)的呢？先看一下的源碼，從源碼分析JobSchedulerService是一個(gè)系統(tǒng)服務(wù)；

public class JobSchedulerService extends com.android.server.SystemService
    implements StateChangedListener, JobCompletedListener {
static final boolean DEBUG = false;
/** The number of concurrent jobs we run at one time. */
private static final int MAX_JOB_CONTEXTS_COUNT
        = ActivityManager.isLowRamDeviceStatic() ? 1 : 3;
static final String TAG = "JobSchedulerService";
/** Master list of jobs. */
final JobStore mJobs;

static final int MSG_JOB_EXPIRED = 0;
static final int MSG_CHECK_JOB = 1;
//....省略了n多代碼
}

是系統(tǒng)服務(wù)那應(yīng)該就是在 SystemServer啟動(dòng)的，先看一下SystemServer的源碼；

public final class SystemServer {
private static final String TAG = "SystemServer";
//手機(jī)開機(jī)啟動(dòng)后會(huì)走這個(gè)main方法，然后調(diào)用run方法
public static void main(String[] args) {
    new SystemServer().run();
  }

手機(jī)開機(jī)啟動(dòng)會(huì)走SystemServer中的主函數(shù)main方法，main方法調(diào)用了run方法，下面是run方法中的代碼：

  private void run() {
     //....省略了n多代碼
    // Start services.
    //這里啟動(dòng)一些系統(tǒng)服務(wù)
    try {
        startBootstrapServices();
        startCoreServices();
      //會(huì)走這個(gè)
        startOtherServices();
    } catch (Throwable ex) {
        Slog.e("System", "******************************************");
        Slog.e("System", "************ Failure starting system services", ex);
        throw ex;
    }
 //....省略了n多代碼
}

從run方法可以看出，這里啟動(dòng)了一系列的系統(tǒng)服務(wù)，里面調(diào)用了startOtherServices()方法，那接下看一下startOtherServices方法，向下看:

 private void startOtherServices() {
      //....省略了n多代碼
         mSystemServiceManager.startService(TwilightService.class);

        //這里就是啟動(dòng)JobSchedulerService
      mSystemServiceManager.startService(JobSchedulerService.class);

        if (!disableNonCoreServices) {
            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BACKUP)) {
                mSystemServiceManager.startService(BACKUP_MANAGER_SERVICE_CLASS);
            }

            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_APP_WIDGETS)) {
                mSystemServiceManager.startService(APPWIDGET_SERVICE_CLASS);
            }

            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_VOICE_RECOGNIZERS)) {
                mSystemServiceManager.startService(VOICE_RECOGNITION_MANAGER_SERVICE_CLASS);
            }
        }
 //....省略了n多代碼
}

在startOtherServices方法方法中調(diào)用了mSystemServiceManager.startService(JobSchedulerService.class);這里就啟動(dòng)了JobSchedulerService服務(wù)；接下來我們分析JobSchedulerService的源碼；
先看一下JobSchedulerService的構(gòu)造方法：

public JobSchedulerService(Context context) {
    super(context);
    // Create the controllers.
    mControllers = new ArrayList<StateController>();
    //以下控制類都是繼承了StateController類
    //網(wǎng)絡(luò)聯(lián)接控制類
    mControllers.add(ConnectivityController.get(this));
  //時(shí)間控制類
    mControllers.add(TimeController.get(this));
  //延時(shí)控制類
    mControllers.add(IdleController.get(this));
    //電量控制類
    mControllers.add(BatteryController.get(this));
    mControllers.add(AppIdleController.get(this));

    mHandler = new JobHandler(context.getMainLooper());
  //new了IJobScheduler.Stub，這個(gè)其實(shí)就是前面JobSchedulerImpl類中mBinder，這里用到了進(jìn)程間通信binder機(jī)制，不明白的可能先學(xué)習(xí)一下進(jìn)程間通信機(jī)制；
    mJobSchedulerStub = new JobSchedulerStub();
    mJobs = JobStore.initAndGet(this);
}

前面提到調(diào)用mBinder.schedule(job);其實(shí)是調(diào)用了JobSchedulerService類里面IJobScheduler.Stub內(nèi)部類的schedule方法；接下看一下這個(gè)方法：

final class JobSchedulerStub extends IJobScheduler.Stub {
   //....省略了n多代碼
    @Override
    public int schedule(JobInfo job) throws RemoteException {
        if (DEBUG) {
            Slog.d(TAG, "Scheduling job: " + job.toString());
        }
        //這里做了一個(gè)檢驗(yàn)，非關(guān)鍵代碼
        final int pid = Binder.getCallingPid();
        final int uid = Binder.getCallingUid();
     //....省略了n多代碼
        long ident = Binder.clearCallingIdentity();
        try {
        //這個(gè)是關(guān)鍵代碼，調(diào)用JobSchedulerService中的schedule
            return JobSchedulerService.this.schedule(job, uid);
        } finally {
            Binder.restoreCallingIdentity(ident);
        }
    }

}

從上面代碼看出，是調(diào)用了調(diào)用JobSchedulerService中的schedule方法，好了，看一下JobSchedulerService中的schedule方法；

 public int schedule(JobInfo job, int uId) {
    JobStatus jobStatus = new JobStatus(job, uId);
    cancelJob(uId, job.getId());
    startTrackingJob(jobStatus);
  //通過handler發(fā)消息
    mHandler.obtainMessage(MSG_CHECK_JOB).sendToTarget();
    return JobScheduler.RESULT_SUCCESS;
}

從上面代碼可以看出是通過Handler發(fā)消息，MSG_CHECK_JOB是目標(biāo)源，看一下JobHandler 中的方法

private class JobHandler extends Handler {
    public JobHandler(Looper looper) {
        super(looper);
    }
    @Override
    public void handleMessage(Message message) {
        synchronized (mJobs) {
            if (!mReadyToRock) {
                return;
            }
        }
        switch (message.what) {
            case MSG_JOB_EXPIRED:
                synchronized (mJobs) {
                    JobStatus runNow = (JobStatus) message.obj;
                    if (runNow != null && !mPendingJobs.contains(runNow)
                            && mJobs.containsJob(runNow)) {
                        mPendingJobs.add(runNow);
                    }
                    queueReadyJobsForExecutionLockedH();
                }
                break;
            case MSG_CHECK_JOB:
                synchronized (mJobs) {
                    maybeQueueReadyJobsForExecutionLockedH();
                }
                break;
        }
        maybeRunPendingJobsH();
      
        removeMessages(MSG_CHECK_JOB);
    }

通過Handler發(fā)消息,然后調(diào)用 maybeQueueReadyJobsForExecutionLockedH()方法，

 private void queueReadyJobsForExecutionLockedH() {
        ArraySet<JobStatus> jobs = mJobs.getJobs();
        if (DEBUG) {
            Slog.d(TAG, "queuing all ready jobs for execution:");
        }
      //遍歷要處理的目標(biāo)任務(wù)，把目標(biāo)任務(wù)加到集合PendingJobs中
        for (int i=0; i<jobs.size(); i++) {
            JobStatus job = jobs.valueAt(i);
            if (isReadyToBeExecutedLocked(job)) {
                if (DEBUG) {
                    Slog.d(TAG, "    queued " + job.toShortString());
                }
                //把目標(biāo)任務(wù)加到待處理目標(biāo)任務(wù)集合中
                mPendingJobs.add(job);
            } else if (isReadyToBeCancelledLocked(job)) {
                stopJobOnServiceContextLocked(job);
            }
        }
        if (DEBUG) {
            final int queuedJobs = mPendingJobs.size();
            if (queuedJobs == 0) {
                Slog.d(TAG, "No jobs pending.");
            } else {
                Slog.d(TAG, queuedJobs + " jobs queued.");
            }
        }
    }

這個(gè)方法主要是遍歷將來要處理的工作任務(wù)然后一個(gè)個(gè)加到待處理工作任務(wù)集合中去；這個(gè)方法執(zhí)行完后就會(huì)執(zhí)行JobHandler中的maybeRunPendingJobsH()方法；

 private void maybeRunPendingJobsH() {
        synchronized (mJobs) {
            if (mDeviceIdleMode) {
                // If device is idle, we will not schedule jobs to run.
                return;
            }
            Iterator<JobStatus> it = mPendingJobs.iterator();
            if (DEBUG) {
                Slog.d(TAG, "pending queue: " + mPendingJobs.size() + " jobs.");
            }
            //通過遍歷待處理任務(wù)集合，一個(gè)個(gè)處理待處理任務(wù)
            while (it.hasNext()) {
                JobStatus nextPending = it.next();
                JobServiceContext availableContext = null;
                for (int i=0; i<mActiveServices.size(); i++) {
                    JobServiceContext jsc = mActiveServices.get(i);
                    final JobStatus running = jsc.getRunningJob();
                    if (running != null && running.matches(nextPending.getUid(),
                            nextPending.getJobId())) {
                        // Already running this job for this uId, skip.
                        availableContext = null;
                        break;
                    }
                    if (jsc.isAvailable()) {
                        availableContext = jsc;
                    }
                }
                if (availableContext != null) {
                    if (DEBUG) {
                        Slog.d(TAG, "About to run job "
                                + nextPending.getJob().getService().toString());
                    }
    //這個(gè)方法就是處理待處理任務(wù)的方法
                    if (!availableContext.executeRunnableJob(nextPending)) {
                        if (DEBUG) {
                            Slog.d(TAG, "Error executing " + nextPending);
                        }
                        mJobs.remove(nextPending);
                    }
                    it.remove();
                }
            }
        }
    }
}

從上面源碼分析可以得出，這個(gè)方法通過遍歷待處理任務(wù)集合，處理任務(wù)，這里調(diào)用了availableContext.executeRunnableJob(nextPending)方法，這個(gè)就是處理待處理任務(wù)的方法，接下來我們一起看看這個(gè)方法的源碼，分析下：

public class JobServiceContext extends IJobCallback.Stub   implements ServiceConnection {

 @Override
public void onServiceConnected(ComponentName name, IBinder service) {
    if (!name.equals(mRunningJob.getServiceComponent())) {
        mCallbackHandler.obtainMessage(MSG_SHUTDOWN_EXECUTION).sendToTarget();
        return;
    }
    this.service = IJobService.Stub.asInterface(service);
    final PowerManager pm =
            (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
    mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, mRunningJob.getTag());
//這里也用WakeLock鎖，防止手機(jī)休眠
    mWakeLock.setWorkSource(new WorkSource(mRunningJob.getUid()));
    mWakeLock.setReferenceCounted(false);
    mWakeLock.acquire();
    mCallbackHandler.obtainMessage(MSG_SERVICE_BOUND).sendToTarget();
}
}

JobServiceContext是ServiceConnection，這個(gè)是進(jìn)程間通訊ServiceConnection，通過調(diào)用availableContext.executeRunnableJob(nextPending)方法，會(huì)觸發(fā)調(diào)用onServiceConnected，看到這里應(yīng)該明白了，onServiceConnected方法中的service就是jobservice,里面還用了WakeLock鎖，防止手機(jī)休眠，然后通過Handler發(fā)消息 調(diào)用了handleServiceBoundH()方法，

  /** Start the job on the service. */
    private void handleServiceBoundH() {
        if (DEBUG) {
            Slog.d(TAG, "MSG_SERVICE_BOUND for " + mRunningJob.toShortString());
        }
        if (mVerb != VERB_BINDING) {
            Slog.e(TAG, "Sending onStartJob for a job that isn't pending. "
                    + VERB_STRINGS[mVerb]);
            closeAndCleanupJobH(false /* reschedule */);
            return;
        }
        if (mCancelled.get()) {
            if (DEBUG) {
                Slog.d(TAG, "Job cancelled while waiting for bind to complete. "
                        + mRunningJob);
            }
            closeAndCleanupJobH(true /* reschedule */);
            return;
        }
        try {
            mVerb = VERB_STARTING;
            scheduleOpTimeOut();
      //我們就是要找這個(gè)方法, 看到這里明白了吧，這個(gè)就是調(diào)用了jobService中的startjob
            service.startJob(mParams);
        } catch (RemoteException e) {
            Slog.e(TAG, "Error sending onStart message to '" +
                    mRunningJob.getServiceComponent().getShortClassName() + "' ", e);
        }
    }

從上面源碼可以看出，最終是調(diào)用了jobService中的startjob方法，　這樣就明白了，是如何觸發(fā)調(diào)用jobService中的startjob方法的；

前面在JobSchedulerService中提到了控件類StateController類，這個(gè)是一個(gè)抽象類，有很多實(shí)現(xiàn)類，這個(gè)我只分析一個(gè)ConnectivityController實(shí)現(xiàn)類，其他都差不多，接下來分析一下ConnectivityController源碼：

public class ConnectivityController extends StateController implements
    ConnectivityManager.OnNetworkActiveListener {
private static final String TAG = "JobScheduler.Conn";
//工作任務(wù)狀態(tài)集合
private final List<JobStatus> mTrackedJobs = new LinkedList<JobStatus>();
  //這個(gè)是手機(jī)網(wǎng)絡(luò)連接改變廣播，網(wǎng)絡(luò)發(fā)生改變，會(huì)觸發(fā)這個(gè)廣播
private final BroadcastReceiver mConnectivityChangedReceiver =
        new ConnectivityChangedReceiver();
/** Singleton. */
private static ConnectivityController mSingleton;
private static Object sCreationLock = new Object();
/** Track whether the latest active network is metered. */
private boolean mNetworkUnmetered;
/** Track whether the latest active network is connected. */
private boolean mNetworkConnected;

public static ConnectivityController get(JobSchedulerService jms) {
    synchronized (sCreationLock) {
        if (mSingleton == null) {
            mSingleton = new ConnectivityController(jms, jms.getContext());
        }
        return mSingleton;
    }
}

private ConnectivityController(StateChangedListener stateChangedListener, Context context) {
    super(stateChangedListener, context);
    // Register connectivity changed BR.
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
    mContext.registerReceiverAsUser(
            mConnectivityChangedReceiver, UserHandle.ALL, intentFilter, null, null);
    ConnectivityService cs =
            (ConnectivityService)ServiceManager.getService(Context.CONNECTIVITY_SERVICE);
    if (cs != null) {
        if (cs.getActiveNetworkInfo() != null) {
            mNetworkConnected = cs.getActiveNetworkInfo().isConnected();
        }
        mNetworkUnmetered = mNetworkConnected && !cs.isActiveNetworkMetered();
    }
}

@Override
public void maybeStartTrackingJob(JobStatus jobStatus) {
    if (jobStatus.hasConnectivityConstraint() || jobStatus.hasUnmeteredConstraint()) {
        synchronized (mTrackedJobs) {
            jobStatus.connectivityConstraintSatisfied.set(mNetworkConnected);
            jobStatus.unmeteredConstraintSatisfied.set(mNetworkUnmetered);
            mTrackedJobs.add(jobStatus);
        }
    }
}

@Override
public void maybeStopTrackingJob(JobStatus jobStatus) {
    if (jobStatus.hasConnectivityConstraint() || jobStatus.hasUnmeteredConstraint()) {
        synchronized (mTrackedJobs) {
            mTrackedJobs.remove(jobStatus);
        }
    }
}

/**
 * @param userId Id of the user for whom we are updating the connectivity state.
 */
private void updateTrackedJobs(int userId) {
    synchronized (mTrackedJobs) {
        boolean changed = false;
        for (JobStatus js : mTrackedJobs) {
            if (js.getUserId() != userId) {
                continue;
            }
            boolean prevIsConnected =
                    js.connectivityConstraintSatisfied.getAndSet(mNetworkConnected);
            boolean prevIsMetered = js.unmeteredConstraintSatisfied.getAndSet(mNetworkUnmetered);
            if (prevIsConnected != mNetworkConnected || prevIsMetered != mNetworkUnmetered) {
                changed = true;
            }
        }
        if (changed) {
            mStateChangedListener.onControllerStateChanged();
        }
    }
}

/**
 * We know the network has just come up. We want to run any jobs that are ready.
 */
public synchronized void onNetworkActive() {
    synchronized (mTrackedJobs) {
        for (JobStatus js : mTrackedJobs) {
            if (js.isReady()) {
                if (DEBUG) {
                    Slog.d(TAG, "Running " + js + " due to network activity.");
                }
                mStateChangedListener.onRunJobNow(js);
            }
        }
    }
}

class ConnectivityChangedReceiver extends BroadcastReceiver {
    /**
     * We'll receive connectivity changes for each user here, which we process independently.
     * We are only interested in the active network here. We're only interested in the active
     * network, b/c the end result of this will be for apps to try to hit the network.
     * @param context The Context in which the receiver is running.
     * @param intent The Intent being received.
     */
    // TODO: Test whether this will be called twice for each user.
    @Override
    public void onReceive(Context context, Intent intent) {
        if (DEBUG) {
            Slog.d(TAG, "Received connectivity event: " + intent.getAction() + " u"
                    + context.getUserId());
        }
        final String action = intent.getAction();
        if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
            final int networkType =
                    intent.getIntExtra(ConnectivityManager.EXTRA_NETWORK_TYPE,
                            ConnectivityManager.TYPE_NONE);
            // Connectivity manager for THIS context - important!
            final ConnectivityManager connManager = (ConnectivityManager)
                    context.getSystemService(Context.CONNECTIVITY_SERVICE);
            final NetworkInfo activeNetwork = connManager.getActiveNetworkInfo();
            final int userid = context.getUserId();
            // This broadcast gets sent a lot, only update if the active network has changed.
            if (activeNetwork == null) {
            //網(wǎng)絡(luò)未聯(lián)接
                mNetworkUnmetered = false;
                mNetworkConnected = false;
                updateTrackedJobs(userid);
            } else if (activeNetwork.getType() == networkType) {
                mNetworkUnmetered = false;
                mNetworkConnected = !intent.getBooleanExtra(
                        ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);
                if (mNetworkConnected) {  // No point making the call if we know there's no conn.
                    mNetworkUnmetered = !connManager.isActiveNetworkMetered();
                }
            //更新工作任務(wù)
                updateTrackedJobs(userid);
            }
        } else {
            if (DEBUG) {
                Slog.d(TAG, "Unrecognised action in intent: " + action);
            }
        }
    }
};

@Override
public void dumpControllerState(PrintWriter pw) {
    pw.println("Conn.");
    pw.println("connected: " + mNetworkConnected + " unmetered: " + mNetworkUnmetered);
    for (JobStatus js: mTrackedJobs) {
        pw.println(String.valueOf(js.hashCode()).substring(0, 3) + ".."
                + ": C=" + js.hasConnectivityConstraint()
                + ", UM=" + js.hasUnmeteredConstraint());
    }
}
　}

上面是網(wǎng)絡(luò)聯(lián)接控制類ConnectivityController，當(dāng)網(wǎng)絡(luò)發(fā)生改變時(shí)，會(huì)觸發(fā)網(wǎng)絡(luò)連接改變廣播，然后調(diào)用updateTrackedJobs(userid)方法，在updateTrackedJobs方法中，會(huì)判斷網(wǎng)絡(luò)是否有改變，有改變的會(huì)調(diào) mStateChangedListener.onControllerStateChanged()方法;這樣又調(diào)用了JobSchedulerService類中onControllerStateChanged方法：

  @Override
public void onControllerStateChanged() {
    mHandler.obtainMessage(MSG_CHECK_JOB).sendToTarget();
}

在onControllerStateChanged方法中通過handler發(fā)消息，然后調(diào)用了maybeQueueReadyJobsForExecutionLockedH();

 private void maybeQueueReadyJobsForExecutionLockedH() {
        int chargingCount = 0;
        int idleCount =  0;
        int backoffCount = 0;
        int connectivityCount = 0;
        List<JobStatus> runnableJobs = new ArrayList<JobStatus>();
        ArraySet<JobStatus> jobs = mJobs.getJobs();
        for (int i=0; i<jobs.size(); i++) {
            JobStatus job = jobs.valueAt(i);
            if (isReadyToBeExecutedLocked(job)) {
                if (job.getNumFailures() > 0) {
                    backoffCount++;
                }
                if (job.hasIdleConstraint()) {
                    idleCount++;
                }
                if (job.hasConnectivityConstraint() || job.hasUnmeteredConstraint()) {
                    connectivityCount++;
                }
                if (job.hasChargingConstraint()) {
                    chargingCount++;
                }
                runnableJobs.add(job);
            } else if (isReadyToBeCancelledLocked(job)) {
                stopJobOnServiceContextLocked(job);
            }
        }
        if (backoffCount > 0 ||
                idleCount >= MIN_IDLE_COUNT ||
                connectivityCount >= MIN_CONNECTIVITY_COUNT ||
                chargingCount >= MIN_CHARGING_COUNT ||
                runnableJobs.size() >= MIN_READY_JOBS_COUNT) {
            if (DEBUG) {
                Slog.d(TAG, "maybeQueueReadyJobsForExecutionLockedH: Running jobs.");
            }
            for (int i=0; i<runnableJobs.size(); i++) {
          //把待處理的工作任務(wù)加到集合中去
                mPendingJobs.add(runnableJobs.get(i));
            }
        } else {
            if (DEBUG) {
                Slog.d(TAG, "maybeQueueReadyJobsForExecutionLockedH: Not running anything.");
            }
        }
        if (DEBUG) {
            Slog.d(TAG, "idle=" + idleCount + " connectivity=" +
            connectivityCount + " charging=" + chargingCount + " tot=" +
                    runnableJobs.size());
        }
    }

通過上面方法，把待處理的工作任務(wù)加到集合中，然后再調(diào) maybeRunPendingJobsH();這個(gè)前面已提到過，就不再說了，一樣的；

好了，從頭開始把JobScheduler源碼分析了一遍，應(yīng)該很明白了JobScheduler的工作原理．

本人做android開發(fā)多年,以后會(huì)陸續(xù)更新關(guān)于android高級(jí)UI,NDK開發(fā),性能優(yōu)化等文章,更多請(qǐng)關(guān)注我的微信公眾號(hào):謝謝!

請(qǐng)掃公眾號(hào)二維碼.jpg