标签: android-workmanager

我正在尝试使用 WorkManager 运行后台服务。当应用程序进入后台时，我启动了 WorkManager。每当 WorkManger 运行时，我也会启动后台服务。应用程序进入后台后，我可以看到我的应用程序服务。我还可以看到，它是在我通过在应用程序列表中滑动关闭应用程序后大约 15 分钟后启动的。所以我确信 Workmanager 在开始时正在工作。但我认为它不适用于打瞌睡模式。将手机从打瞌睡模式唤醒后，我也看不到我的服务。

我的代码：

public class MyWorker extends Worker {

  public MyWorker() {
    super();
  }

  @NonNull
  @Override
  public WorkerResult doWork() {

    Intent intent = new Intent(getApplicationContext(), MyService.class);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        MyJobIntentService.enqueueWork(getApplicationContext(), new Intent());
    } else {
Intent intent = new Intent(getApplicationContext(), MyService.class);
        getApplicationContext().startService(intent);
    }

    return WorkerResult.SUCCESS;
  }
}

public void startWorkManger() {

  PeriodicWorkRequest request = new PeriodicWorkRequest
         .Builder(MyWorker.class, MIN_PERIODIC_INTERVAL_MILLIS, TimeUnit.MILLISECONDS).addTag(TAG).build();
  mWorkManager.enqueue(request);
}

有什么不对？

我有一个必须在固定进程中运行的后台任务。我目前正在JobIntentService为此使用 a 。但是，我想迁移到 WorkManager 以利用基于网络的任务延迟。

使用 WorkManager 或任何其他 API 14-28 兼容方式是否有任何解决方案？

我想将一些对象上传到服务器。我正在使用工作管理器和 uniqueWork 来避免上传重复的对象。工作受到限制，因此它们仅在有互联网连接时才能运行。问题是我希望这些对象中的每一个一次上传一个，但所有的工作都是一次发生的。

我知道我可以使用 beginWith 和 workContinuations 来依次执行工作，但不幸的是，可以在不同的时间创建多个对象，因此我无法访问创建工作时的所有工作。

val workRequest = OneTimeWorkRequestBuilder<UploadWorker>()
            .setConstraints(networkConstraint)
            .build()
WorkManager.getInstance()
            .enqueueUniqueWork(uniqueName, ExistingWorkPolicy.KEEP, workRequest)

我认为enqueue这意味着所有的工作都会像队列一样一次发生。有没有办法让它以这种方式工作？

我是新手，所以如果问题措辞不当，请告诉我！我有一个 Android 应用程序，即使手机处于锁定状态，它也需要大约每 15 分钟执行一次任务。上下文是： - 我的目标是 SDK 23 或更高版本 - 任务 1) 获取用户的位置 2) 使用 OKHttpClient 调用 HTTPS API，然后 3) 将结果发送到 Firestore 数据库

我正在使用 WorkManager 来尝试实现这一目标。但是，问题是每次执行时，都会执行 8-9 次，而且时间很不规律。我可以从 Firestore 条目和 Logcat 中看到这一点。

WorkManager 甚至是完成这项任务的正确方法吗？我在用

implementation "androidx.work:work-runtime:2.0.1"
import androidx.work.PeriodicWorkRequest;
import androidx.work.WorkManager;
import androidx.work.ExistingPeriodicWorkPolicy;

我看到其他人有这个问题：Android Worker 多次执行该作业

//In MainActivity.java: 

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        PeriodicWorkRequest periodicWorkRequest = new PeriodicWorkRequest.Builder(
                PeriodicReadings.class, 15, TimeUnit.MINUTES).build();

        WorkManager.getInstance().enqueueUniquePeriodicWork("PWR", ExistingPeriodicWorkPolicy.REPLACE, periodicWorkRequest);

//In PeriodicReadings.java:

    @NonNull
    @Override
    public Result doWork() {
        getReadings(); //work to be …

我配置了一个定期工作管理器请求，似乎它在 Pixel（Android 9.0 版）上运行，但在同样运行 9.0 的三星设备上失败

//Work manager request
final PeriodicWorkRequest workRequest = new PeriodicWorkRequest.Builder(MyWorker.class, 1, TimeUnit.HOURS).build();

WorkManager.getInstance().enqueueUniquePeriodicWork("My_TASK", ExistingPeriodicWorkPolicy.REPLACE, workRequest);

// My worker
public class MyWorker extends Worker {

public MyWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
    super(context, workerParams);
}

@NonNull
@Override
public Result doWork() {
    //some work
    return Result.success();
}
}

在我的聊天应用程序中，我想从本地数据库读取消息并由工作经理将它们发送到服务器，并在用户发送新消息时进行改造。

在父母中：

 OneTimeWorkRequest workRequest = new OneTimeWorkRequest
        .Builder(SendMsg_Work.class)
        .setConstraints(new Constraints
                .Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .build())
        .setInitialDelay(5, TimeUnit.SECONDS)
        .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
        .build();
    WorkManager.getInstance().enqueue(workRequest);

在工人：

@NonNull
@Override
public Result doWork() {
        ChatRoom_Model_Local ll = database.get_unSendMsg();
        if (ll != null) {
            sendMessage(ll);
        } else {
            return Result.failure();
        }
}

和改造 - 我也使用 RxJava ：

private void sendMessage(ChatRoom_Model_Local model) {

    Single<Response<MSG_Response>> api = ApiClient.createService(ApiInterface.class, pr.getData(pr.SendMessage_url))
            .sendMSG(pr.getData(pr.MY_TOKEN), model.getOther_user(), model.getMsg_text());

    api.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new SingleObserver<Response<MSG_Response>>() {
                @Override
                public void onSubscribe(Disposable d) { }

                @Override
                public void onSuccess(Response<MSG_Response> response) { …

我正在使用 WorkManager 将 OneTimeWorkRequests 排队以进行文件上传。这当然需要网络连接，如果设备没有连接并且上传失败，它将按照我指定的重试/退避策略重试。

我的问题很简单：

我可以更改重试的最大退避时间吗？

默认情况下，最大退避时间设置为 5 小时，理想情况下，我想减少这一点，但我一直找不到这样做的方法。

请参阅我的代码以将工作请求排队如下：

Constraints constraints = new Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .build();

OneTimeWorkRequest uploadRequest = new OneTimeWorkRequest.Builder(UploadFileWorker.class)
                .setInputData(createInputDataForUri(file.getPath()))
                .setConstraints(constraints)
                .setBackoffCriteria(BackoffPolicy.EXPONENTIAL,
                        OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
                        TimeUnit.MILLISECONDS)
                .build();

workManager.enqueueUniqueWork(UNIQUE_WORK_FILE_UPLOAD, ExistingWorkPolicy.APPEND, uploadRequest);

我们可以使用 轻松设置 BackoffPolicy（线性/指数）和 backoffDelay .setBackoffCriteria()，并为请求添加初始延迟，但我认为无法自定义重试的最大退避时间。这是设计使然，还是我只是瞎了眼？

是否有 WorkManager 的支持库版本。在WorkManager的发行说明中，有一个 pre androidx version 1.0.1 可用。

但是在添加与依赖项相同的内容时implementation "android.arch.work:work-runtime:1.0.1"，导入仍然是import androidx .work.Worker 。

关于如何为仍然依赖于支持库的项目添加 WorkManager 的任何想法？

编辑 1：根据文档链接中的注释，WorkManager 1.0.1 是 androidx 包的一部分，但仍依赖于非 androidx 库。看起来它只是一个名称，然后被引用到 androidx。

小米和Oppo等中文ROM的工作管理器，在电池优化下，将计划的工作延迟增加了几个小时。但是，我注意到一些应用程序即使在电池优化下也能安静地运行计划的作业。我注意到的一个区别是它们在每次作业运行时都会显示一条通知，那么电池优化器是否负责使应用程序保持活动状态？

而且我还注意到，在我强制停止该应用程序后，24 小时后它又开始工作了，但这怎么可能？任何人都可以了解幕后发生的事情，以及他们将使用什么方法？

如果需要更多详细信息，请告诉我。

public static WorkInfo.State getStateOfWork() {

    if (WorkManager.getInstance().getWorkInfosForUniqueWork("affirmation").get().size() > 0) {
        return WorkManager.getInstance().getWorkInfosForUniqueWork("affirmation")
                .get().get(0).getState();
        // this can return WorkInfo.State.ENQUEUED or WorkInfo.State.RUNNING
        // you can check all of them in WorkInfo class.
    } else {
        return WorkInfo.State.CANCELLED;
    }
} catch (ExecutionException e) {
    e.printStackTrace();
    return WorkInfo.State.CANCELLED;
} catch (InterruptedException e) {
    e.printStackTrace();
    return WorkInfo.State.CANCELLED;
}
}

public static void createWorkRequest() {
Constraints constraints = new Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build();
PeriodicWorkRequest periodicWorkRequest = new PeriodicWorkRequest.Builder
        (MyWorkManager.class, 30, TimeUnit.MINUTES)
        .setConstraints(constraints)
        .build();
WorkManager.getInstance()
        .enqueueUniquePeriodicWork("affirmation", ExistingPeriodicWorkPolicy.REPLACE, periodicWorkRequest);

}