En ciertas situaciones, es posible que debas proporcionar una estrategia de subprocesos personalizada. Para
Por ejemplo, quizás debas administrar una operación asíncrona basada en devoluciones de llamada.
WorkManager admite este caso de uso con
ListenableWorker
ListenableWorker es la API de trabajador más básica.
Worker,
CoroutineWorker y
RxWorker derivan de esta clase. R
ListenableWorker solo indica cuándo debe comenzar, detenerse y salir el trabajo.
la conversación depende completamente de ti. El indicador de inicio de trabajo se invoca en la puerta de enlace
por lo que es muy importante que vayas a un subproceso en segundo plano de tu
elegir manualmente.
El método abstracto
ListenableWorker.startWork()
muestra un ListenableFuture del
Result R
ListenableFuture es una interfaz liviana: es un Future que proporciona
para adjuntar objetos de escucha y propagar excepciones. En la
startWork, se espera que muestres un ListenableFuture, que
se establecerá con el Result de la operación una vez que se complete. Puedes crear
ListenableFuture instancias de una de estas dos maneras:
- Si usas Guava, utiliza
ListeningExecutorService. - De lo contrario, incluye
councurrent-futuresen tu archivo de Gradle y usarCallbackToFutureAdapter
Si quisieras ejecutar un trabajo basado en una devolución de llamada asíncrona, tendrías que haz algo como esto:
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;
});
}
}
¿Qué sucede si tu trabajo está
detenido?
Un elemento ListenableFuture de ListenableWorker siempre se cancela cuando el trabajo se
se espera que se detengan. Con un CallbackToFutureAdapter, solo debes agregar un
objeto de escucha de cancelación, de la siguiente manera:
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;
});
}
}
Cómo ejecutar un ListenableWorker en un proceso diferente
También puedes vincular un trabajador a un proceso específico mediante RemoteListenableWorker, que es una implementación de ListenableWorker.
RemoteListenableWorker vincula un proceso específico con dos argumentos adicionales que puedes proporcionar como parte de los datos de entrada cuando compilas la solicitud de trabajo: ARGUMENT_CLASS_NAME y ARGUMENT_PACKAGE_NAME.
En el siguiente ejemplo, se muestra cómo compilar una solicitud de trabajo vinculada a un proceso específico:
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();
Para cada RemoteWorkerService, también debes agregar una definición del servicio en el archivo 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>