Androidでワークマネージャを使う

カスタムワーナー

By default, WorkManager configures itself automatically when your app starts. If you require more control of how WorkManager manages and schedules work, you can customise the WorkManager configuration.

def work_version = "2.5.0"
implementation "androidx.work:work-runtime-ktx:$work_version"
androidTestImplementation "androidx.work:work-testing:$work_version"

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

class TodoApplication() : Application(), Configuration.Provider {
    override fun onCreate() {
      super.onCreate()
      // LATER PUT THE PERIODIC WORK REQUEST HERE
    }
    override fun getWorkManagerConfiguration(): Configuration {
 
      return if (BuildConfig.DEBUG) {
         Configuration.Builder().setMinimumLoggingLevel(Log.DEBUG).build()
      } 
      else {
         Configuration.Builder().setMinimumLoggingLevel(Log.ERROR).build()
      }
    }
}

Here, we use Configuration.Provider to extend our TodoApplication, and override the getWorkManagerConfiguration

OneTimeWorkリクエスト

OndemandBackupWorker

override suspend fun doWork(): Result {
    val appContext = applicationContext
    showNotifications("Backing up the data", appContext)
    return try {
       val res = dummyWork()
       val outputData = workDataOf(KEY_ONDEMANDWORKER_RESP to res)
       Result.success(outputData)
    } catch (throwable: Throwable) {
       Timber.e(throwable)
       Result.failure()
    }
}
private suspend fun dummyWork(): String {
     // Faking the network call
     sleep()
     return "Completed successfully!"
}

Here, we create a dummyWork function, (which puts the thread to sleep) and returns string result.

ファイルワーカー

override fun doWork(): Result {
return try {
   val content="Backed up on ${dateFormatter.format(Date())}"
   val outputUri = saveToFile(appContext, content)
   val data=workDataOf(KEY_FILEWORKER_RESP to outputUri.toString())
   Result.success(data)
   
 } catch (throwable: Throwable) {
     Timber.e(throwable)
     Result.failure()
   }
}

Here, we create a file using saveToFile, and put in the current timestamp as text into that file

OnDemandBackupViewModel

internal fun beginBackup() {
   val constraints = Constraints.Builder()
     .setRequiresStorageNotLow(true)
     .setRequiresBatteryNotLow(true)
     .setRequiredNetworkType(NetworkType.CONNECTED)
     .build()
var continuation = workManager.beginUniqueWork(
       ONDEMAND_BACKUP_WORK_NAME,
       ExistingWorkPolicy.KEEP,
    OneTimeWorkRequest.from(OnDemandBackupWorker::class.java)
   )
// BACKUP WORKER
   val backupBuilder = OneTimeWorkRequestBuilder<OnDemandBackupWorker>()
        
  
  backupBuilder.addTag(TAG_BACKUP)
  backupBuilder.setConstraints(constraints)
  continuation = continuation.then(backupBuilder.build())
// SAVE FILE WORKER
  val saveInFile = OneTimeWorkRequest.Builder(FileWorker::class.java)
      .setConstraints(constraints)
      .addTag(TAG_FILE)
      .build()
  continuation = continuation.then(saveInFile)
  continuation.enqueue()
}

internal fun cancelBackup() {
   workManager.cancelUniqueWork(ONDEMAND_BACKUP_WORK_NAME)
}

Since, we need to chain our work requests, hence we use beginUniqueWork

Note: For cancelling a work request, we simply call the cancelUniqueWork with the tag (used for creating the work) 

ワークリクエストの進捗状況の追跡

internal val backupDataInfo: LiveData<List<WorkInfo>> = workManager
        .getWorkInfosByTagLiveData(TAG_BACKUP)

Here, TAG_BACKUP is our tag, specified previously

定期的な要求

Note: PeriodicBackupWorker is the same like FileWorker (only difference is the file content)

val constraints = Constraints.Builder()
    .setRequiresStorageNotLow(true)
    .setRequiresBatteryNotLow(true)
    .setRequiredNetworkType(NetworkType.UNMETERED)
    .build()
val periodicBackup = PeriodicWorkRequestBuilder<PeriodicBackupWorker>(1, TimeUnit.DAYS)
    .addTag(TAG_PERIODIC_BACKUP)
    .setConstraints(constraints)
    .build()
WorkManager.getInstance(this).enqueueUniquePeriodicWork(
     PERIODIC_BACKUP_WORK_NAME,
     ExistingPeriodicWorkPolicy.KEEP,
     periodicBackup
 )

Periodic work has a minimum interval of 15 minutes. Also if your periodic work has constraints, it will not execute until the constraints are met, even if the delay between periods has been met.

The normal lifecycle of a PeriodicWorkRequest is ENQUEUED -> RUNNING -> ENQUEUED

従業員の筆記試験

OndemandBackupWorkerテスト

@RunWith(AndroidJUnit4::class)
class OnDemandBackupWorkerTest {
 private lateinit var context: Context
 private lateinit var executor: Executor
 @Before
 fun setUp() {
     context = ApplicationProvider.getApplicationContext()
     executor = Executors.newSingleThreadExecutor()
 }
 @Test
 fun testOnDemandBackupWorker() {
    val worker = TestListenableWorkerBuilder<OnDemandBackupWorker> (context).build()
    
   runBlocking {
     val result = worker.doWork()
     assertTrue(result is ListenableWorker.Result.Success)
   }
 }
}

定期的なバックアップテスト

// TEST 1
@Test
fun testPeriodicBackUpWorker() {
   val worker = TestWorkerBuilder<PeriodicBackupWorker>(
        context = context,
        executor = executor
    ).build()
   val result = worker.doWork()
   assertTrue(result is ListenableWorker.Result.Success)
}

// TEST 2
@Test
fun testIfPeriodicBackupRunning() {
 WorkManagerTestInitHelper.initializeTestWorkManager(context)
 
 val testDriver = WorkManagerTestInitHelper.getTestDriver(context)
 val workManager = WorkManager.getInstance(context)
 val constraints = Constraints.Builder()
     .setRequiresStorageNotLow(true)
     .setRequiresBatteryNotLow(true)
     .setRequiredNetworkType(NetworkType.UNMETERED)
     .build()
 val request =
     PeriodicWorkRequestBuilder<PeriodicBackupWorker> (repeatInterval=24, TimeUnit.HOURS)
         .setConstraints(constraints)
         .build()
 workManager.enqueue(request).result.get()
 with(testDriver) {
      this?.setPeriodDelayMet(request.id)
      this?.setAllConstraintsMet(request.id)
 }
 val workInfo = workManager.getWorkInfoById(request.id).get()
 assertEquals(workInfo.state, WorkInfo.State.ENQUEUED)
}