Summary: Ctors | Methods | Protected Methods | Inherited Methods

RxWorker

Kotlin |Java

public abstract class RxWorker
extends ListenableWorker

java.lang.Object
↳	androidx.work.ListenableWorker
	↳	androidx.work.RxWorker

RxJava2 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 ListenableWorker.Result. After this time has expired, the worker will be signalled to stop.

See also:

Worker

Summary

Public constructors
`RxWorker(Context appContext, WorkerParameters workerParams)`

Public methods
`abstract Single<ListenableWorker.Result>`	`createWork()` Override this method to define your actual work and return a `Single` of `ListenableWorker.Result` which will be subscribed by the `WorkManager`.
`void`	`onStopped()` This method is invoked when this Worker has been told to stop.
`final Completable`	`setCompletableProgress(Data data)` Updates the progress for a `RxWorker`.
`final Single<Void>`	`setProgress(Data data)` This method is deprecated. This method is being deprecated because it is impossible to signal success via a `Single<Void>` type. A `Completable` should have been used. Use `setCompletableProgress(Data)` instead.
`ListenableFuture<ListenableWorker.Result>`	`startWork()` Override this method to start your actual background processing.

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

Inherited methods

From class


        
          androidx.work.ListenableWorker

`final Context`	`getApplicationContext()` Gets the application `Context`.
`ListenableFuture<ForegroundInfo>`	`getForegroundInfoAsync()` Return an instance of `ForegroundInfo` if the `WorkRequest` is important to the user.
`final UUID`	`getId()` Gets the ID of the `WorkRequest` that created this Worker.
`final Data`	`getInputData()` Gets the input data.
`final Network`	`getNetwork()` Gets the `Network` to use for this Worker.
`final int`	`getRunAttemptCount()` Gets the current run attempt count for this work.
`final Set<String>`	`getTags()` Gets a `Set` of tags associated with this Worker's `WorkRequest`.
`final List<String>`	`getTriggeredContentAuthorities()` Gets the list of content authorities that caused this Worker to execute.
`final List<Uri>`	`getTriggeredContentUris()` Gets the list of content `Uri`s that caused this Worker to execute.
`final boolean`	`isStopped()` Returns `true` if this Worker has been told to stop.
`void`	`onStopped()` This method is invoked when this Worker has been told to stop.
`final ListenableFuture<Void>`	`setForegroundAsync(ForegroundInfo foregroundInfo)` This method is deprecated. Use `WorkRequest.Builder.setExpedited(OutOfQuotaPolicy)` and `getForegroundInfoAsync()` instead.
`final ListenableFuture<Void>`	`setProgressAsync(Data data)` Updates `ListenableWorker` progress.
`abstract ListenableFuture<ListenableWorker.Result>`	`startWork()` Override this method to start your actual background processing.

From class


        
          java.lang.Object

`Object`	`clone()`
`boolean`	`equals(Object arg0)`
`void`	`finalize()`
`final Class<?>`	`getClass()`
`int`	`hashCode()`
`final void`	`notify()`
`final void`	`notifyAll()`
`String`	`toString()`
`final void`	`wait(long arg0, int arg1)`
`final void`	`wait(long arg0)`
`final void`	`wait()`

Public constructors

RxWorker

public RxWorker (Context appContext, 
                WorkerParameters workerParams)

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

Public methods

createWork

public abstract Single<ListenableWorker.Result> createWork ()

Override this method to define your actual work and return a Single of 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 ListenableWorker.Result. After this time has expired, the worker will be signalled to stop.

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

onStopped

public void onStopped ()

This method is invoked when this Worker has been told to stop. At this point, the ListenableFuture returned by the instance of startWork() is also cancelled. This could happen due to 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. All processing in this method should be lightweight - there are no contractual guarantees about which thread will invoke this call, so this should not be a long-running or blocking operation.

setCompletableProgress

public final Completable setCompletableProgress (Data data)

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

Parameters
`data`	`Data`: The progress `Data`

Returns
`Completable`	The `Completable`

setProgress

public final Single<Void> setProgress (Data data)

This method is deprecated.
This method is being deprecated because it is impossible to signal success via a `Single<Void>` type. A Completable should have been used.

Use setCompletableProgress(Data) instead.

Updates the progress for a RxWorker. This method returns a Single unlike the ListenableWorker.setProgressAsync(Data) API.

This method is deprecated. Use setCompletableProgress(Data) instead.

Parameters
`data`	`Data`: The progress `Data`

Returns
`Single<Void>`	The `Single`

startWork

public ListenableFuture<ListenableWorker.Result> startWork ()

Override this method to start your actual background processing. This method is called on the main thread.

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

The future will also be cancelled if this worker is stopped for any reason (see onStopped()).

Returns
`ListenableFuture<ListenableWorker.Result>`	A `ListenableFuture` with the `ListenableWorker.Result` of the computation. If you cancel this Future, WorkManager will treat this unit of work as failed.

Protected methods

getBackgroundScheduler

protected Scheduler getBackgroundScheduler ()

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.

Returns
`Scheduler`	The default `Scheduler`.