Cómo comenzar a usar WorkManager

Para comenzar a usar WorkManager, primero debes importar la biblioteca a tu proyecto de Android.

Agrega las siguientes dependencias al archivo build.gradle de tu app:

Groovy

dependencies {
    def work_version = "2.9.1"

    // (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

dependencies {
    val work_version = "2.9.1"

    // (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")
}

Una vez que agregues las dependencias y sincronices el proyecto de Gradle, el siguiente paso es definir una tarea para ejecutar.

Cómo definir un trabajo

Los trabajos se definen con la clase Worker. El método doWork() se ejecuta de forma asíncrona en un subproceso en segundo plano proporcionado por WorkManager.

Para crear un trabajo que pueda ejecutar WorkManager, extiende la clase Worker y anula el método doWork(). Por ejemplo, para crear un Worker que suba imágenes, puedes hacer lo siguiente:

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


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();
   }
}

El Result que muestra doWork() le informa al servicio de WorkManager si el trabajo se ejecutó correctamente y, en caso de haber un error, si se debe reintentar o no.

  • Result.success(): el trabajo se completó correctamente.
  • Result.failure(): no se pudo completar el trabajo.
  • Result.retry(): no se pudo completar el trabajo y se debe volver a intentar en otro momento según su política de reintento.

Cómo crear un objeto WorkRequest

Una vez que definas tu trabajo, debes programarlo mediante el servicio WorkManager para que se ejecute. WorkManager ofrece mucha flexibilidad para la programación de tu trabajo. Puedes programarlo para que se ejecute de forma periódica en un intervalo de tiempo o solo una vez.

Independientemente de cómo programes tu trabajo, siempre usarás un objeto WorkRequest. Mientras que un Worker define la unidad de trabajo, una solicitud WorkRequest (y sus subclases) definen cómo y cuándo se debe ejecutar el trabajo. En el caso más simple, puedes usar una solicitud OneTimeWorkRequest, como se muestra en el siguiente ejemplo.

Kotlin


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

Java


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

Cómo enviar el objeto WorkRequest al sistema

Por último, debes enviar tu WorkRequest a WorkManager con el método enqueue().

Kotlin


WorkManager
    .getInstance(myContext)
    .enqueue(uploadWorkRequest)

Java


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

La hora exacta a la que se ejecutará el trabajador depende de las limitaciones que se usen en tu WorkRequest y de las optimizaciones del sistema. WorkManager está diseñado para tener el mejor comportamiento bajo estas restricciones.

Próximos pasos

Esta guía de introducción apenas abarca lo básico. La solicitud WorkRequest también puede incluir información adicional, como las limitaciones bajo las que se debe ejecutar el trabajo, las entradas que se le asignen, un retraso y la política de retirada para reintentar la ejecución de un trabajo. En la próxima sección, Cómo definir tus solicitudes de trabajo, obtendrás información más detallada sobre estas opciones y podrás aprender a programar trabajos únicos y recurrentes.

Recursos adicionales

Además de la documentación de guía, hay varios blogs, codelabs y muestras de código disponibles que te ayudarán a comenzar.

Ejemplos

  • WorkManagerSample, una app de procesamiento de imágenes sencilla
  • Sunflower, una app de demostración que muestra las prácticas recomendadas con varios componentes de arquitectura, incluido WorkManager

Codelabs

Blogs