此页面由 Cloud Translation API 翻译。

ListenableWorker 中的线程处理

在某些情况下，您可能需要提供自定义线程处理策略。对于例如，您可能需要处理基于回调的异步操作。 WorkManager 通过 ListenableWorker。 ListenableWorker 是最基本的工作器 API； Worker, CoroutineWorker和 RxWorker 都是从此类派生而来。答 ListenableWorker 只会发出信号，指示作业何时开始、停止和离开一切都由你自己决定在主线程上调用开始工作信号因此，请务必转到您应用的某个后台线程手动选择。

抽象方法 ListenableWorker.startWork() 返回ListenableFuture Result。答 ListenableFuture 是一个轻量级接口：它是一个Future，可提供用于附加监听器和传播异常的功能。在 startWork 方法，您应返回 ListenableFuture，在操作完成后，将使用其 Result 进行设置。您可以创建 ListenableFuture 实例：

如果您使用的是 Guava，请使用 ListeningExecutorService。
否则，请包含 councurrent-futures ，然后使用以下代码 CallbackToFutureAdapter。

如果您希望基于异步回调执行一些工作，执行如下操作：

Kotlin

class CallbackWorker(
        context: Context,
        params: WorkerParameters
) : ListenableWorker(context, params) {
    override fun startWork(): ListenableFuture<Result> {
        return CallbackToFutureAdapter.getFuture { completer ->
            val callback = object : Callback {
                var successes = 0

                override fun onFailure(call: Call, e: IOException) {
                    completer.setException(e)
                }

                override fun onResponse(call: Call, response: Response) {
                    successes++
                    if (successes == 100) {
                        completer.set(Result.success())
                    }
                }
            }

            repeat(100) {
                downloadAsynchronously("https://example.com", callback)
            }

            callback
        }
    }
}

Java

public class CallbackWorker extends ListenableWorker {

    public CallbackWorker(Context context, WorkerParameters params) {
        super(context, params);
    }

    @NonNull
    @Override
    public ListenableFuture<Result> startWork() {
        return CallbackToFutureAdapter.getFuture(completer -> {
            Callback callback = new Callback() {
                int successes = 0;

                @Override
                public void onFailure(Call call, IOException e) {
                    completer.setException(e);
                }

                @Override
                public void onResponse(Call call, Response response) {
                    successes++;
                    if (successes == 100) {
                        completer.set(Result.success());
                    }
                }
            };

            for (int i = 0; i < 100; i++) {
                downloadAsynchronously("https://www.example.com", callback);
            }
            return callback;
        });
    }
}

如果您的工作已停止？当工作被取消时，ListenableWorker 的 ListenableFuture 始终会被取消。预计会停止运行。使用 CallbackToFutureAdapter 时，您只需添加一个取消监听器，如下所示：

Kotlin

class CallbackWorker(
        context: Context,
        params: WorkerParameters
) : ListenableWorker(context, params) {
    override fun startWork(): ListenableFuture<Result> {
        return CallbackToFutureAdapter.getFuture { completer ->
            val callback = object : Callback {
                var successes = 0

                override fun onFailure(call: Call, e: IOException) {
                    completer.setException(e)
                }

                override fun onResponse(call: Call, response: Response) {
                    ++successes
                    if (successes == 100) {
                        completer.set(Result.success())
                    }
                }
            }

 completer.addCancellationListener(cancelDownloadsRunnable, executor)

            repeat(100) {
                downloadAsynchronously("https://example.com", callback)
            }

            callback
        }
    }
}

Java

public class CallbackWorker extends ListenableWorker {

    public CallbackWorker(Context context, WorkerParameters params) {
        super(context, params);
    }

    @NonNull
    @Override
    public ListenableFuture<Result> startWork() {
        return CallbackToFutureAdapter.getFuture(completer -> {
            Callback callback = new Callback() {
                int successes = 0;

                @Override
                public void onFailure(Call call, IOException e) {
                    completer.setException(e);
                }

                @Override
                public void onResponse(Call call, Response response) {
                    ++successes;
                    if (successes == 100) {
                        completer.set(Result.success());
                    }
                }
            };

            completer.addCancellationListener(cancelDownloadsRunnable, executor);

            for (int i = 0; i < 100; ++i) {
                downloadAsynchronously("https://www.example.com", callback);
            }
            return callback;
        });
    }
}

在其他进程中运行 ListenableWorker

您还可以使用 RemoteListenableWorker（ListenableWorker 的实现）将工作器绑定到特定进程。

RemoteListenableWorker 会使用您在构建工作请求时于输入数据中提供的两个额外参数绑定到特定进程：ARGUMENT_CLASS_NAME 和 ARGUMENT_PACKAGE_NAME。

以下示例演示了如何构建绑定到特定进程的工作请求：

Kotlin

val PACKAGE_NAME = "com.example.background.multiprocess"

val serviceName = RemoteWorkerService::class.java.name
val componentName = ComponentName(PACKAGE_NAME, serviceName)

val data: Data = Data.Builder()
   .putString(ARGUMENT_PACKAGE_NAME, componentName.packageName)
   .putString(ARGUMENT_CLASS_NAME, componentName.className)
   .build()

return OneTimeWorkRequest.Builder(ExampleRemoteListenableWorker::class.java)
   .setInputData(data)
   .build()

Java

String PACKAGE_NAME = "com.example.background.multiprocess";

String serviceName = RemoteWorkerService.class.getName();
ComponentName componentName = new ComponentName(PACKAGE_NAME, serviceName);

Data data = new Data.Builder()
        .putString(ARGUMENT_PACKAGE_NAME, componentName.getPackageName())
        .putString(ARGUMENT_CLASS_NAME, componentName.getClassName())
        .build();

return new OneTimeWorkRequest.Builder(ExampleRemoteListenableWorker.class)
        .setInputData(data)
        .build();

对于每个 RemoteWorkerService，您还需要在 AndroidManifest.xml 文件中添加服务定义：

<manifest ... >
    <service
            android:name="androidx.work.multiprocess.RemoteWorkerService"
            android:exported="false"
            android:process=":worker1" />

        <service
            android:name=".RemoteWorkerService2"
            android:exported="false"
            android:process=":worker2" />
    ...
</manifest>

示例

WorkManagerMultiProcessSample