W niektórych sytuacjach konieczne może być opracowanie niestandardowej strategii podziału na wątki. Może być np. konieczne wykonanie operacji asynchronicznej opartej na wywołaniu zwrotnym.
WorkManager obsługuje ten przypadek użycia w ListenableWorker
.
ListenableWorker
to najbardziej podstawowy interfejs API dla instancji roboczych. Wszystkie elementy Worker
, CoroutineWorker
i RxWorker
pochodzą z tej klasy. ListenableWorker
informuje tylko o tym, kiedy zadanie ma się rozpocząć, a kiedy powinno się zakończyć, i pozostaje całkowicie Twoim obowiązkiem. Sygnał startowy jest wywoływany w wątku głównym, dlatego tak ważne jest ręczne przejście do wybranego wątku w tle.
Metoda abstrakcyjna ListenableWorker.startWork()
zwraca ListenableFuture
z Result
. ListenableFuture
to prostszy interfejs: Future
, który udostępnia funkcje dołączania detektorów i propagowania wyjątków. W metodzie startWork
powinien być zwracany element ListenableFuture
, który należy ustawić jako Result
operacji po jej zakończeniu. Instancje ListenableFuture
możesz utworzyć na 2 sposoby:
- Jeśli używasz gujawy, użyj
ListeningExecutorService
. - W przeciwnym razie umieść
councurrent-futures
w pliku Gradle i użyjCallbackToFutureAdapter
.
Jeśli chcesz wykonać działanie oparte na asynchronicznym wywołaniu zwrotnym, możesz zrobić to w następujący sposób:
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; }); } }
Co się stanie, jeśli praca zostanie zatrzymana?
ListenableFuture
na urządzeniu ListenableWorker
jest zawsze anulowany, gdy przewiduje się zakończenie pracy. Za pomocą CallbackToFutureAdapter
wystarczy dodać odbiornik anulowania w ten sposób:
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; }); } }
Uruchamianie elementu ListenableWorker w innym procesie
Możesz też powiązać instancję roboczą z konkretnym procesem za pomocą RemoteListenableWorker
, implementacji ListenableWorker
.
Funkcja RemoteListenableWorker
wiąże się z konkretnym procesem za pomocą 2 dodatkowych argumentów, które podajesz jako część danych wejściowych podczas tworzenia żądania: ARGUMENT_CLASS_NAME
i ARGUMENT_PACKAGE_NAME
.
Przykład poniżej pokazuje tworzenie żądania pracy, które jest powiązane z konkretnym procesem:
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();
Do każdego elementu RemoteWorkerService
musisz też dodać definicję usługi w pliku 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>