Summary: Ctors | Methods | Inherited Methods

Worker

Kotlin |Java

public abstract class Worker
extends ListenableWorker

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

A class that performs work synchronously on a background thread provided by WorkManager.

Worker classes are instantiated at runtime by WorkManager and the doWork() method is called on a pre-specified background thread (see Configuration.getExecutor()). This method is for synchronous processing of your work, meaning that once you return from that method, the Worker is considered to be finished and will be destroyed. If you need to do your work asynchronously or call asynchronous APIs, you should use ListenableWorker.

In case the work is preempted for any reason, the same instance of Worker is not reused. This means that doWork() is called exactly once per Worker instance. A new Worker is created if a unit of work needs to be rerun.

A Worker 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.

Summary

Public constructors
`Worker(Context context, WorkerParameters workerParams)`

Public methods
`abstract ListenableWorker.Result`	`doWork()` Override this method to do your actual background processing.
`final ListenableFuture<ListenableWorker.Result>`	`startWork()` Override this method to start your actual background processing.

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 specifies that the `WorkRequest` is long-running or otherwise important.
`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

Worker

public Worker (Context context, 
                WorkerParameters workerParams)

Parameters
`context`	`Context`
`workerParams`	`WorkerParameters`

Public methods

doWork

public abstract ListenableWorker.Result doWork ()

Override this method to do your actual background processing. This method is called on a background thread - you are required to synchronously do your work and return the ListenableWorker.Result from this method. Once you return from this method, the Worker is considered to have finished what its doing and will be destroyed. If you need to do your work asynchronously on a thread of your own choice, see ListenableWorker.

A Worker has a well defined execution window to finish its execution and return a ListenableWorker.Result. After this time has expired, the Worker will be signalled to stop.

Returns
`ListenableWorker.Result`	The `ListenableWorker.Result` of the computation; note that dependent work will not execute if you use `ListenableWorker.Result.failure()` or `ListenableWorker.Result.failure(Data)`

startWork

public final ListenableFuture<ListenableWorker.Result> startWork ()

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

A ListenableWorker has a well defined execution window to 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.