JobService的使用及源码分析

转自:http://blog.csdn.net/fishle123/article/details/50790894

Google在Android 5.0中引入JobScheduler来执行一些需要满足特定条件但不紧急的后台任务,APP利用JobScheduler来执行这些特殊的后台任务时来减少电量的消耗。本文首先介绍JobSerice的使用方法,然后分析JobService的源码实现。

JobService的使用

使用JobScheduler的时候需要把待执行的后台任务封装到JobService中提交。下面就来介绍JobService的使用,首先看一下JobService是什么东东。

 

从上面的截图,可以看出JobService继承自Service,并且是一个抽象类。在JobService中有两个抽象方法onStartJob(JobParameters)onStopJob(JobParameters)。onStartJob在JobService被调度到的时候会执行,我们只需要继承JobService然后重写onStartJob方法,并在里面执行我们的后台任务就可以了。

下面给出一个JobService的使用实例。

首先,定义一个JobService的子类,如:

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public class MyJobService extends JobService {  
  2.     public static final String TAG = MyJobService.class.getSimpleName();  
  3.   
  4.     @Override  
  5.     public boolean onStartJob(JobParameters params) {  
  6.         Log.i(TAG, "onStartJob:" + params.getJobId());  
  7.         Toast.makeText(MyJobService.this"start job:" + params.getJobId(), Toast.LENGTH_SHORT).show();  
  8.         jobFinished(params, false);//任务执行完后记得调用jobFinsih通知系统释放相关资源  
  9.         return false;  
  10.     }  
  11.   
  12.     @Override  
  13.     public boolean onStopJob(JobParameters params) {  
  14.         Log.i(TAG, "onStopJob:" + params.getJobId());  
  15.         return false;  
  16.     }  
  17.   
  18.   
  19. }  

在MyJobService中,onStartJob里面的逻辑非常简单:弹出一个Toast。定义完JobService之后,剩下的工作就是提交Job了,这里我们在Activity中实现,用户点击button来提交任务。Activity的代码如下:

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public class MainActivity extends Activity {  
  2.   
  3.     public static final String TAG = MainActivity.class.getSimpleName();  
  4.     private int mJobId = 0;  
  5.   
  6.     private EditText mDelayEditText;  
  7.     private EditText mDeadlineEditText;  
  8.     private RadioButton mWiFiConnectivityRadioButton;  
  9.     private RadioButton mAnyConnectivityRadioButton;  
  10.     private CheckBox mRequiresChargingCheckBox;  
  11.     private CheckBox mRequiresIdleCheckbox;  
  12.   
  13.     @Override  
  14.     protected void onCreate(Bundle savedInstanceState) {  
  15.         super.onCreate(savedInstanceState);  
  16.         setContentView(R.layout.activity_main);  
  17.   
  18.         mDelayEditText = (EditText) findViewById(R.id.delay_time);  
  19.         mDeadlineEditText = (EditText) findViewById(R.id.deadline_time);  
  20.         mWiFiConnectivityRadioButton = (RadioButton) findViewById(R.id.checkbox_unmetered);  
  21.         mAnyConnectivityRadioButton = (RadioButton) findViewById(R.id.checkbox_any);  
  22.         mRequiresChargingCheckBox = (CheckBox) findViewById(R.id.checkbox_charging);  
  23.         mRequiresIdleCheckbox = (CheckBox) findViewById(R.id.checkbox_idle);  
  24.     }  
  25.   
  26.     public void onBtnClick(View view) {  
  27.         JobScheduler scheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);  
  28.         ComponentName componentName = new ComponentName(MainActivity.this, MyJobService.class);  
  29.         JobInfo.Builder builder = new JobInfo.Builder(++mJobId, componentName);  
  30.   
  31.   
  32.         String delay = mDelayEditText.getText().toString();  
  33.         if (delay != null && !TextUtils.isEmpty(delay)) {  
  34.             //设置JobService执行的最小延时时间  
  35.             builder.setMinimumLatency(Long.valueOf(delay) * 1000);  
  36.         }  
  37.         String deadline = mDeadlineEditText.getText().toString();  
  38.         if (deadline != null && !TextUtils.isEmpty(deadline)) {  
  39.             //设置JobService执行的最晚时间  
  40.             builder.setOverrideDeadline(Long.valueOf(deadline) * 1000);  
  41.         }  
  42.         boolean requiresUnmetered = mWiFiConnectivityRadioButton.isChecked();  
  43.         boolean requiresAnyConnectivity = mAnyConnectivityRadioButton.isChecked();  
  44.         //设置执行的网络条件  
  45.         if (requiresUnmetered) {  
  46.             builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED);  
  47.         } else if (requiresAnyConnectivity) {  
  48.             builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);  
  49.         }  
  50.         builder.setRequiresDeviceIdle(mRequiresIdleCheckbox.isChecked());//是否要求设备为idle状态  
  51.         builder.setRequiresCharging(mRequiresChargingCheckBox.isChecked());//是否要设备为充电状态  
  52.   
  53.         scheduler.schedule(builder.build());  
  54.         Log.i(TAG, "schedule job:" + mJobId);  
  55.     }  
  56.     //......  
  57.     }  

这里重点看一下26----55行,在button的单击事件响应中,先通过getSystemService拿到系统的JobScheduler,然后使用JobInfo.Buidler来构造一个后台任务,具体看28----55行。在设置后台任务的参数时,需要特别注意的是:以下五个约束条件我们需要至少指定其中的一个,否则调用JobInfo.Buidler的build方法时会抛异常,导致后台任务构造失败。五个约束条件如下:

1)最小延时

2)最晚执行时间

3)需要充电

4)需要设备为idle(空闲)状态(一般很难达到这个条件吧)

5)联网状态(NETWORK_TYPE_NONE--不需要网络,NETWORK_TYPE_ANY--任何可用网络,NETWORK_TYPE_UNMETERED--不按用量计费的网络)

其实仔细想一想也有道理,其实约束条件决定了JobService在什么时候执行,如果都没指定,系统就不知道在什么来执行我们的JobService了。如果我们的后台任务满足以上的一个或多个条件,就可以考虑是不是应该用JobService来执行。

运行效果如下:


JobService源码分析

JobService内部的运行机制究竟是怎样的?既然继承子Service,那么它至少要重写onStartCommand或者onBind。实际上JobService选择的是重写onBind。为什么使用bind方式呢?上面有提到,JobService是通过JobScheduler来调度,很明显这里会涉及到跨进程通信,如果使用AIDL(当然也可以使用Messenger)就可以很容易实现了。看一下源码:

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** @hide */  
  2. public final IBinder onBind(Intent intent) {  
  3.     return mBinder.asBinder();  
  4. }  

很明显,这里采用的是AIDL方式。在看一下mBinder的定义:

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** Binder for this service. */  
  2. IJobService mBinder = new IJobService.Stub() {  
  3.     @Override  
  4.     public void startJob(JobParameters jobParams) {  
  5.         ensureHandler();  
  6.         Message m = Message.obtain(mHandler, MSG_EXECUTE_JOB, jobParams);  
  7.         m.sendToTarget();  
  8.     }  
  9.     @Override  
  10.     public void stopJob(JobParameters jobParams) {  
  11.         ensureHandler();  
  12.         Message m = Message.obtain(mHandler, MSG_STOP_JOB, jobParams);  
  13.         m.sendToTarget();  
  14.     }  
  15. };  
  16.   
  17. /** @hide */  
  18. void ensureHandler() {  
  19.     synchronized (mHandlerLock) {  
  20.         if (mHandler == null) {  
  21.             mHandler = new JobHandler(getMainLooper());  
  22.         }  
  23.     }  
  24. }  

从这里可以看到,JobService定义了一个IJobService接口,在这个接口里面定义了startJob和stopJob两个方法来让JobScheduler调度我们的后台任务的执行。这两个方法的实现也很简单,分别发送了MSG_EXECUTE_JOB和MSG_STOP_JOB两个Message。ensureHandler从名字上看,应该就是用来初始化一个Handler吧。看一下源码就知道了:

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** @hide */  
  2. void ensureHandler() {  
  3.     synchronized (mHandlerLock) {  
  4.         if (mHandler == null) {  
  5.             mHandler = new JobHandler(getMainLooper());  
  6.         }  
  7.     }  
  8. }  

从这里可以看到,在JobService里面定义了一个JobHandler。注意下这里使用的是getMainLooper(),因此,消息是在主线程中处理。继续看JobHandler是怎么处理这两个消息的:

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. class JobHandler extends Handler {  
  2.     JobHandler(Looper looper) {  
  3.         super(looper);  
  4.     }  
  5.   
  6.     @Override  
  7.     public void handleMessage(Message msg) {  
  8.         final JobParameters params = (JobParameters) msg.obj;  
  9.         switch (msg.what) {  
  10.             case MSG_EXECUTE_JOB:  
  11.                 try {  
  12.                     boolean workOngoing = JobService.this.onStartJob(params);  
  13.                     ackStartMessage(params, workOngoing);  
  14.                 } catch (Exception e) {  
  15.                     Log.e(TAG, "Error while executing job: " + params.getJobId());  
  16.                     throw new RuntimeException(e);  
  17.                 }  
  18.                 break;  
  19.             case MSG_STOP_JOB:  
  20.                 try {  
  21.                     boolean ret = JobService.this.onStopJob(params);  
  22.                     ackStopMessage(params, ret);  
  23.                 } catch (Exception e) {  
  24.                     Log.e(TAG, "Application unable to handle onStopJob.", e);  
  25.                     throw new RuntimeException(e);  
  26.                 }  
  27.                 break;  
  28.             case MSG_JOB_FINISHED:  
  29.                 final boolean needsReschedule = (msg.arg2 == 1);  
  30.                 IJobCallback callback = params.getCallback();  
  31.                 if (callback != null) {  
  32.                     try {  
  33.                         callback.jobFinished(params.getJobId(), needsReschedule);  
  34.                     } catch (RemoteException e) {  
  35.                         Log.e(TAG, "Error reporting job finish to system: binder has gone" +  
  36.                                 "away.");  
  37.                     }  
  38.                 } else {  
  39.                     Log.e(TAG, "finishJob() called for a nonexistent job id.");  
  40.                 }  
  41.                 break;  
  42.             default:  
  43.                 Log.e(TAG, "Unrecognised message received.");  
  44.                 break;  
  45.         }  
  46.     }  
  47.     ......//省略部分代码  
  48.  }  

从源码中,可以很清楚的看到,在第10----18行,处理在startJob中发出的消息,这里会调用JobService.this.onStartJob(params)来执行任务,在第19----27调用JobService.this.onStopJob(params)来通知我们需要停止任务了。如果我们的后台任务需要在wifi可用的时候才执行的话,如果在任务执行的过程中wifi断开了,那么系统就调用onStopService来通知我们停止运行。

再次强调一下,JobService中的后台任务是在主线程中执行,这里一定不能执行耗时的任务。虽然在JobService中使用了Binder,但是最后还是通过Handler将任务调度到主线程中来执行。

在上面的例子用,有提到在JobInfo.Builder中配置JobService的时候需要指定至少一个约束(触发)条件,否则会抛出异常,这里我们也看一下JobInfo.Builder的build方法:

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public JobInfo build() {  
  2.     // Allow jobs with no constraints - What am I, a database?  
  3.     if (!mHasEarlyConstraint && !mHasLateConstraint && !mRequiresCharging &&  
  4.             !mRequiresDeviceIdle && mNetworkType == NETWORK_TYPE_NONE) {  
  5.         throw new IllegalArgumentException("You're trying to build a job with no " +  
  6.                 "constraints, this is not allowed.");  
  7.     }  
  8.     mExtras = new PersistableBundle(mExtras);  // Make our own copy.  
  9.     // Check that a deadline was not set on a periodic job.  
  10.     if (mIsPeriodic && (mMaxExecutionDelayMillis != 0L)) {  
  11.         throw new IllegalArgumentException("Can't call setOverrideDeadline() on a " +  
  12.                 "periodic job.");  
  13.     }  
  14.     if (mIsPeriodic && (mMinLatencyMillis != 0L)) {  
  15.         throw new IllegalArgumentException("Can't call setMinimumLatency() on a " +  
  16.                 "periodic job");  
  17.     }  
  18.     if (mBackoffPolicySet && mRequiresDeviceIdle) {  
  19.         throw new IllegalArgumentException("An idle mode job will not respect any" +  
  20.                 " back-off policy, so calling setBackoffCriteria with" +  
  21.                 " setRequiresDeviceIdle is an error.");  
  22.     }  
  23.     return new JobInfo(this);  
  24. }  

从第3----7行,可知,如果5个约束条件都没有指定的时候,会抛出IllegalArgumentException。其实仔细想一想也有道理,其实约束条件决定了JobService在什么时候执行,如果都没指定,系统就不知道在什么来执行我们的JobService了。

总结

最后,总结一下JobService的使用:

1)先继承JobService,并重写startJob和stopJob

2)在manifest.xml中声明JobService的时候,记得一定要加上

android:permission=”android.permission.BIND_JOB_SERVICE”

3)后台任务不能执行耗时任务,如果一定要这么做,一定要再起一个线程去做,使用 thread/handler/AsyncTask都可以。

4)JobService一定要设置至少一个执行条件,如有网络连接、充电中、系统空闲...

5)任务执行完后记得调用jobFinish通知系统释放相关资源

如果我们的后台任务满足JobService的一个或多个约束条件,就可以考虑是不是应该用JobService来执行。


源码下载

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值