Question

我正在开发一个Android应用，该应用要求每小时执行一次后台任务（Job Scheduler或Service）。当应用程序运行时，任务会执行，但是一旦我从前台杀死该应用程序，服务就无法工作。还有另一种方法可以做到这一点吗？

1。服务

public class NotificationService extends JobService {

    private void PrintLog()
    {
        Log.d("DGVCL", "PrintLog()");
    }

    @Override
    public boolean onStartJob(JobParameters jobParameters) {
        Log.d("DGVCL", "onStartJob()");
        PrintLog();
        jobFinished(jobParameters, false);
        return true;
    }

    @Override
    public boolean onStopJob(JobParameters jobParameters) {
        Log.d("DGVCL", "onStopJob()");
        return true;
    }
}

2。主要活动

JobScheduler jobScheduler = (JobScheduler)getApplicationContext().getSystemService(JOB_SCHEDULER_SERVICE);
        ComponentName componentName = new ComponentName(this, NotificationService.class);
        JobInfo jobInfo = new JobInfo.Builder(1, componentName)
                .setPeriodic(Global.NOTIFICATION_TIME_PERIOD)
                .setBackoffCriteria(Global.NOTIFICATION_TIME_PERIOD, JobInfo.BACKOFF_POLICY_LINEAR)
                .setPersisted(true).build();
        jobScheduler.schedule(jobInfo);

3。清单

<service android:name="com.hopesndreams.hiren.hd.service.NotificationService" android:permission="android.permission.BIND_JOB_SERVICE" >
    </service>

Answer 1

@hiren patel ..看一个例子..它可以正常工作。

Job Scheduler in Background

我认为您需要在杀死或销毁之前安排调度程序。

作业调度程序有局限性
它无法离线使用。
其时间段为15分钟，在15分钟后，它会自动停止服务，我们必须重新开始或重新安排作业。

谢谢..

Answer 2

使用WorkManager，它是在JobScheduler的基础上构建的，并且专门用于接管所有后台服务，包括前台和后台功能。 https://developer.android.com/topic/libraries/architecture/workmanager

Answer 3

*使用AlarmManager *

步骤1：创建服务

在服务中执行您的逻辑

        public class AService extends Service {

        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            //do something
        }

        @Override
        public void onCreate() {
            //do somrthing
        }
    }

第2步：创建BroadCast接收器

以此启动您的服务。

        public class AReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            try {
                Intent intent = new Intent(context, AService.class);
                context.startService(intent);
            } catch (Exception e) {
            }
        }
    }

在MainActivity中

   Intent liveIntent = new Intent(getApplicationContext(), AReceiver.class);
    PendingIntent recurring = PendingIntent.getBroadcast(getApplicationContext(), 0, liveIntent, PendingIntent.FLAG_CANCEL_CURRENT);
    AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
    Calendar updateTime = Calendar.getInstance();
    alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, updateTime.getTimeInMillis(), 16 * 60 * 1000, recurring);
    //wakeup and starts service in every 16 minutes.

这是为我工作的方法。即使关闭应用程序也可以正常工作。在小米设备上工作。

别忘了在清单中添加服务

Answer 4

实际上，WorkManager是必经之路。

您可以阅读更多有关其他工作原语的信息，以适合您的任务here，但是以下实现在WorkManager中使用Worker进行线程化，该线程在后台线程上同步执行工作。

public class BackgroundWorker extends Worker {

    public BackgroundWorker
            (@NonNull Context context,
             @NonNull WorkerParameters params) {
             super(context, params);
    }

    @NonNull
    @Override

    public Worker.Result doWork() {     
        yourBackgroundTask();  // yourBackgroundTask() implementation
        return Result.success();
    }

    public static void schedulePeriodicWork(Data data) {
        // When multiple constraints are specified like below, 
        // your task will run only when all the constraints are met.
        Constraints constraints = new Constraints.Builder()
                        .setRequiredNetworkType(NetworkType.CONNECTED)
                        .setRequiresBatteryNotLow(true)
                        .setRequiresCharging(true)
                        .build();

        PeriodicWorkRequest taskWork = new PeriodicWorkRequest.Builder(BackgroundWorker.class, 60,
                TimeUnit.MINUTES)
                .setConstraints(constraints)
                .setInputData(data)
                .build();

        WorkManager.getInstance().enqueue(taskWork);
    } 
}

稍后在onCreate()内的MainActivity文件中：

Data data = workData();

BackgroundWorker.schedulePeriodicWork(data);

然后在onCreate()方法之外，

private Data workData() {
    return new Data.Builder() // to build Data objects
        .build();
}

需要注意的一点是，尽管我们将上述任务设置为每60分钟执行一次，但每次迭代可能不会在相同的时间间隔执行。

根据Android文档，WorkManager用于可推迟的工作，并且必须容忍一些漂移。但是，您可以在日志控制台中查看更新“ WM-WorkerWrapper: Worker result SUCCESS for Work”。

希望这会有所帮助。

应用程序被杀死后，Job Scheduler服务不起作用

4 个答案: