前言

上篇文章JobScheduler 详解一讲述了 JobScheduler 的服务启动，本篇文章将继续上篇文章，以 TimeController 为例，讲述 JobScheduler 的 schedule 和 cancel 流程。仍旧使用上篇文章给出的 demo：

private static ComponentName sService = new ComponentName("com.example.mi.myjobtest", MyJobService.class.getName()); public static void schedule(Context context) { JobScheduler js = (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE); JobInfo job = new JobInfo.Builder(JOB_ID, sService) .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED)//网络条件，默认值NETWORK_TYPE_NONE .setPeriodic(DAY_TIME)//任务执行周期 .setPersisted(true)//设备重启后是否继续执行 .setRequiresCharging(true)//设置是否需要充电 .build(); js.schedule(job); }

一、JobScheduler 的 schedule 流程

先给出 JobScheduler 的 schedule 流程时序图如下:

点击查看大图

1.1 JobSchedulerService.schedule

JobSchedulerService.java

public int schedule(JobInfo job, int uId) { JobStatus jobStatus = new JobStatus(job, uId); cancelJob(uId, job.getId()); ... startTrackingJob(jobStatus); mHandler.obtainMessage(MSG_CHECK_JOB).sendToTarget(); return JobScheduler.RESULT_SUCCESS; }

1.1.1 创建 JobStatus

JobStatus.java

/** Create a newly scheduled job. */ public JobStatus(JobInfo job, int uId) { this(job, uId, 0); final long elapsedNow = SystemClock.elapsedRealtime(); if (job.isPeriodic()) {// 执行过 setPeriodic() earliestRunTimeElapsedMillis = elapsedNow; latestRunTimeElapsedMillis = elapsedNow + job.getIntervalMillis(); } else { earliestRunTimeElapsedMillis = job.hasEarlyConstraint() ? elapsedNow + job.getMinLatencyMillis() : NO_EARLIEST_RUNTIME; latestRunTimeElapsedMillis = job.hasLateConstraint() ? elapsedNow + job.getMaxExecutionDelayMillis() : NO_LATEST_RUNTIME; } }

1.2 JobSchedulerService.cancelJob

JobSchedulerService.java

public void cancelJob(int uid, int jobId) { JobStatus toCancel; synchronized (mJobs) { // 根据 uid 和 jobId 来查找相应的 JobStatus toCancel = mJobs.getJobByUidAndJobId(uid, jobId); } if (toCancel != null) { cancelJobImpl(toCancel); } }

1.3 JobSchedulerService.startTrackingJob

JobSchedulerService.java

private void startTrackingJob(JobStatus jobStatus) { boolean update; boolean rocking; synchronized (mJobs) { // 把 jobStatus 添加到 mJobs 中 update = mJobs.add(jobStatus); // mReadyToRock 在 phase600 是变为 true rocking = mReadyToRock; } if (rocking) { for (int i=0; i<mControllers.size(); i++) { StateController controller = mControllers.get(i); if (update) { controller.maybeStopTrackingJob(jobStatus); } // 检查是否需要将该任务添加到相应的追踪控制器 controller.maybeStartTrackingJob(jobStatus); } } }

执行完此步之后，通过 JobHandler 发送 MSG_CHECK_JOB 消息，接下来进入其 handleMessage

1.4 JobSchedulerService.JobHandler

1.4.1 handleMessage

JobSchedulerService.java :: JobHandler

private class JobHandler extends Handler { @Override public void handleMessage(Message message) { ... switch (message.what) { case MSG_JOB_EXPIRED: ... break; case MSG_CHECK_JOB: synchronized (mJobs) { // Check the list of jobs and run some of them if we feel inclined. maybeQueueReadyJobsForExecutionLockedH(); } break; case MSG_STOP_JOB: cancelJobImpl((JobStatus)message.obj); break; } maybeRunPendingJobsH(); removeMessages(MSG_CHECK_JOB); } }

1.4.2 maybeQueueReadyJobsForExecutionLockedH

JobSchedulerService.java :: JobHandler

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++; } //将所有 ready 的 jobs 加入 runnableJobs 队列 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) { for (int i=0; i<runnableJobs.size(); i++) { //加入到 mPendingJobs 队列 mPendingJobs.add(runnableJobs.get(i)); } } }

该方法实现的功能是： * 先将所有 ready 的 jobs 加入 runnableJobs 队列中 * 如果满足发送条件，那么将 runnableJobs 中的所有 jobStatus 加入到 mPendingJobs 中

1.4.3 isReadyToBeExecutedLocked

JobSchedulerService.java :: JobHandler

private boolean isReadyToBeExecutedLocked(JobStatus job) { final boolean jobReady = job.isReady(); final boolean jobPending = mPendingJobs.contains(job); final boolean jobActive = isCurrentlyActiveLocked(job); final boolean userRunning = mStartedUsers.contains(job.getUserId()); return userRunning && jobReady && !jobPending && !jobActive; }

只有当用户是运行的、job 满足触发条件、job 不在 mPendingJobs 队列中、job 不在运行中时才会返回 true

1.4.4 maybeRunPendingJobsH

JobSchedulerService.java :: JobHandler

private void maybeRunPendingJobsH() { synchronized (mJobs) { ... Iterator<JobStatus> it = mPendingJobs.iterator(); 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 (!availableContext.executeRunnableJob(nextPending)) { // 执行出错，在 mJobs 中删除 mJobs.remove(nextPending); } it.remove(); } } } }

此段代码的作用是找一个 available 的 JobServiceContext 来运行 nextPending job (如果 job 已经在运行中了则跳过)

1.5 executeRunnableJob

JobServiceContext.java

boolean executeRunnableJob(JobStatus job) { synchronized (mLock) { mRunningJob = job; // 是否达到 Deadline final boolean isDeadlineExpired = job.hasDeadlineConstraint() && (job.getLatestRunTimeElapsed() < SystemClock.elapsedRealtime()); mParams = new JobParameters(this, job.getJobId(), job.getExtras(), isDeadlineExpired); mExecutionStartTimeElapsed = SystemClock.elapsedRealtime(); mVerb = VERB_BINDING; scheduleOpTimeOut(); final Intent intent = new Intent().setComponent(job.getServiceComponent()); boolean binding = mContext.bindServiceAsUser(intent, this, Context.BIND_AUTO_CREATE | Context.BIND_NOT_FOREGROUND, new UserHandle(job.getUserId()));; if (!binding) { mRunningJob = null; mParams = null; mExecutionStartTimeElapsed = 0L; mVerb = VERB_FINISHED; removeOpTimeOut(); return false; } try { mBatteryStats.noteJobStart(job.getName(), job.getUid()); } catch (RemoteException e) { } // 正在执行 job 置为 false mAvailable = false; return true; } }

这是 system_server 进程的主线程来执行 bind Service，从而拉起目标进程，服务启动后会回调到发起端的 onServiceConnected

1.5.1 onServiceConnected

JobServiceContext.java

public void onServiceConnected(ComponentName name, IBinder service) { JobStatus runningJob; synchronized (mLock) { // 即为上面执行的 job runningJob = mRunningJob; } if (runningJob == null || !name.equals(runningJob.getServiceComponent())) { mCallbackHandler.obtainMessage(MSG_SHUTDOWN_EXECUTION).sendToTarget(); return; } // 获取远程 JobService 的代理端 // 后续会调用 service.startJob this.service = IJobService.Stub.asInterface(service); ... mCallbackHandler.obtainMessage(MSG_SERVICE_BOUND).sendToTarget(); }

this.service是指获取远程 IJobService 的代理端，mCallbackHandler 运行在 system_server 的主线程

1.5.2 Send MSG_SERVICE_BOUND

JobServiceContext.java :: JobServiceHandler

private class JobServiceHandler extends Handler { public void handleMessage(Message message) { switch (message.what) { case MSG_SERVICE_BOUND: removeOpTimeOut(); handleServiceBoundH(); break; ... } } }

1.5.3 handleServiceBoundH

JobServiceContext.java :: JobServiceHandler

private void handleServiceBoundH() { if (mVerb != VERB_BINDING) { closeAndCleanupJobH(false /* reschedule */); return; } if (mCancelled.get()) { closeAndCleanupJobH(true /* reschedule */); return; } try { mVerb = VERB_STARTING; scheduleOpTimeOut(); service.startJob(mParams); } catch (RemoteException e) { ... } }

此处的service是由【小节1.5.1】所赋值，是指 app 端 IJobService 的代理类。经过 binder call 回到app进程

1.6 JobService.startJob

JobService.java

public abstract class JobService extends Service { /** Binder for this service. */ IJobService mBinder = new IJobService.Stub() { @Override public void startJob(JobParameters jobParams) { ensureHandler(); Message m = Message.obtain(mHandler, MSG_EXECUTE_JOB, jobParams); m.sendToTarget(); } @Override public void stopJob(JobParameters jobParams) { ensureHandler(); Message m = Message.obtain(mHandler, MSG_STOP_JOB, jobParams); m.sendToTarget(); } }; }

由于 JobService 运行在 app 端所在进程，那么此处的 mHandler 便是指app进程的主线程。

1.7 JobService.JobHandler

JobService.java :: JobHandler

class JobHandler extends Handler { ... public void handleMessage(Message msg) { final JobParameters params = (JobParameters) msg.obj; switch (msg.what) { case MSG_EXECUTE_JOB: boolean workOngoing = JobService.this.onStartJob(params); ackStartMessage(params, workOngoing); break; case MSG_STOP_JOB: ... case MSG_JOB_FINISHED:... default: break; } } }

二、JobScheduler 的 cancel 流程

2.1 JobSchedulerStub.cancel

JobSchedulerService.java ::JobSchedulerStub

final class JobSchedulerStub extends IJobScheduler.Stub { public void cancel(int jobId) throws RemoteException { final int uid = Binder.getCallingUid(); long ident = Binder.clearCallingIdentity(); try { JobSchedulerService.this.cancelJob(uid, jobId); } finally { Binder.restoreCallingIdentity(ident); } } @Override public void cancelAll() throws RemoteException { final int uid = Binder.getCallingUid(); long ident = Binder.clearCallingIdentity(); try { JobSchedulerService.this.cancelJobsForUid(uid, true); } finally { Binder.restoreCallingIdentity(ident); } } }

2.2 JobSchedulerService.cancelJob

JobSchedulerService.java

public void cancelJob(int uid, int jobId) { JobStatus toCancel; synchronized (mJobs) { toCancel = mJobs.getJobByUidAndJobId(uid, jobId); } if (toCancel != null) { cancelJobImpl(toCancel); } } public void cancelJobsForUid(int uid, boolean forceAll) { List<JobStatus> jobsForUid; synchronized (mJobs) { jobsForUid = mJobs.getJobsByUid(uid); } for (int i=0; i<jobsForUid.size(); i++) { JobStatus toRemove = jobsForUid.get(i); if (!forceAll) { String packageName = toRemove.getServiceComponent().getPackageName(); try { if (ActivityManagerNative.getDefault().getAppStartMode(uid, packageName) != ActivityManager.APP_START_MODE_DISABLED) { continue; } } catch (RemoteException e) { } } cancelJobImpl(toRemove); } }

由上可知： * cancel(int jobId) 会调用 cancelJob(int uid, int jobId)，cancelAll() 会调用 cancelJobsForUid(int uid, true)

2.3 JobSchedulerService.cancelJobImpl

JobSchedulerService.java

private void cancelJobImpl(JobStatus cancelled) { stopTrackingJob(cancelled); synchronized (mJobs) { // Remove from pending queue. mPendingJobs.remove(cancelled); // Cancel if running. stopJobOnServiceContextLocked(cancelled); } }

2.4 JobSchedulerService.stopJobOnServiceContextLocked

private boolean stopJobOnServiceContextLocked(JobStatus job) { for (int i=0; i<mActiveServices.size(); i++) { JobServiceContext jsc = mActiveServices.get(i); final JobStatus executing = jsc.getRunningJob(); if (executing != null && executing.matches(job.getUid(), job.getJobId())) { // 找到匹配的正在执行 job，则取消该 job jsc.cancelExecutingJob(); return true; } } return false; }

作用是找到匹配的正在执行 job，则取消该 job

2.5 JobServiceContext.cancelExecutingJob

JobServiceContext.java

void cancelExecutingJob() { mCallbackHandler.obtainMessage(MSG_CANCEL).sendToTarget(); }

向运行在 system_server 主线程的 JobServiceHandler 发送 MSG_CANCEL 消息，接收到该消息，则执行handleCancelH()

2.6 JobServiceContext.handleCancelH

JobServiceContext.java :: JobServiceHandler

private void handleCancelH() { switch (mVerb) { case VERB_BINDING: case VERB_STARTING: mCancelled.set(true); break; case VERB_EXECUTING: if (hasMessages(MSG_CALLBACK)) { // If the client has called jobFinished, ignore this cancel. return; } sendStopMessageH(); break; case VERB_STOPPING: // Nada. break; default: break; } }

2.7 JobServiceContext.sendStopMessageH

JobServiceContext.java :: JobServiceHandler

private void sendStopMessageH() { removeOpTimeOut(); if (mVerb != VERB_EXECUTING) { closeAndCleanupJobH(false /* reschedule */); return; } try { mVerb = VERB_STOPPING; scheduleOpTimeOut(); service.stopJob(mParams); } catch (RemoteException e) { closeAndCleanupJobH(false /* reschedule */); } }

之后的过程与 schedule 的过程大同小异

总结

由上面的知识点可知无论是 JobScheduler 的 schedule 过程还是 cancel 过程，都涉及到两次的跨进程调用：

1.从 app 进程进入 system_server 进程的 JobSchedulerStub，采用 IJobScheduler 接口

2.system_server 进程的主线程来执行 bind Service，从而拉起目标进程，服务启动后会回调到发起端的 onServiceConnected；this.service 是指获取远程 IJobService 的代理端，然后通过 IJobService 接口，再次调用到 app 端

3.最终会回调目标应用中的 JobService 的 onStartJob() 方法，可见该方法运行在 app 进程的主线程，那么当存在耗时操作时则必须要采用异步方式，让耗时操作交给子线程去执行,这样就不会阻塞 app 的 UI 线程

本文参考博文