Em determinadas situações, talvez seja necessário oferecer uma estratégia personalizada para linhas de execução. Por exemplo, você pode precisar processar uma operação assíncrona baseada em callback. Nesse caso, não é possível simplesmente confiar em um Worker
, porque ele não pode fazer o trabalho de forma bloqueada. O WorkManager é compatível com esse caso de uso com ListenableWorker
. ListenableWorker
é a API de worker mais básica. Worker
, CoroutineWorker
e RxWorker
são derivados dessa classe. Um ListenableWorker
sinaliza apenas quando o trabalho precisa iniciar e parar, deixando toda a linha de execução por sua conta. O sinal de início do trabalho é invocado na linha de execução principal, então é muito importante que você vá manualmente a uma linha de execução em segundo plano da sua escolha.
O método abstrato ListenableWorker.startWork()
retorna um ListenableFuture
do Result
. Um ListenableFuture
é uma interface leve: é um Future
que fornece funcionalidade para anexar listeners e propagar exceções. No método startWork
, você precisa retornar um ListenableFuture
, que será definido com o Result
da operação assim que ela for concluída. É possível criar instâncias de ListenableFuture
de duas maneiras:
- Se você usa Guava, use
ListeningExecutorService
. - Caso contrário, inclua
councurrent-futures
no arquivo do Gradle e useCallbackToFutureAdapter
.
Se você quer executar algum trabalho com base em um callback assíncrono, faça algo parecido com isto:
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; }); } }
O que acontece se seu trabalho for interrompido? O ListenableFuture
de um ListenableWorker
é sempre cancelado quando o trabalho é interrompido. Usando um CallbackToFutureAdapter
, basta adicionar um listener de cancelamento da seguinte forma:
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; }); } }
Como executar um ListenableWorker em um processo diferente
Também é possível vincular um worker a um processo específico usando
RemoteListenableWorker
,
uma implementação de ListenableWorker
.
RemoteListenableWorker
se vincula a um processo específico com dois argumentos
extras que você fornece como parte dos dados de entrada ao criar a solicitação
de trabalho: ARGUMENT_CLASS_NAME
e ARGUMENT_PACKAGE_NAME
.
O exemplo a seguir demonstra a criação de uma solicitação de trabalho vinculada a um processo 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
, também é preciso adicionar uma definição de serviço no
arquivo 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>
Exemplos
- WorkManagerMultiProcessSample (link em inglês)