android: job service

最新推荐文章于 2021-05-28 14:25:30 发布

shuai_wen

最新推荐文章于 2021-05-28 14:25:30 发布

阅读量810

点赞数

分类专栏： android

本文链接：https://blog.csdn.net/u011279649/article/details/88012243

版权

android 专栏收录该内容

130 篇文章 9 订阅

订阅专栏

使用jobService遇到一些坑，这里记录下：

Job在android中的地位还是很重要的，代码位于android/app/job 和activity、service并列，(不知道另外两个broadcast和provide放在哪里？)

public abstract class JobService extends Service

public abstract class JobService extends Service {
public static final String PERMISSION_BIND = "android.permission.BIND_JOB_SERVICE";
private JobServiceEngine mEngine;

/** @hide */
public final IBinder onBind(Intent intent) {
if (mEngine == null) {
mEngine = new JobServiceEngine(this) {
@Override
public boolean onStartJob(JobParameters params) {
return JobService.this.onStartJob(params);
}

@Override
public boolean onStopJob(JobParameters params) {
return JobService.this.onStopJob(params);
}
};
}
return mEngine.getBinder();
}
public final void jobFinished(JobParameters params, boolean wantsReschedule) {
mEngine.jobFinished(params, wantsReschedule);
}

public abstract boolean onStartJob(JobParameters params);
public abstract boolean onStopJob(JobParameters params);
}

JobService是JobScheduler callback的入口点

/**
* JobService 是 Entry point for the callback from the android.app.job.JobScheduler.
* This is the base class that handles asynchronous requests that were previously scheduled.

JobService是个abstract class，用户需要继承且实现onStartJob、onStopJob
* You are responsible for overriding {JobService#onStartJob(JobParameters)}, which is where
* you will implement your job logic.

// 为防止阻塞主线程，把执行逻辑放在另外的线程
* This service executes each incoming job on a {android.os.Handler} running on your
* application's main thread. This means that you must offload your execution logic to
* another thread/handler/{android.os.AsyncTask} of your choosing. Not doing so will result
* in blocking any future callbacks from the JobManager - specifically
* {onStopJob(android.app.job.JobParameters)}, which is meant to inform you that the
* scheduling requirements are no longer being met.
*/

onStartJob

public abstract boolean onStartJob(JobParameters params);

添加的具体逻辑在这里执行；

return true表示job还要执行直到调用jobFinished或者执行条件不满足如和配置的网络类型等

return false表示job执行完毕
/**
* Called to indicate that the job has begun executing. Override this method with the
* logic for your job. Like all other component lifecycle callbacks, this method executes
* on your application's main thread.
*
* Return {true} from this method if your job needs to continue running. If you
* do this, the job remains active until you call
* {jobFinished(JobParameters, boolean)} to tell the system that it has completed
* its work, or until the job's required constraints are no longer satisfied. For
* example, if the job was scheduled using
* {JobInfo.Builder#setRequiresCharging(boolean) setRequiresCharging(true)},
* it will be immediately halted by the system if the user unplugs the device from power,
* the job's {onStopJob(JobParameters)} callback will be invoked, and the app
* will be expected to shut down all ongoing work connected with that job.
*
* The system holds a wakelock on behalf of your app as long as your job is executing.
* This wakelock is acquired before this method is invoked, and is not released until either
* you call {jobFinished(JobParameters, boolean)}, or after the system invokes
* { #onStopJob(JobParameters)} to notify your job that it is being shut down
* prematurely.
*
* Returning {false} from this method means your job is already finished. The
* system's wakelock for the job will be released, and {onStopJob(JobParameters)}
* will not be invoked.
*
*/

onStopJob

当job获得执行时间但条件不满足时调用该函数

/**
* This method is called if the system has determined that you must stop execution of your job
* even before you've had a chance to call {jobFinished(JobParameters, boolean)}.
*
* This will happen if the requirements specified at schedule time are no longer met. For
* example you may have requested WiFi with
* { android.app.job.JobInfo.Builder#setRequiredNetworkType(int)}, yet while your
* job was executing the user toggled WiFi. Another example is if you had specified
* {android.app.job.JobInfo.Builder#setRequiresDeviceIdle(boolean)}, and the phone left its
* idle maintenance window. You are solely responsible for the behavior of your application
* upon receipt of this message; your app will likely start to misbehave if you ignore it.
* Once this method returns, the system releases the wakelock that it is holding on
* behalf of the job.
*/
public abstract boolean onStopJob(JobParameters params);

jobFinished

/**
* Call this to inform the JobScheduler that the job has finished its work. When the
* system receives this message, it releases the wakelock being held for the job.
* You can request that the job be scheduled again by passing {true} as
* the wantsReschedule parameter.
*/
public final void jobFinished(JobParameters params, boolean wantsReschedule) {
mEngine.jobFinished(params, wantsReschedule);
}

JobParameters

JobParameters包含标示任务的参数，系统处理该参数
/**
* Contains the parameters used to configure/identify your job. You do not create this object
* yourself, instead it is handed in to your application by the System.
*/
public class JobParameters implements Parcelable {
private final int jobId;
}

JobInfo

/**
* Container of data passed to the {android.app.job.JobScheduler} fully encapsulating the
* parameters required to schedule work against the calling application. These are constructed
* using the {JobInfo.Builder}.
* You must specify at least one sort of constraint on the JobInfo object that you are creating.
* The goal here is to provide the scheduler with high-level semantics about the work you want to
* accomplish. Doing otherwise with throw an exception in your app.
*/
public class JobInfo implements Parcelable {}

JobInfo.Builder builder = new JobInfo.Builder(JOB_ID,new ComponentName(packageName, className));
builder.setPeriodic(5000);
builder.setPersisted(true);
builder.setRequiresCharging(true);

Builder setPeriodic(long intervalMillis)
Builder setPeriodic(long intervalMillis, long flexMillis)
Builder setMinimumLatency(long minLatencyMillis)
Builder setOverrideDeadline(long maxExecutionDelayMillis)
/*Set whether or not to persist this job across device reboots*/
Builder setPersisted(boolean isPersisted)
Builder setRequiredNetworkType(@NetworkType int networkType)
Builder setRequiresBatteryNotLow(boolean batteryNotLow)
Builder setRequiresCharging(boolean requiresCharging)
Builder setRequiresDeviceIdle(boolean requiresDeviceIdle)

//生成Info
JobInfo info = builder.build();

JobService的使用

public class CloudUpdateJobService extends JobService {
    private static String TAG = "CloudUpdate";
1. override onStartJob and onStopJob
    @Override
    public boolean onStartJob(final JobParameters params) {
        Log.i(TAG, "job is scheduled");
        2. 用户逻辑在一个单独的thread
        new Thread(new Runnable() {
            @Override
            public void run() {
                Log.i(TAG, "running in defined job");
                3. 完成后显示jobFinished
                jobFinished(params, false);
            }
        }).start();
        return true;
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        return false;
    }

    public static boolean scheduleJob(Context context, long delay){
        Log.i(TAG, "call into scheduleJob");
        4. 获得系统服务：jobscheduler
        JobScheduler jobScheduler = (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE);
        5. 为什么要取消？防止多个，每次提交job前都要取消相同的job
        jobScheduler.cancel(17493201);
        ComponentName cn = new ComponentName(context.getPackageName(), CloudUpdateJobService.class.getName());
        Log.i(TAG, "package name: " + context.getPackageName());
        Log.i(TAG, "class name: by class.getName:   " + CloudUpdateJobService.class.getName());
        Log.i(TAG, "class name: by class:           " + CloudUpdateJobService.class);
        6.创建JobInfo.Builder,参数是job_id和 ComponentName[通过ComponentName和用户实现的JobService关联]
        7.向JobInfo.Builder赋值
        8.由JobInfo.Builder创建JobInfo
        JobInfo jobInfo = new JobInfo.Builder(17493201, cn)
                .setRequiredNetworkType(JobInfo.NETWORK_TYPE_NONE)
                .setPeriodic(10000, 5000)
                .build();
        Log.i(TAG, "after build JobInfo then submit");
        9.调用系统服务jobScheduler的接口schedule
        if (jobScheduler.schedule(jobInfo) <= JobScheduler.RESULT_FAILURE) {
            Log.i(TAG, "scheduleJob 17493201 failed");
            return false;
        }
        return true;
    }
}

使用中遇到的问题

Builder setPeriodic(5000)使用5S周期方式，一直没看到输出，不知道哪里出错了

1.是ComponentName错了吗？和Class name有什么区别？

/**
 * Identifier for a specific application component
 * ({@link android.app.Activity}, {@link android.app.Service},
 * {@link android.content.BroadcastReceiver}, or
 * {@link android.content.ContentProvider}) that is available.  Two
 * pieces of information, are required to identify
 * a component: the package (a String) it exists in, and the class (a String)
 * name inside of that package.
 *
 */

new ComponentName(context.getPackageName(), CloudUpdateJobService.class.getName());

new ComponentName(context, CloudUpdateJobService.class);

从打印的log看两种方法都没有问题，但奇怪的是两个构造函数中表示className的方式不同。

2. dumpsys jobscheduler看下job是否在？

首先明确jobscheduler是个系统服务

service list | grep jobscheduler
jobscheduler: [android.app.job.IJobScheduler]

3. dumpsys jobscheduler | grep android_learning
看对应的jobcom.xiaomi.aiasst.android_learning/.CloudUpdateJobServices是否执行 : 是否有START-P

JOB #u0a214/17493201: 7ad602a com.xiaomi.aiasst.android_learning/.CloudUpdateJobService
u0a214 tag=*job*/com.xiaomi.aiasst.android_learning/.CloudUpdateJobService
Source: uid=u0a214 user=0 pkg=com.xiaomi.aiasst.android_learning
Service: com.xiaomi.aiasst.android_learning/.CloudUpdateJobService
#u0a214/17493201 from u0a214 idle: com.xiaomi.aiasst.android_learning [RUN_ANY_IN_BACKGROUND allowed] RUNNABLE
#u0a214/17493201 from u0a214: com.xiaomi.aiasst.android_learning RUNNABLE
-6h23m44s681ms START-P: #u0a212/17493201 com.xiaomi.aiasst.android_learning/.CloudUpdateJobService
-6h23m44s631ms STOP: #u0a212/17493201 com.xiaomi.aiasst.android_learning/.CloudUpdateJobService app called jobFinished

怎样合理配置jobInfo

setPeriodic(long intervalMillis) -> setPeriodic(long intervalMillis, long flexMillis) 问题有所改善，因为两个参数的函数有个执行的大概限制，而一个参数的函数没有任何限制，不知道合适执行完全有系统决定。

setMinimumLatency(60 * 1000) // 任务最少延迟时间

//如果设置了Deadline就能log输出，调试时可以这么用
setOverrideDeadline(120 * 1000) // 任务deadline，当到期没达到指定条件也会开始执行

另外，周期型job，大多也没有用period的方式，一般是执行单个job后在schedule一次。

有关配置文件AndroidManifest.xml

要加上 android:permission="android.permission.BIND_JOB_SERVICE" >
<service
    android:name=".CloudUpdateJobService"
    android:permission="android.permission.BIND_JOB_SERVICE" >
</service>

shuai_wen

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
android: job service

使用jobService遇到一些坑，这里记录下：Job在android中的地位还是很重要的，代码位于android/app/job 和activity、service并列，(不知道另外两个broadcast和provide放在哪里？)public abstract class JobService extends Servicepublic abstract class JobSe...
复制链接

扫一扫