JobService的使用介绍

深碍√TFBOYSˉ_ 2022-05-16 01:09 301阅读 0赞

原文链接：[https://blog.csdn.net/allisonchen/article/details/79218713][https_blog.csdn.net_allisonchen_article_details_79218713]

*JobService是Android L时候官方加入的组件。适用于需要特定条件下才执行后台任务的场景。*

*由系统统一管理和调度，在特定场景下使用JobService更加灵活和省心，相当于是Service的加强或者优化。*

我们来研究下JobService如何使用。

*官方链接如下：*

[*https://developer.android.google.cn/reference/android/app/job/JobService.html*][https_developer.android.google.cn_reference_android_app_job_JobService.html]

我们先看看JobService类的继承关系。

*public abstract class JobService *

*extends Service*

可以看到JobService是继承自Service的抽象类。  
看来JobService的本质还是Service，只不过封装了些额外的方法和逻辑。

那到底JobService如何使用？和Service有什么区别呢？实现原理又是什么？

## 第一个问题：如何使用JobService？ ##

首先我们来看下官方的对于JobService的解释。  
ーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー  
*Entry point for the callback from the JobScheduler.  
  
This is the base class that handles asynchronous requests that were previously scheduled.  
You are responsible for overriding onStartJob(JobParameters), which is where you will implement your job logic.  
  
This service executes each incoming job on a Handler running on your application's main thread.  
This means that you must offload your execution logic to another thread/handler/AsyncTask   
of your choosing.*  
ーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー  
  
大概就是下面的意思：  
JobService是JobScheduler的回调，是安排的Job请求的实际处理类。  
需要我们覆写onStartJob(JobParameters)方法，并在里面实现实际的任务逻辑。  
因为JobService的执行是在APP的主线程里响应的，所以必须提供额外的异步逻辑去执行这些任务。

## 我们先看下JobService公开的API有哪些。 ##

*onStartJob()*

定义：Job开始的时候的回调，实现实际的工作逻辑。  
注意：如果返回false的话，系统会自动结束本job；  
  
  
*jobFinished()*  
定义：Job的任务执行完毕后，APP端自己的调用，用以通知JobScheduler已经完成了任务。  
注意:该方法执行完后不会回调onStopJob(),但是会回调onDestroy()  
  
  
*onStopJob()*  
定义：停止该Job。当JobScheduler发觉该Job条件不满足的时候，或者job被抢占被取消的时候的强制回调。  
注意:如果想在这种意外的情况下让Job重新开始，返回值应该设置为true。  
  
  
另外还有父类Service的基础方法，可以覆写来实现一些辅助作用。  
*onCreate()*  
定义：Service被初始化后的回调。  
作用：可以在这里设置BroadcastReceiver或者ContentObserver  
  
  
*onDestroy()*  
定义：Service被销毁前的回调。  
作用：可以在这里注销BroadcastReceiver或者ContentObserver

上面可以看出，JobService只是实际的执行和停止任务的回调入口。  
那如何将这个入口告诉系统，就需要用到JobScheduler了。  
  
*官方链接如下：  
[https://developer.android.google.cn/reference/android/app/job/JobScheduler.html][https_developer.android.google.cn_reference_android_app_job_JobScheduler.html]*

我们先看看JobScheduler类的继承关系。  
*JobScheduler  
public abstract class JobScheduler  
extends Object*  
  
  
可以看到JobScheduler就是个抽象类。  
实际上它的实现逻辑在android.app.JobSchedulerImpl里。  
但是我们暂时不管那么多，只要知道使用JobScheduler里面提供的API即可。

照例，看下官方的解释。  
*ーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー  
This is an API for scheduling various types of jobs against the framework that will be  
executed in your application's own process.  
See JobInfo for more description of the types of jobs that can be run and how to construct them.  
You will construct these JobInfo objects and pass them to the JobScheduler with schedule(JobInfo).  
When the criteria declared are met, the system will execute this job on your application's JobService.  
ーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー*

描述的非常清晰，就是说。  
JobScheduler是framework层里用来安排各种各样的将要执行在app自己进程里的任务的机制。  
我们需要创建各种Job的描述类JobInfo。并且通过JobScheduler传递给系统。当我们描述的条件或者标准满足了，系统  
将执行app的JobService。

## 同样看下JobScheduler提供的API。 ##

*schedule()*

定义：安排一个Job任务。  
  
  
*enqueue()*  
定义：安排一个Job任务，但是可以将一个任务排入队列。  
  
  
*cancel()*  
定义：取消一个执行ID的Job。  
  
  
*cancelAll()*  
定义：取消该app所有的注册到JobScheduler里的任务。  
  
  
*getAllPendingJobs()*  
定义：获取该app所有的注册到JobScheduler里未完成的任务列表。  
  
  
*getPendingJob()*  
定义：按照ID检索获得JobScheduler里未完成的该任务的JobInfo信息。

上面还提到需要创建JobInfo对象，实际要通过JobInfo.Builder类利用建造者模式创建出JobInfo对象。

## JobInfo.Builder里有很多设置Job条件的方法。 ##

我们选取几个代表性的API看看。

*Builder()*  
定义：JobInfo.Builder的内部类构造函数。  
注意：参数之一ID必须是APP UID内唯一的，如果APP和别的APP共用了UID,那么要防止该ID和别的APP里有冲突。  
  
*setOverrideDeadline()*  
定义：设置job被立即执行的最大延迟期限。  
注意：即便其他条件没满足此期限到了也要立即执行  
  
*setRequiresDeviceIdle()*  
定义：是否需要在IDLE状态下运行该Job。  
  
*setRequiredNetworkType()*  
定义：设置需要何种网络类型条件。  
  
JobService，JobScheduler以及JobInfo三大块的API我们都已经有些了解了。

## 那我们先写个简单的JobService跑起来试试。 ##

## ##

### 步骤1.首先创建JobService实现类； ###

onCreate() 简单打个Log  
 onStartJob() 模拟业务逻辑，返回true  
 onStopJob() 期待被再次执行，返回true  
 onDestroy()简单打个log  
 注意：Manifest文件里JobService的声明里必须请求android:permission="android.permission.BIND\_JOB\_SERVICE"的权限

## ##

### 步骤2.在UI端安排JobInfo进任务队列 ###

获取系统的JobSchedulerService的代理对象  
 新建JobInfo.Builder对象，并传入JobService实现类的ComponentName和ID；  
 通过JobInfo.Builder对象设置Job执行的条件，这里设置条件为简单的1s deadline；  
 通过JobInfo.Builder对象创建出JobInfo对象；  
 通过JobSchedulerService代理对象将JobInfo发送到JobScheduler机制中去；

## ##

### 步骤3.UI端模拟任务完成，通知JobService ###

## ##

### 对应的代码 ###

JobService端

1.  `public class EllisonsJobService extends JobService {`
2.  `public static final int ELLISONS_JOB_ID = 0;`
3.  `public static final int ELLISONS_JOB_OVERDIDE_DEADLINE = 1000;`
4.   
5.  `@Override`
6.  `public void onCreate() {`
7.  `super.onCreate();`
8.  `Log.w(TAG, "EllisonsJobService onCreate()");`
9.  `}`
10.  
11. `@Override`
12. `public void onDestroy() {`
13. `super.onDestroy();`
14. `Log.w(TAG, "EllisonsJobService destroyed.");`
15. `}`
16.  
17. `@Override`
18. `public boolean onStartJob(JobParameters params) {`
19. `Log.w(TAG, "EllisonsJobService onStartJob()");`
20.  
21. `Helpers.doHardWork(this, params);`
22.  
23. `return true;`
24. `}`
25.  
26. `@Override`
27. `public boolean onStopJob(JobParameters params) {`
28. `Log.w(TAG, "EllisonsJobService stopped & wait to restart params:" + params + " reason:" + params.getStopReason());`
29. `return false;`
30. `}`
31. `}`

UI端

添加四个按钮：用于schedule，cancel，finish和enqueue job。  
代码如下：

1.  `public class MainActivity extends Activity {`
2.   
3.  `@Override`
4.  `protected void onCreate(Bundle savedInstanceState) {`
5.  `super.onCreate(savedInstanceState);`
6.  `Log.w(TAG, "MainActivity onCreate() PID:" + android.os.Process.myPid() + " TID:" + android.os.Process.myTid());`
7.  `setContentView(R.layout.activity_main);`
8.  `}`
9.   
10. `public void onClick_Schedule(View view) {`
11. `Log.w(TAG, "MainActivity onClick_Schedule()");`
12. `Helpers.schedule(this);`
13. `}`
14.  
15. `public void onClick_Finished(View view) {`
16. `Log.w(TAG, "MainActivity onClick_Finished()");`
17. `Helpers.jobFinished();`
18. `}`
19.  
20. `public void onClick_Cancel(View view) {`
21. `Log.w(TAG, "MainActivity onClick_Cancel()");`
22. `Helpers.cancelJob(this);`
23. `}`
24.  
25. `public void onClick_Enqueue(View view) {`
26. `Log.w(TAG, "MainActivity onClick_Enqueue()");`
27. `Helpers.enqueueJob();`
28. `}`
29.  
30. `@Override`
31. `public void onDestroy() {`
32. `super.onDestroy();`
33. `Log.w(TAG, "MainActivity onDestroy()");`
34. `}`
35. `}`

控制端

1.  `public class Helpers {`
2.  `private static JobService mJob;`
3.  `private static JobParameters mJobParams;`
4.   
5.  `public static void schedule(Context context) {`
6.  `Log.w(TAG, "Helpers schedule()");`
7.   
8.  `final JobScheduler scheduler = context.getSystemService(JobScheduler.class);`
9.  `final JobInfo.Builder builder = new JobInfo.Builder(EllisonsJobService.ELLISONS_JOB_ID,`
10. `new ComponentName(context, EllisonsJobService.class));`
11.  
12. `builder.setOverrideDeadline(EllisonsJobService.ELLISONS_JOB_OVERDIDE_DEADLINE);`
13. `scheduler.schedule(builder.build());`
14. `}`
15.  
16. `public static void cancelJob(Context context) {`
17. `Log.w(TAG, "Helpers cancelJob()");`
18. `final JobScheduler scheduler = context.getSystemService(JobScheduler.class);`
19. `scheduler.cancel(EllisonsJobService.ELLISONS_JOB_ID);`
20. `}`
21.  
22. `public static void jobFinished() {`
23. `Log.w(TAG, "Helpers jobFinished()");`
24. `mJob.jobFinished(mJobParams, false);`
25. `}`
26.  
27. `public static void enqueueJob() {`
28. `Log.w(TAG, "Helpers enqueueJob()");`
29. `}`
30.  
31. `public static void doHardWork(JobService job, JobParameters params) {`
32. `Log.w(TAG, "Helpers doHardWork()");`
33. `mJob = job;`
34. `mJobParams = params;`
35. `}`
36. `}`

DEMO的主界面

![SouthEast][]

点击schedule的button。通过log看到JobService启动了。

1.  `01-31 17:59:23.110 13813 13813 W Ellison : MainActivity onClick_Schedule()`
2.  `01-31 17:59:23.111 13813 13813 W Ellison : Helpers schedule()`
3.  `01-31 17:59:23.119 13813 13813 W Ellison : EllisonsJobService onCreate()`
4.  `01-31 17:59:23.121 13813 13813 W Ellison : EllisonsJobService onStartJob()`
5.  `01-31 17:59:23.121 13813 13813 W Ellison : Helpers doHardWork()`

点击finish的button。通过log看到JobService结束了。

1.  `01-31 17:59:35.582 13813 13813 W Ellison : MainActivity onClick_Finished()`
2.  `01-31 17:59:35.582 13813 13813 W Ellison : Helpers jobFinished()`
3.  `01-31 17:59:35.595 13813 13813 W Ellison : EllisonsJobService destroyed.`

点击schedule和cancel的button。通过log看到JobService执行后被停止了。

1.  `01-31 17:59:48.599 13813 13813 W Ellison : MainActivity onClick_Schedule()`
2.  `01-31 17:59:48.599 13813 13813 W Ellison : Helpers schedule()`
3.  `01-31 17:59:48.608 13813 13813 W Ellison : EllisonsJobService onCreate()`
4.  `01-31 17:59:48.611 13813 13813 W Ellison : EllisonsJobService onStartJob()`
5.  `01-31 17:59:48.611 13813 13813 W Ellison : Helpers doHardWork()`
6.   
7.  `01-31 17:59:55.039 13813 13813 W Ellison : MainActivity onClick_Cancel()`
8.  `01-31 17:59:55.039 13813 13813 W Ellison : Helpers cancelJob()`
9.  `01-31 17:59:55.040 13813 13813 W Ellison : EllisonsJobService stopped & wait to restart params:android.app.job.JobParameters@ac7bfd7 reason:0★`
10. `01-31 17:59:55.049 13813 13813 W Ellison : EllisonsJobService destroyed.`

★处显示被停止的原因值为0。  
而据JobParameters.java里关于stop reason的定义如下。

1.  `/** @hide */`
2.  `public static final int REASON_CANCELED = 0;`

可以看到被取消的Job的reason数值确实为0。

\*关于enqueue的逻辑，后续再添加。

### 如何查看自己的JobService的运行？ ###

那除了自己加log的形式，有没有别的方式查看自己的JobService了呢？  
答案是有的。

使用adb shell service list命令得到如下信息。

47 jobscheduler: [android.app.job.IJobScheduler]

只能看到JobSchedulerService的信息，看不到自己的Job Service。

但是adb给我们提供了另外一种方式查看JobService。  
adb shell dumpsys jobscheduler | grep packagename

我们将packagename换成我们的包名"com.example.TimeApiDemo",得到以下信息。

注册到JobScheduler里的JobService的属性记录

1.  `JOB #u0a174/0: 1beb0fa com.example.timeapidemo/.EllisonsJobService`
2.  `u0a174 tag=*job*/com.example.timeapidemo/.EllisonsJobService`
3.  `Source: uid=u0a174 user=0 pkg=com.example.timeapidemo`
4.  `JobInfo:`
5.  `Service: com.example.timeapidemo/.EllisonsJobService`
6.  `Requires: charging=false batteryNotLow=false deviceIdle=false`
7.  `Max execution delay: +1s0ms`
8.  `Backoff: policy=1 initial=+30s0ms`
9.  `Has late constraint`
10. `Required constraints: DEADLINE`
11. `Satisfied constraints: DEADLINE APP_NOT_IDLE DEVICE_NOT_DOZING`
12. `Unsatisfied constraints:`
13. `Tracking: TIME`
14. `Enqueue time: -36s216ms`
15. `Run time: earliest=none, latest=-35s216ms`
16. `Ready: false (job=true user=true !pending=true !active=false !backingup=true comp=true)`

正在运行的JobService的信息

1.  `Active jobs:`
2.  `...`
3.  `Slot #3: 1beb0fa #u0a174/0 com.example.timeapidemo/.EllisonsJobService`
4.  `Running for: +36s215ms, timeout at: +9m23s798ms`
5.  `u0a174 tag=*job*/com.example.timeapidemo/.EllisonsJobService`
6.  `Source: uid=u0a174 user=0 pkg=com.example.timeapidemo`
7.  `Required constraints: DEADLINE`
8.  `Tracking: TIME`
9.  `Enqueue time: -36s216ms`
10. `Run time: earliest=none, latest=-35s216ms`
11. `Evaluated priority: 40`
12. `Active at -36s213ms, pending for +2ms`

### JobService自启动 ###

一开始的时候说到Job条件不满足的时候，JobScheduler会强制停止该Job，并在条件满足的时候再次启动该Job。  
我们来验证下。

# #

## ##

## IDLE状态下Job停止的例子 ##

我们目前的demo里在创建JobInfo的时候并没有调用setRequiresDeviceIdle()。而这个函数的默认值为false，即意味着该Job不需要在IDLE状态下运行。  
那么等同于如果系统进入了IDLE状态，那么该Job的条件应该不满足，会被停止。当不是IDLE状态了，条件满足了，Job又会被执行。  
  
 再次点击schedule的button，确保我们的Job开始了。

使用如下命令使得设备强制进入IDLE状态。

adb shell dumpsys battery unplug 将USB充电停止

adb shell dumpsys battery 查看电池状态确保充电状态关闭

1.  `Current Battery Service state:`
2.  `(UPDATES STOPPED -- use 'reset' to restart)`
3.  `AC powered: false`

adb shell dumpsys deviceidle enable 将IDLE状态许可

1.  `Deep idle mode enabled`
2.  `Light idle mode enable`

adb shell dumpsys deviceidle force-idle 强制进入IDLE状态

Now forced in to deep idle mode

这时候查看log，发现我们的JobService被停止和销毁了。

1.  `01-31 18:39:31.064 15504 15504 W Ellison : MainActivity onClick_Schedule()`
2.  `01-31 18:39:31.065 15504 15504 W Ellison : Helpers schedule()`
3.  `01-31 18:39:31.096 15504 15504 W Ellison : EllisonsJobService onCreate()`
4.  `01-31 18:39:31.104 15504 15504 W Ellison : EllisonsJobService onStartJob()`
5.  `01-31 18:39:31.104 15504 15504 W Ellison : Helpers doHardWork()`
6.  `01-31 18:39:38.870 15504 15504 W Ellison : EllisonsJobService stopped & wait to restart params:android.app.job.JobParameters@1a480b9 reason:4★`
7.  `01-31 18:39:38.880 15504 15504 W Ellison : EllisonsJobService destroyed.`

★处显示被停止的原因值为4。  
        而据JobParameters.java里关于stop reason的定义。

public static final int REASON_DEVICE_IDLE = 4;

可以看到进入IDLE状态后Job被停止后的stop reason数值确实为4。

这时候我们使用如下命令将设备走出IDLE状态。  
        adb shell dumpsys deviceidle disable

1.  `Deep idle mode disabled`
2.  `Light idle mode disabled`

再次查看log，发现我们的JobService并没有被重新启动。

哪里出了问题呢？

查阅官方文档，我们发现了答案。  
ーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー

*boolean onStopJob (JobParameters params)  
...  
Returns  
boolean True to indicate to the JobManager whether you'd like to reschedule this  
job based on the retry criteria provided at job creation-time. False to drop  
the job. Regardless of the value returned, your job must stop executing.*

ーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー

原来在条件不满足的时候系统会强制停止该Job并回调onStopJob()。onStopJob()里执行停止本地任务的逻辑。如果希望该Job在条件满足的时候被重新启动，应该将返回值置为true。

那我们将onStopJob()的返回值改为true，再试一下。

1.  `public class EllisonsJobService extends JobService {`
2.  `...`
3.  `@Override`
4.  `public boolean onStopJob(JobParameters params) {`
5.  `Log.w(TAG, "EllisonsJobService stopped & wait to restart params:" + params + " reason:" + params.getStopReason());`
6.  `return true;`
7.  `}`
8.  `}`

再次执行上面的步骤。

adb shell dumpsys battery unplug  
    adb shell dumpsys deviceidle enable  
    adb shell dumpsys deviceidle force-idle  
    adb shell dumpsys deviceidle disable

得到如下Log：

1.  `01-31 18:49:22.822 15745 15745 W Ellison : MainActivity onCreate() PID:15745 TID:15745`
2.  `01-31 18:49:23.925 15745 15745 W Ellison : MainActivity onClick_Schedule()`
3.  `01-31 18:49:23.926 15745 15745 W Ellison : Helpers schedule()`
4.  `01-31 18:49:23.938 15745 15745 W Ellison : EllisonsJobService onCreate()`
5.  `01-31 18:49:23.941 15745 15745 W Ellison : EllisonsJobService onStartJob()`
6.  `01-31 18:49:23.941 15745 15745 W Ellison : Helpers doHardWork()`
7.  `01-31 18:49:32.005 15745 15745 W Ellison : EllisonsJobService stopped & wait to restart params:android.app.job.JobParameters@1a480b9 reason:4`
8.  `01-31 18:49:32.007 15745 15745 W Ellison : EllisonsJobService destroyed.`
9.  `01-31 18:50:19.190 15745 15745 W Ellison : EllisonsJobService onCreate()`
10. `01-31 18:50:19.197 15745 15745 W Ellison : EllisonsJobService onStartJob()`
11. `01-31 18:50:19.198 15745 15745 W Ellison : Helpers doHardWork()`

果然，onStopJob()的返回值改为true后，离开IDLE状态后系统可以将Job再次启动起来。

我们再验证另外一种情况，如果Job需要网络条件，那么断网后是否也能够停止Job，开网后是否能够再次启动Job？

## 网络条件下执行Job的例子 ##

修改的代码如下：

1.  `public class Helpers {`
2.  `...`
3.  `public static void schedule(Context context) {`
4.  `...`
5.  `builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);`
6.  `// builder.setOverrideDeadline(EllisonsJobService.ELLISONS_JOB_OVERDIDE_DEADLINE);`
7.  `scheduler.schedule(builder.build());`
8.  `}`
9.  `}`

首先开网并点击schedule的button，可以看到service开始运行。

1.  `01-31 19:00:56.239 16043 16043 W Ellison : MainActivity onCreate() PID:16043 TID:16043`
2.  `01-31 19:01:00.943 16043 16043 W Ellison : MainActivity onClick_Schedule()`
3.  `01-31 19:01:00.943 16043 16043 W Ellison : Helpers schedule()`
4.  `01-31 19:01:00.952 16043 16043 W Ellison : EllisonsJobService onCreate()`
5.  `01-31 19:01:00.954 16043 16043 W Ellison : EllisonsJobService onStartJob()`
6.  `01-31 19:01:00.954 16043 16043 W Ellison : Helpers doHardWork()`

我们关闭网络，可以看到service停止运行了。

1.  `01-31 19:01:13.182 16043 16043 W Ellison : EllisonsJobService stopped & wait to restart params:android.app.job.JobParameters@8394280 reason:1★`
2.  `01-31 19:01:13.184 16043 16043 W Ellison : EllisonsJobService destroyed.`

★处显示被停止的原因值为1。  
而据JobParameters.java里关于stop reason的定义。

public static final int REASON_CONSTRAINTS_NOT_SATISFIED = 1;

可以看到Job在条件不满足时候被停止的stop reason数值确实为1。

我们再次开启网络，发现service自己起来了。

1.  `01-31 19:01:43.203 16043 16043 W Ellison : EllisonsJobService onCreate()`
2.  `01-31 19:01:43.209 16043 16043 W Ellison : EllisonsJobService onStartJob()`
3.  `01-31 19:01:43.209 16043 16043 W Ellison : Helpers doHardWork()`

可以看到，网络条件的Job运行过程和IDLE例子结果完全一致。

我们发现JobService是如此的灵活。可以满足很多特定场景的要求。

## 自行取消Job后能否自启动？ ##

这时候，我们思考一个问题，如果自己cancel了的job，如果onStopJob()返回true，是否也能够将其自动启动？

这个问题不需要修改代码，只需要做如下操作。

点击schedule和cancel的button。

1.  `01-31 19:02:48.917 16043 16043 W Ellison : MainActivity onClick_Schedule()`
2.  `01-31 19:02:48.918 16043 16043 W Ellison : Helpers schedule()`
3.  `01-31 19:02:48.923 16043 16043 W Ellison : EllisonsJobService onCreate()`
4.  `01-31 19:02:48.936 16043 16043 W Ellison : EllisonsJobService onStartJob()`
5.  `01-31 19:02:48.936 16043 16043 W Ellison : Helpers doHardWork()`
6.   
7.  `01-31 19:02:55.956 16043 16043 W Ellison : MainActivity onClick_Cancel()`
8.  `01-31 19:02:55.956 16043 16043 W Ellison : Helpers cancelJob()`
9.  `01-31 19:02:55.961 16043 16043 W Ellison : EllisonsJobService stopped & wait to restart params:android.app.job.JobParameters@4634857 reason:0`
10. `01-31 19:02:55.963 16043 16043 W Ellison : EllisonsJobService destroyed.`

在cancel完之后等待了很长时间，service也没有自动启动起来。  
这个是不是和上面的官方说明矛盾啊。  
不是说返回true，系统就会再次启动Job吗？  
  
其实并不矛盾。  
首先从逻辑上讲，APP自行取消的Job，系统是不需要为你再次启动的。  
只有因外部条件不满足了等场合被强制的Job才有再次启动的可能性。  
后期我们将从源码角度探究JobSecheduler如此设计的证据。  
  
那如果说我们收到要求，不管是系统自动结束的我们Job还是我们自行Cancel了Job，  
我们都希望Job能够再次启动。  
那该怎么办？

其实很简单，我们可以在onStopJob()或onDestroy()里再次schedule我们的jobservice。  
这里以onStopJob()为例，我们将代码做下修改：

继续点击点击schedule和cancel的button。

1.  `01-31 19:20:02.615 16589 16589 W Ellison : MainActivity onClick_Schedule()`
2.  `01-31 19:20:02.615 16589 16589 W Ellison : Helpers schedule()`
3.  `01-31 19:20:02.632 16589 16589 W Ellison : EllisonsJobService onCreate()`
4.  `01-31 19:20:02.636 16589 16589 W Ellison : EllisonsJobService onStartJob()`
5.  `01-31 19:20:02.636 16589 16589 W Ellison : Helpers doHardWork()`
6.   
7.  `01-31 19:20:08.248 16589 16589 W Ellison : MainActivity onClick_Cancel()`
8.  `01-31 19:20:08.248 16589 16589 W Ellison : Helpers cancelJob()`
9.  `01-31 19:20:08.250 16589 16589 W Ellison : EllisonsJobService stopped & wait to restart params:android.app.job.JobParameters@cd62c5f reason:0`
10. `01-31 19:20:08.250 16589 16589 W Ellison : Helpers schedule()`
11. `01-31 19:20:08.262 16589 16589 W Ellison : EllisonsJobService destroyed.`
12. `01-31 19:20:08.264 16589 16589 W Ellison : EllisonsJobService onCreate()`
13. `01-31 19:20:08.267 16589 16589 W Ellison : EllisonsJobService onStartJob()`
14. `01-31 19:20:08.267 16589 16589 W Ellison : Helpers doHardWork()`

通过log发现JobService cancel之后立马又被系统重新创建并启动了。

## 总结 ##

JobService被意外终止之后如何自启动的方案有两种。

1.JobService的onStopJob()返回值设置为true。  
  注意：对于自行cancel了的Job无效。  
2.JobService的onStopJob()或onDestroy()里强制再次schedule我们的jobservice。

### 注意 ###

JobService绑定成功后，系统的JobServiceContext都会给该JobService创建和持有WakeLock，直到JobService销毁的时候才释放WakeLock对象。  
也就是说，除非JobService执行结束或意外中止，系统一直会保持运转以保证JobService的正常运行。  
所以，如果JobService保持自启动的话，最好不要无限循环自启动，这样会导致系统一直无法休眠，加速电量的损耗。

我们将目前的尝试结果做下总结，总结那些JobService使用中应当知道的规则。

## JobService规则 ##

### 规则一 ###

Manifest文件里JobService的声明里必须请求android:permission="android.permission.BIND\_JOB\_SERVICE"的权限。  
不然的话，在schdule或者enqueue job的时候会抛出如下的IllegalArgumentException。  
"Error: requested job be persisted without holding RECEIVE\_BOOT\_COMPLETED permission."

### 规则二 ###

JobInfo创建的时候必须设置一个条件。  
不然的话，在创建JobInfo对象时会抛如下的IllegalArgumentException。  
"You're trying to build a job with no constraints, this is not allowed."

### 规则三 ###

同一个UID的进程里只能有唯一一个Job的ID。  
不然的话，新生成的Job会抢占已经运行的Job，导致该Job被异常终止。

### 规则四 ###

JobService因为运行条件变化后被强制停止后想自启动的话，需要将onStopJob()返回true。

### 规则五 ###

JobService不论何种原因被停止了都希望能自动启动的话，需要在onStopJob()或  
onDestroy()里强制再次schedule我们的jobservice。

### 规则六 ###

如果自行cancel了Job，即便onStopJob()里返回true系统也不会将该Job再度启动。

# #

### 规则七 ###

如果自行finished了Job，那么onStopJob()将得不到回调，将只回调onDestroy()。

### 规则八 ###

Job如果要执行长时间任务的话，onStartJob()应当返回true。不然onStartJob()刚回调结束，  
Job就会被停止。

## 后续 ##

JobService使用的大体内容就是这些，后续将补充如下内容。

### 一 enqueue API的相关使用说明。 ###

###    二 JobService和Service的区别。 ###

### 三 源码层面探究JobScheduler如何实现cancel后的job即便onStopJob()返回true也不能再次启动。 ###

###    四 源码层面探究JobScheduler的大体原理。 ###

[https_blog.csdn.net_allisonchen_article_details_79218713]: https://blog.csdn.net/allisonchen/article/details/79218713
[https_developer.android.google.cn_reference_android_app_job_JobService.html]: https://developer.android.google.cn/reference/android/app/job/JobService.html
[https_developer.android.google.cn_reference_android_app_job_JobScheduler.html]: https://developer.android.google.cn/reference/android/app/job/JobScheduler.html
[SouthEast]: /images/20220516/bd08ec307c4f47a180df2b2774871285.png