滿足 DeadLine 約束條件的 Job 基本會(huì)被立即執(zhí)行，無論別的約束條件是否滿足

滿足 Time 約束條件后竞漾，Job 基本會(huì)被移除

該 Controller 中把 Job 移除眯搭，并不會(huì)使 Job 的周期執(zhí)行受到影響；周期性起作用的邏輯在 JobServiceContext 中

一业岁、調(diào)用流程

public JobSchedulerService(Context context) {
    super(context);
    // Create the controllers.
    mControllers = new ArrayList<StateController>();
    mControllers.add(ConnectivityController.get(this));
    mControllers.add(TimeController.get(this));
    mControllers.add(IdleController.get(this));
    mControllers.add(BatteryController.get(this));

    mHandler = new JobSchedulerService.JobHandler(context.getMainLooper());
    mJobSchedulerStub = new JobSchedulerService.JobSchedulerStub();
    mJobs = JobStore.initAndGet(this);
}
|
public static synchronized TimeController get(JobSchedulerService jms) {
    if (mSingleton == null) {
        mSingleton = new TimeController(jms, jms.getContext());
    }
    return mSingleton;
}
|
private TimeController(StateChangedListener stateChangedListener, Context context) {
    super(stateChangedListener, context);
    mDeadlineExpiredAlarmIntent = PendingIntent.getBroadcast(mContext, 0 /* ignored */,
            new Intent(ACTION_JOB_EXPIRED), 0);
    mNextDelayExpiredAlarmIntent = PendingIntent.getBroadcast(mContext, 0 /* ignored */,
            new Intent(ACTION_JOB_DELAY_EXPIRED), 0);

    mNextJobExpiredElapsedMillis = Long.MAX_VALUE;
    mNextDelayExpiredElapsedMillis = Long.MAX_VALUE;

    // Register BR for these intents. 注冊(cè)廣播接收器
    IntentFilter intentFilter = new IntentFilter(ACTION_JOB_EXPIRED);
    intentFilter.addAction(ACTION_JOB_DELAY_EXPIRED);
    mContext.registerReceiver(mAlarmExpiredReceiver, intentFilter);
}

二鳞仙、添加需要追蹤的 Job

public synchronized void maybeStartTrackingJob(JobStatus job) {
    if (job.hasTimingDelayConstraint() || job.hasDeadlineConstraint()) {
        // 首先移除舊 Job
        maybeStopTrackingJob(job);
        // mTrackedJobs sorted asc. by deadline
        ListIterator<JobStatus> it = mTrackedJobs.listIterator(mTrackedJobs.size());
        while (it.hasPrevious()) {
            JobStatus ts = it.previous();
            if (ts.getLatestRunTimeElapsed() < job.getLatestRunTimeElapsed()) {
                // Insert
                break;
            }
        }
        // google 是個(gè)坑貨，放錯(cuò)位置了
        it.add(job);
        // 調(diào)整 AlarmManager 下次觸發(fā)時(shí)間
        maybeUpdateAlarms(
                job.hasTimingDelayConstraint() ? job.getEarliestRunTime() : Long.MAX_VALUE,
                job.hasDeadlineConstraint() ? job.getLatestRunTimeElapsed() : Long.MAX_VALUE);
    }
}

1. 調(diào)整最早及最遲可以執(zhí)行 Job 的時(shí)間

private void maybeUpdateAlarms(long delayExpiredElapsed, long deadlineExpiredElapsed) {
    if (delayExpiredElapsed < mNextDelayExpiredElapsedMillis) {
        setDelayExpiredAlarm(delayExpiredElapsed);
    }
    if (deadlineExpiredElapsed < mNextJobExpiredElapsedMillis) {
        setDeadlineExpiredAlarm(deadlineExpiredElapsed);
    }
}

/**
 * Set an alarm with the {@link android.app.AlarmManager} for the next time at which a job's
 * delay will expire.
 * This alarm <b>will not</b> wake up the phone.
 */
private void setDelayExpiredAlarm(long alarmTimeElapsedMillis) {
    // 如果 alarmTimeElapsedMillis 已經(jīng)小于當(dāng)前時(shí)間笔时，則使用當(dāng)前時(shí)間
    alarmTimeElapsedMillis = maybeAdjustAlarmTime(alarmTimeElapsedMillis);
    mNextDelayExpiredElapsedMillis = alarmTimeElapsedMillis;
    updateAlarmWithPendingIntent(mNextDelayExpiredAlarmIntent, mNextDelayExpiredElapsedMillis);
}


/**
 * Set an alarm with the {@link android.app.AlarmManager} for the next time at which a job's
 * deadline will expire.
 * This alarm <b>will</b> wake up the phone.
 * 這里注釋應(yīng)該寫錯(cuò)了棍好，不會(huì)喚醒手機(jī)
 */
private void setDeadlineExpiredAlarm(long alarmTimeElapsedMillis) {
    // 如果 alarmTimeElapsedMillis 已經(jīng)小于當(dāng)前時(shí)間，則使用當(dāng)前時(shí)間
    alarmTimeElapsedMillis = maybeAdjustAlarmTime(alarmTimeElapsedMillis);
    mNextJobExpiredElapsedMillis = alarmTimeElapsedMillis;
    updateAlarmWithPendingIntent(mDeadlineExpiredAlarmIntent, mNextJobExpiredElapsedMillis);
}

2. 調(diào)整 AlarmManager 觸發(fā)時(shí)間

private void updateAlarmWithPendingIntent(PendingIntent pi, long alarmTimeElapsed) {
    ensureAlarmService();
    if (alarmTimeElapsed == Long.MAX_VALUE) {
        mAlarmService.cancel(pi);
    } else {
        /**
         * This alarm does not wake the device up; if it goes off while the device
         * is asleep, it will not be delivered until the next time the device
         * wakes up.
         * 該鬧鐘不會(huì)喚醒手機(jī)
         */
        mAlarmService.set(AlarmManager.ELAPSED_REALTIME, alarmTimeElapsed, pi);
    }
}

三允耿、移除不再需要追蹤的 Job

/**
 * When we stop tracking a job, we only need to update our alarms if the job we're no longer
 * tracking was the one our alarms were based off of.
 * Really an == comparison should be enough, but why play with fate? We'll do <=.
 * 注釋好搞笑借笙，but, yes, why play with fate!
 */
@Override
public synchronized void maybeStopTrackingJob(JobStatus job) {
    if (mTrackedJobs.remove(job)) {
        // 查看是否有滿足時(shí)間約束條件的 Job, 之后觸發(fā)執(zhí)行所有滿足約束條件的 Job
        // 重置 AlarmManager 下次觸發(fā)時(shí)間
        checkExpiredDelaysAndResetAlarm();
        checkExpiredDeadlinesAndResetAlarm();
    }
}

1. 檢查滿足最早可以執(zhí)行約束條件的 Job, 重置 AlarmManager 下次觸發(fā)時(shí)間

/**
 * Handles alarm that notifies us that a job's delay has expired. Iterates through the list of
 * tracked jobs and marks them as ready as appropriate.
 */
private synchronized void checkExpiredDelaysAndResetAlarm() {
    final long nowElapsedMillis = SystemClock.elapsedRealtime();
    long nextDelayTime = Long.MAX_VALUE;
    boolean ready = false;
    Iterator<JobStatus> it = mTrackedJobs.iterator();
    while (it.hasNext()) {
        final JobStatus job = it.next();
        if (!job.hasTimingDelayConstraint()) {
            continue;
        }
        final long jobDelayTime = job.getEarliestRunTime();
        if (jobDelayTime <= nowElapsedMillis) { // 該 Job 滿足了該約束條件
            job.timeDelayConstraintSatisfied.set(true);
            if (canStopTrackingJob(job)) {
                // Job 已經(jīng)滿足時(shí)間約束條件，不需要再保持追蹤. 注意只是從時(shí)間追蹤隊(duì)列移除较锡，不影響別的追蹤隊(duì)列
                // 此處把 Job 移除业稼，并不會(huì)使 Job 的周期執(zhí)行收到影響；周期性起作用的邏輯在 JobServiceContext 中
                it.remove();
            }
            if (job.isReady()) {
                ready = true;
            }
        } else {  // Keep going through list to get next delay time.
            if (nextDelayTime > jobDelayTime) {
                nextDelayTime = jobDelayTime;
            }
        }
    }
    if (ready) {
        // 觸發(fā) JobSchedulerService 檢查所有滿足執(zhí)行條件的 Job蚂蕴，根據(jù)策略決定是否放入 mPendingJobs低散，隨后執(zhí)行 mPendingJobs 中的 Job
        mStateChangedListener.onControllerStateChanged();
    }
    // 重置 AlarmManager 下次觸發(fā)時(shí)間
    setDelayExpiredAlarm(nextDelayTime);
}

2. 檢查滿足最遲需要執(zhí)行約束條件的 Job 并立即執(zhí)行, 重置 AlarmManager 下次觸發(fā)時(shí)間

/**
 * Checks list of jobs for ones that have an expired deadline, sending them to the JobScheduler
 * if so, removing them from this list, and updating the alarm for the next expiry time.
 */
private synchronized void checkExpiredDeadlinesAndResetAlarm() {
    long nextExpiryTime = Long.MAX_VALUE;
    final long nowElapsedMillis = SystemClock.elapsedRealtime();

    Iterator<JobStatus> it = mTrackedJobs.iterator();
    while (it.hasNext()) {
        JobStatus job = it.next();
        if (!job.hasDeadlineConstraint()) {
            continue;
        }
        final long jobDeadline = job.getLatestRunTimeElapsed();

        if (jobDeadline <= nowElapsedMillis) { // 該 Job 滿足了最遲執(zhí)行約束條件
            job.deadlineConstraintSatisfied.set(true);
            /**
             * 觸發(fā) JobSchedulerService 把該 Job 加入 mPendingJobs，
             * 并檢查所有滿足執(zhí)行條件的 Job 放入 mPendingJobs骡楼，隨后執(zhí)行 mPendingJobs 中的 Job
             */
            mStateChangedListener.onRunJobNow(job);
            // 此處把 Job 移除熔号，并不會(huì)使 Job 的周期執(zhí)行收到影響；周期性起作用的邏輯在 JobServiceContext 中
            it.remove();
        } else {  // Sorted by expiry time, so take the next one and stop.
            nextExpiryTime = jobDeadline;
            break;
        }
    }
    // 重置 AlarmManager 下次觸發(fā)時(shí)間
    setDeadlineExpiredAlarm(nextExpiryTime);
}

3. onRunJobNow(job)執(zhí)行滿足最遲需要執(zhí)行約束條件的 Job流程

mStateChangedListener.onRunJobNow(job);
|
@Override
public void onRunJobNow(JobStatus jobStatus) {
    mHandler.obtainMessage(MSG_JOB_EXPIRED, jobStatus).sendToTarget();
}

private class JobHandler extends Handler {
    @Override
    public void handleMessage(Message message) {
        switch (message.what) {
            case MSG_JOB_EXPIRED:
                synchronized (mJobs) {
                    JobStatus runNow = (JobStatus) message.obj;
                    // runNow can be null, which is a controller's way of indicating that its
                    // state is such that all ready jobs should be run immediately.
                    if (runNow != null && !mPendingJobs.contains(runNow) && mJobs.containsJob(runNow)) {
                        mPendingJobs.add(runNow);
                    }
                    // 檢查所有滿足執(zhí)行條件的 Job君编，放入 mPendingJobs跨嘉，隨后執(zhí)行
                    queueReadyJobsForExecutionLockedH();
                }
                break;
        }
        // 從 mPendingJobs 中取出 Job 執(zhí)行
        maybeRunPendingJobsH();
        // Don't remove JOB_EXPIRED in case one came along while processing the queue.
        removeMessages(MSG_CHECK_JOB);
    }
}

四、接收到來自 AlarmManager 的廣播的執(zhí)行流程

private final BroadcastReceiver mAlarmExpiredReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        // A job has just expired, so we run through the list of jobs that we have and
        // notify our StateChangedListener.
        if (ACTION_JOB_EXPIRED.equals(intent.getAction())) {
            checkExpiredDeadlinesAndResetAlarm();
        } else if (ACTION_JOB_DELAY_EXPIRED.equals(intent.getAction())) {
            checkExpiredDelaysAndResetAlarm();
        }
    }
};