JobIntentService详解及使用

Android o新特性–后台限制

Android8.0对系统资源的管控更加严格,添加了后台限制规则。

如果满足以下任意条件,应用将被视为处于前台:

  1. 具有可见 Activity(不管该 Activity 已启动还是已暂停)。
  2. 具有前台服务。
  3. 另一个前台应用已关联到该应用(不管是通过绑定到其中一个服务,还是通过使用其中一个内容提供程序)。 例如,如果另一个应用绑定到该应用的服务,那么该应用处于前台:
  4. IME
  5. 壁纸服务
  6. 通知侦听器
  7. 语音或文本服务

如果以上条件均不满足,应用将被视为处于后台。

系统不允许后台应用创建后台服务。 因此,Android 8.0 引入了一种全新的方法,即 Context.startForegroundService(),以在前台启动新服务。

在系统创建服务后应用有五秒的时间来调用该服务的 startForeground() 方法以显示新服务的用户可见通知。

如果应用在此时间限制内未调用 startForeground(),则系统将停止服务并声明此应用为 ANR

Android强制开发者使用 JobScheduler 作业替换后台服务的意思,使用jobIntentService就可以比较方便的使用JobScheduler这个工具。

特殊情况是可以创建后台服务的:

  1. 处理对用户可见的任务时,应用将被置于白名单中,后台应用将被置于一个临时白名单中并持续数分钟。 位于白名单中时,应用可以无限制地启动服务,并且其后台服务也可以运行。
    1. 处理一条高优先级 Firebase 云消息传递 (FCM) 消息。
    2. 接收广播,例如短信/彩信消息。
    3. 从通知执行 PendingIntent。
  2. bindService不受后台限制

JobIntentService

JobIntentService实质为Service其继承关系如下所示。

 java.lang.Object
    ↳   android.content.Context
       ↳    android.content.ContextWrapper
           ↳    android.app.Service
               ↳    android.support.v4.app.JobIntentService

作用

Helper for processing work that has been enqueued for a job/service. When running on Android O or later, the work will be dispatched as a job via JobScheduler.enqueue. When running on older versions of the platform, it will use Context.startService.

官方文档解释为,用于处理被加入到job或service任务的一个辅助工具,8.0以下被当作普通的Intent使用startSerivce()启动service来执行。

8.0以上任务被作为job用jobScheduler.enqueue()方法来分发,
说到Jobscheduler,应该不陌生了,框架提供的用来APP调度任务的接口,根据APP要求构建JobInfo,系统会在适当的时间调用JobInfo指定的JobService来执行你的任务。

所以在Android8.0及以上JobIntentService和JobService做的事情是相同的,都是等着JobScheduler分配任务来执行。

不同点在于,JobService使用的handler使用的是主线程的Looper,因此需要在onStartJob()中手动创建AsyncTask去执行耗时任务,而JobIntentService则帮我们处理这一过程,使用它只需要写需要做的任务逻辑即可,不用关心卡住主线程的问题。另外,向jobScheduler传递任务操作也更简单了,不需要在指定JobInfo中的参数,直接enqueue(context,intent)就可以。

这有点像Service和IntentService的关系。

来看一段JobIntentService的源码
加入enqueue到onhandlework的过程。

//JobIntentService的入口方法
public static void enqueueWork(@NonNull Context context, @NonNull Class cls, int jobId,
            @NonNull Intent work) {
        if (work == null) {
            throw new IllegalArgumentException("work must not be null");
        }
        synchronized (sLock) {
            WorkEnqueuer we = getWorkEnqueuer(context, cls, true, jobId);//根据版本获取不同的WorkEnqueuer
            we.ensureJobId(jobId);//每个jobIntentService 唯一对应一个JobId,所有给这个service的work都必须相同
            we.enqueueWork(work);//调用WorkEnqueuer
        }
    }
static WorkEnqueuer getWorkEnqueuer(Context context, Class cls, boolean hasJobId, int jobId) {
        WorkEnqueuer we = sClassWorkEnqueuer.get(cls);
        if (we == null) {
            if (BuildCompat.isAtLeastO()) {
                if (!hasJobId) {
                    throw new IllegalArgumentException("Can't be here without a job id");
                }
                we = new JobWorkEnqueuer(context, cls, jobId);//8.0
            } else {
                we = new CompatWorkEnqueuer(context, cls);//8.0以前
            }
            sClassWorkEnqueuer.put(cls, we);
        }
        return we;
    }

    //8.0的WorkEnqueuer.enqueueWork()
    @Override
        void enqueueWork(Intent work) {
            if (DEBUG) Log.d(TAG, "Enqueueing work: " + work);
            mJobScheduler.enqueue(mJobInfo, new JobWorkItem(work));//调用JobScheduler.enqueue()
        }

看到最终调用了JobScheduler来调度任务,那么是给哪个service执行呢,看mJobInfo怎么build的

 JobWorkEnqueuer(Context context, Class cls, int jobId) {
            super(context, cls);
            ensureJobId(jobId);
            JobInfo.Builder b = new JobInfo.Builder(jobId, mComponentName);//使用mComponentName
            mJobInfo = b.setOverrideDeadline(0).build();
            mJobScheduler = (JobScheduler) context.getApplicationContext().getSystemService(
                    Context.JOB_SCHEDULER_SERVICE);
        }

使用mComponentName,那这个mComponentName在哪赋值

//JobWorkEnqueuer的父类
 WorkEnqueuer(Context context, Class cls) {
            mComponentName = new ComponentName(context, cls);

所以mComponentName就是在enqueueWork(@NonNull Context context, @NonNull Class cls, int jobId,@NonNull Intent work)中传入的service的类名,一般在调用JobIntentService时就会传入其子类的类名。

那么work在哪被处理的呢,按照jobService的逻辑找到onStartJob(),就是执行任务处理的地方

 public boolean onStartJob(JobParameters params) {
            if (DEBUG) Log.d(TAG, "onStartJob: " + params);
            mParams = params;
            // We can now start dequeuing work!
            mService.ensureProcessorRunningLocked();
            return true;
        }

        void ensureProcessorRunningLocked() {
            if (mCurProcessor == null) {
                mCurProcessor = new CommandProcessor();
                if (DEBUG) Log.d(TAG, "Starting processor: " + mCurProcessor);
                mCurProcessor.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);//mCurProcessor是线程池的AsyncTask
        }
    }

    final class CommandProcessor extends AsyncTask<Void, Void, Void> {
        @Override
        protected Void doInBackground(Void... params) {
            GenericWorkItem work;

            if (DEBUG) Log.d(TAG, "Starting to dequeue work...");

            while ((work = dequeueWork()) != null) {
                if (DEBUG) Log.d(TAG, "Processing next work: " + work);
                onHandleWork(work.getIntent());  //回调onHandleWork()
                if (DEBUG) Log.d(TAG, "Completing work: " + work);
                work.complete();
            }

            if (DEBUG) Log.d(TAG, "Done processing work!");

            return null;
        }

子类实现jobIntentService处理work就是实现onHandleWork,可以看到其使用线程池的AsyncTask来处理work的,所以不需要考虑主线程阻塞的问题。

案例演示

public class MainActivity extends Activity {

    Button btn ;
    static int num =0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn = findViewById(R.id.button);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent workIntent = new Intent();
                num++;
                Log.d("houson", "onClick: "+num);
                workIntent.putExtra("work","work num:"+num);
                MyJobIntentService.enqueueWork(getApplicationContext(),workIntent);
            }
        });
    }
}
public class MyJobIntentService extends JobIntentService {

    /**
     * 这个Service 唯一的id
     */
    static final int JOB_ID = 10111;

    /**
     * Convenience method for enqueuing work in to this service.
     */
    static void enqueueWork(Context context, Intent work) {
        enqueueWork(context, MyJobIntentService.class, JOB_ID, work);
    }

    @Override
    protected void onHandleWork( Intent intent) {
        Log.d("houson", "onHandleWork: "+intent.getStringExtra("work").toString());
    }
}

注意manifest!

<uses-permission android:name="android.permission.WAKE_LOCK"></uses-permission>
<service android:name=".MyJobIntentService"></service>

结果:

11-06 20:39:04.116 20653-20653/com.example.houson.jobintentservicedemo D/houson: onClick: 47
11-06 20:39:04.135 20653-20743/com.example.houson.jobintentservicedemo D/houson: onHandleWork: work num:47
11-06 20:39:04.216 20653-20653/com.example.houson.jobintentservicedemo D/houson: onClick: 48
11-06 20:39:04.234 20653-20745/com.example.houson.jobintentservicedemo D/houson: onHandleWork: work num:48

总结

由于Android O的后台限制,创建后台服务需要使用JobScheduler来由系统进行调度任务的执行,而使用JobService的方式比较繁琐,8.0及以上提供了JobIntentService帮助开发者更方便的将任务交给JobScheduler调度,其本质是Service后台任务在他的OnhandleWork()中进行,子类重写该方法即可。使用较简单。

注意
1.需要添加android.permission.WAKE_LOCK权限,JobIntentService处理了亮屏/锁屏,因此要此权限。
2.注册JobintentService也是service

  • 34
    点赞
  • 53
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
ThreadLocal 是 Java 中的一个线程局部变量,它为每个线程提供了独立的变量副本,每个线程都可以通过 ThreadLocal 对象来访问自己的变量副本,而不会影响其他线程的副本。ThreadLocal 在多线程编程中非常有用,可以解决线程安全问题。 使用 ThreadLocal 的主要场景包括: 1. 线程上下文信息传递:有些情况下,我们需要在多个方法之间传递一些上下文信息,例如用户认证信息、数据库连接等。使用 ThreadLocal 可以避免在方法参数中传递这些上下文信息,每个线程都可以独立地访问自己的上下文信息。 2. 线程安全的对象:有些对象在多线程环境下是不安全的,如果每个线程都持有一个对象的副本,就可以避免多线程竞争访问导致的安全问题。例如 SimpleDateFormat 是非线程安全的,可以使用 ThreadLocal 来为每个线程提供一个独立的 SimpleDateFormat 对象。 3. 隐式参数传递:有些方法需要依赖某些参数,但是这些参数对于调用方来说并不是必须的。使用 ThreadLocal 可以将这些参数设置为 ThreadLocal 变量,在方法中直接获取这些参数,而不需要显式传递。 需要注意的是,使用 ThreadLocal 时要及时清理资源,避免内存泄漏。在使用完毕后,应该调用 ThreadLocal 的 remove() 方法来清理当前线程持有的变量副本。 总之,ThreadLocal 可以用于在多线程环境下实现线程安全、线程间数据隔离和传递上下文信息等功能。但是过度使用 ThreadLocal 也会导致代码可读性变差,增加了代码的复杂性,需要根据具体场景进行合理使用
评论 10
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值