To get started using WorkManager, first import the library into your Android
project.

Add the following dependencies to your app's `build.gradle` file:  

### Groovy

```groovy
dependencies {
    def work_version = "2.11.0"

    // (Java only)
    implementation "androidx.work:work-runtime:$work_version"

    // Kotlin + coroutines
    implementation "androidx.work:work-runtime-ktx:$work_version"

    // optional - RxJava2 support
    implementation "androidx.work:work-rxjava2:$work_version"

    // optional - GCMNetworkManager support
    implementation "androidx.work:work-gcm:$work_version"

    // optional - Test helpers
    androidTestImplementation "androidx.work:work-testing:$work_version"

    // optional - Multiprocess support
    implementation "androidx.work:work-multiprocess:$work_version"
}
```

### Kotlin

```kotlin
dependencies {
    val work_version = "2.11.0"

    // (Java only)
    implementation("androidx.work:work-runtime:$work_version")

    // Kotlin + coroutines
    implementation("androidx.work:work-runtime-ktx:$work_version")

    // optional - RxJava2 support
    implementation("androidx.work:work-rxjava2:$work_version")

    // optional - GCMNetworkManager support
    implementation("androidx.work:work-gcm:$work_version")

    // optional - Test helpers
    androidTestImplementation("androidx.work:work-testing:$work_version")

    // optional - Multiprocess support
    implementation("androidx.work:work-multiprocess:$work_version")
}
```

Once you've added the dependencies and synchronized your Gradle project, the
next step is to define some work to run.
| **Note:** You can always find the latest version of WorkManager, including beta, alpha, and release candidate versions on the [WorkManager releases
| page](https://developer.android.com/jetpack/androidx/releases/work).

## Define the work

Work is defined using the [Worker](https://developer.android.com/reference/androidx/work/Worker)
class. The `doWork()` method runs asynchronously on a background
thread provided by WorkManager.

To create some work for WorkManager to run, extend the `Worker` class and
override the `doWork()` method. For example, to create a `Worker` that uploads
images, you can do the following:  

### Kotlin

```kotlin
class UploadWorker(appContext: Context, workerParams: WorkerParameters):
       Worker(appContext, workerParams) {
   override fun doWork(): Result {

       // Do the work here--in this case, upload the images.
       uploadImages()

       // Indicate whether the work finished successfully with the Result
       return Result.success()
   }
}
```

### Java

```java
public class UploadWorker extends Worker {
   public UploadWorker(
       @NonNull Context context,
       @NonNull WorkerParameters params) {
       super(context, params);
   }

   @Override
   public Result doWork() {

     // Do the work here--in this case, upload the images.
     uploadImages();

     // Indicate whether the work finished successfully with the Result
     return Result.success();
   }
}
```

The [Result](https://developer.android.com/reference/androidx/work/ListenableWorker.Result)
returned from `doWork()` informs the WorkManager service whether the
work succeeded and, in the case of failure, whether or not the work should be
retried.

- `Result.success()`: The work finished successfully.
- `Result.failure()`: The work failed.
- `Result.retry()`: The work failed and should be tried at another time according to its [retry policy](https://developer.android.com/topic/libraries/architecture/workmanager/how-to/define-work#retries_backoff).

## Create a WorkRequest

Once your work is defined, it must be scheduled with the WorkManager service in
order to run. WorkManager offers a lot of flexibility in how you schedule your
work. You can schedule it to [run
periodically](https://developer.android.com/topic/libraries/architecture/workmanager/how-to/define-work#schedule_periodic_work)
over an interval of time, or you can schedule it to run only [one
time](https://developer.android.com/topic/libraries/architecture/workmanager/how-to/define-work#constraints).

However you choose to schedule the work, you will always use a
[WorkRequest](https://developer.android.com/reference/androidx/work/WorkRequest). While a
`Worker` defines the unit of work, a
[WorkRequest](https://developer.android.com/reference/androidx/work/WorkRequest) (and its
subclasses) define how and when it should be run. In the simplest case, you can
use a
[OneTimeWorkRequest](https://developer.android.com/reference/androidx/work/OneTimeWorkRequest),
as shown in the following example.  

### Kotlin

```kotlin
val uploadWorkRequest: WorkRequest =
   OneTimeWorkRequestBuilder<UploadWorker>()
       .build()
```

### Java

```java
WorkRequest uploadWorkRequest =
   new OneTimeWorkRequest.Builder(UploadWorker.class)
       .build();
```

## Submit the WorkRequest to the system

Finally, you need to submit your `WorkRequest` to `WorkManager` using the
[enqueue()](https://developer.android.com/reference/androidx/work/WorkManager#enqueue(androidx.work.WorkRequest))
method.  

### Kotlin

```kotlin
WorkManager
    .getInstance(myContext)
    .enqueue(uploadWorkRequest)
```

### Java

```java
WorkManager
    .getInstance(myContext)
    .enqueue(uploadWorkRequest);
```

The exact time that the worker is going to be executed depends on the
constraints that are used in your `WorkRequest` and on system optimizations.
WorkManager is designed to give the best behavior under these restrictions.

## Next steps

This getting started guide only scratches the surface. The `WorkRequest` can
also include additional information, such as the constraints under which the
work should run, input to the work, a delay, and backoff policy for retrying
work. In the next section, [Define your work
requests](https://developer.android.com/topic/libraries/architecture/workmanager/how-to/define-work), you'll
learn more about these options in greater detail as well as get an understanding
of how to schedule unique and reoccurring work.

## Additional resources

In addition to guide documentation, there are several blogs, codelabs, and code
samples available to help you get started.

### Samples

- [Sunflower](https://github.com/android/sunflower), a demo app demonstrating best practices with various architecture components, including WorkManager.

### Codelabs

- Working with WorkManager [(Kotlin)](https://codelabs.developers.google.com/codelabs/android-workmanager/#0) and [(Java)](https://codelabs.developers.google.com/codelabs/android-workmanager-java/#0)
- [Advanced WorkManager (Kotlin)](https://codelabs.developers.google.com/codelabs/android-adv-workmanager/#0)

### Blogs

- [Introducing WorkManager](https://medium.com/androiddevelopers/introducing-workmanager-2083bcfc4712)
- [WorkManager Basics](https://medium.com/androiddevelopers/workmanager-basics-beba51e94048)
- [WorkManager and Kotlin](https://medium.com/androiddevelopers/workmanager-meets-kotlin-b9ad02f7405e)
- [WorkManager Periodicity](https://medium.com/androiddevelopers/workmanager-periodicity-ff35185ff006)
- [Customizing WorkManager - Fundamentals](https://medium.com/androiddevelopers/customizing-workmanager-fundamentals-fdaa17c46dd2)
- [Customize WorkManager with Dagger](https://medium.com/androiddevelopers/customizing-workmanager-with-dagger-1029688c0978)