RxWorker

Kotlin |Java

abstract class RxWorker : ListenableWorker

kotlin.Any
↳	androidx.work.ListenableWorker
	↳	androidx.work.rxjava3.RxWorker

RxJava3 interoperability Worker implementation.

When invoked by the WorkManager, it will call @createWork() to get a Single<Result> subscribe to it.

By default, RxWorker will subscribe on the thread pool that runs WorkManager Workers. You can change this behavior by overriding getBackgroundScheduler() method.

An RxWorker is given a maximum of ten minutes to finish its execution and return a androidx.work.ListenableWorker.Result. After this time has expired, the worker will be signalled to stop.

Summary

Public constructors
`<init>(@NonNull appContext: Context, @NonNull workerParams: WorkerParameters)`

Public methods
abstract Single<ListenableWorker.Result!>	`createWork()` Override this method to define your actual work and return a `Single` of `androidx.work.ListenableWorker.Result` which will be subscribed by the `WorkManager`.
open Unit	`onStopped()`
Completable	`setCompletableProgress(@NonNull data: Data)` Updates the progress for a `RxWorker`.
ListenableFuture<ListenableWorker.Result!>	`startWork()`

Protected methods
open Scheduler	`getBackgroundScheduler()` Returns the default background scheduler that `RxWorker` will use to subscribe.

Inherited functions

From class ListenableWorker

`Context`	`getApplicationContext()` Gets the application `android.content.Context`.
`UUID`	`getId()` Gets the ID of the `WorkRequest` that created this Worker.
`Data`	`getInputData()` Gets the input data. Note that in the case that there are multiple prerequisites for this Worker, the input data has been run through an `InputMerger`.
`Network?`	`getNetwork()` Gets the `android.net.Network` to use for this Worker. This method returns `null` if there is no network needed for this work request.
`Int`	`getRunAttemptCount()` Gets the current run attempt count for this work. Note that for periodic work, this value gets reset between periods.
`MutableSet<String!>`	`getTags()` Gets a `java.util.Set` of tags associated with this Worker's `WorkRequest`.
`MutableList<String!>`	`getTriggeredContentAuthorities()` Gets the list of content authorities that caused this Worker to execute. See `JobParameters#getTriggeredContentAuthorities()` for relevant `JobScheduler` code.
`MutableList<Uri!>`	`getTriggeredContentUris()` Gets the list of content `android.net.Uri`s that caused this Worker to execute. See `JobParameters#getTriggeredContentUris()` for relevant `JobScheduler` code.
`Boolean`	`isStopped()` Returns `true` if this Worker has been told to stop. This could be because of an explicit cancellation signal by the user, or because the system has decided to preempt the task. In these cases, the results of the work will be ignored by WorkManager and it is safe to stop the computation. WorkManager will retry the work at a later time if necessary.
`ListenableFuture<Void!>`	`setForegroundAsync(@NonNull foregroundInfo: ForegroundInfo)` This specifies that the `WorkRequest` is long-running or otherwise important. In this case, WorkManager provides a signal to the OS that the process should be kept alive if possible while this work is executing. Calls to `setForegroundAsync` must complete before a `ListenableWorker` signals completion by returning a `Result`. Under the hood, WorkManager manages and runs a foreground service on your behalf to execute this WorkRequest, showing the notification provided in `ForegroundInfo`.
`ListenableFuture<Void!>`	`setProgressAsync(@NonNull data: Data)` Updates `ListenableWorker` progress.

Public constructors

<init>

RxWorker(
    @NonNull appContext: Context, 
    @NonNull workerParams: WorkerParameters)

Parameters
`appContext`	Context: The application `Context`
`workerParams`	WorkerParameters: Parameters to setup the internal state of this worker

Public methods

createWork

@MainThread @NonNull abstract fun createWork(): Single<ListenableWorker.Result!>

Override this method to define your actual work and return a Single of androidx.work.ListenableWorker.Result which will be subscribed by the WorkManager.

If the returned Single fails, the worker will be considered as failed.

If the RxWorker is cancelled by the WorkManager (e.g. due to a constraint change), WorkManager will dispose the subscription immediately.

By default, subscription happens on the shared Worker pool. You can change it by overriding getBackgroundScheduler().

An RxWorker is given a maximum of ten minutes to finish its execution and return a androidx.work.ListenableWorker.Result. After this time has expired, the worker will be signalled to stop.

Return
`Single<ListenableWorker.Result!>`	a `Single<Result>` that represents the work.

onStopped

@CallSuper open fun onStopped(): Unit

setCompletableProgress

@NonNull fun setCompletableProgress(@NonNull data: Data): Completable

Updates the progress for a RxWorker. This method returns a Completable similar to the ListenableWorker#setProgressAsync(Data) API.

Parameters
`data`	Data: The progress `Data`

Return
`Completable`	The `Completable`

startWork

@NonNull fun startWork(): ListenableFuture<ListenableWorker.Result!>

Protected methods

getBackgroundScheduler

@NonNull protected open fun getBackgroundScheduler(): Scheduler

Returns the default background scheduler that RxWorker will use to subscribe.

The default implementation returns a Scheduler that uses the Executor which was provided in WorkManager's Configuration (or the default one it creates).

You can override this method to change the Scheduler used by RxWorker to start its subscription. It always observes the result of the Single in WorkManager's internal thread.

Return
`Scheduler`	The default `Scheduler`.