class MyWorker(context: Context, params: WorkerParameters) : Worker { -----------------------------------
   override fun doWork(): Result {
       try {
   //Ваш код
       } catch (ex: Exception) {
          return Result.failure(); //или Result.retry()
       }
       return Result.success()
   }
}

val  myWorkRequest = OneTimeWorkRequestBuilder<MyWorker>().build()

val  myWorkRequest = PeriodicWorkRequestBuilder<MyWorker>(30, TimeUnit.MINUTES, 25, TimeUnit.MINUTES).build()

val myWorkRequest = OneTimeWorkRequestBuilder<MyWork>()
       .addTag(“tag”)
       .setInitialDelay(10, TimeUnit.SECONDS)
       .build()

WorkManager.getInstance(context).enqueue(myWorkRequest)

val constraints = Constraints.Builder()
       .setRequiresCharging(true)
       .setRequiresBatteryNotLow(true)
       .setRequiredNetworkType(NetworkType.CONNECTED)
       .setRequiresDeviceIdle(true)
       .setRequiresStorageNotLow(true)
       .build()

//Параллельный запуск 3 задач
WorkManager.getInstance(context)
       .enqueue(myWorkRequest1, myWorkRequest2, myWorkRequest3)
//Последовательный запуск 3х задач
WorkManager.getInstance(context)
       .beginWith(myWorkRequest1)
       .then(myWorkRequest2)
       .then(myWorkRequest3)
       .enqueue()

//Последовательный и параллельный запуск 5 задач
WorkManager.getInstance(context)
       .beginWith(myWorkRequest1, myWorkRequest2)
       .then(myWorkRequest3, myWorkRequest4)
       .then(myWorkRequest5)
       .enqueue()

//Первая последовательная цепочка
val chain12 = WorkManager.getInstance(context)
       .beginWith(myWorkRequest1)
       .then(myWorkRequest2);
//Вторая последовательная цепочка
val chain34 = WorkManager.getInstance(context)
       .beginWith(myWorkRequest3)
       .then(myWorkRequest4);
//Параллельный запуск 2 последовательных цепочек, затем 5 задача
WorkContinuation.combine(chain12, chain34)
       .then(myWorkRequest5)
       .enqueue();

WorkManager.getInstance(context)
       .beginUniqueWork("work123", ExistingWorkPolicy.REPLACE, myWorkRequest1)
       .then(myWorkRequest3)
       .then(myWorkRequest5)
       .enqueue();

WorkManager.getInstance(context)
   .getWorkInfoIdLiveData(myWorkRequest.id)
   .observe(this, {
           Log.d(TAG, "onChanged: " + it.state);
})

val myData = Data.Builder()
       .putString("keyA", "value1")
       .putInt("keyB", 1)
       .build()
val myWorkRequest1 = new OneTimeWorkRequestBuilder<MyWorker>()
       .setInputData(myData)
       .build()

val valueA = getInputData().getString("keyA", "")
val valueB = getInputData().getInt("keyB", 0)

WorkManager.getInstance(context)
       .beginWith(myWorkRequest1, myWorkRequest2)
       .then(myWorkRequest3)
       .enqueue()
//Данные из 1 задачи
val output = Data.Builder()
       .putString("keyA", "value1")
       .putInt("keyB", 1)
       .build()
Result.success(output)
//Данные из 2 задачи
val output = Data.Builder()
       .putString("keyA", "value2")
       .putInt("keyB", 2)
       .build()
Result.success(output)

val myWorkRequest3 = new OneTimeWorkRequestBuilder<MyWorker>()
       .setInputMerger(ArrayCreatingInputMerger.class)
       .build()
//Получаем данные:
val valueA = getInputData().getStringArray("keyA")
val valueB = getInputData().getIntArray("keyB")
val valueC = getInputData().getStringArray("keyC")
val valueD = getInputData().getStringArray("keyD")

<provider android:authorities=”${applicationId}.workmanager-init”
android:name=”androidx.work.impl.WorkManagerInitializer”
tools.node=”remove” />

class TestProjectApplication : Application(), Configuration.Provider {
   override fun getWorkManagerConfiguration(): Configuration {
       return Configuration.Builder()
           .setExecutor(Executors.newFixedThreadPool(5))
           .setMinimumLoggingLevel(Log.DEBUG)
           .build()
   }
}

androidTestImplementation "androidx.work:work-testing:$work_version"

@Test
fun testAdditionWorker() {
   // создаем входные данные для теста
   val inputData = workDataOf("first" to 1, "second" to 2)
  // создаем объект Worker’a
   val worker = TestListenableWorkerBuilder<MyWorker>(context, inputData).build()
   // Получаем результат
   val result = worker.doWork()
   // Проверяем, что работа завершилась успешно и выдала нужный результат
   assertTrue(result is Success)
   assertEquals((result as Success).outputData.getInt("result", 0), 4)
}

WorkManagerTestInitHelper.initializeTestWorkManager(context)
val testDriver = WorkManagerTestInitHelper.getTestDriver(context)!!
val workManager = WorkManager.getInstance(context)
val constraints = Constraints.Builder()
   .setRequiredNetworkType(NetworkType.UNMETERED)
   .setRequiresCharging(true)
   .build()
val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
   .setConstraints(constraints)
   .build()
// синхронно в рамках тестовой среды получаем результат выполнения
workManager.enqueue(workRequest).result.get()
// задаем необходимые условия запуска работы
testDriver.setAllConstraintsMet(workRequest.id)
// получаем статус работы
val workInfo = workManager.getWorkInfoById(workRequest.id).get()
assertEquals(workInfo.state, WorkInfo.State.SUCCEEDED)