update worker

app/src/main/AndroidManifest.xml

@@ -44,10 +44,10 @@
             android:name="preloaded_fonts"
             android:resource="@array/preloaded_fonts" />
         <!--
-             The API key for Google Maps-based APIs is defined as enqueueUpdateCurrentWeatherWorkRequestImmediately string resource.
+             The API key for Google Maps-based APIs is defined as enqueuePeriodic string resource.
              (See the file "res/values/google_maps_api.xml").
              Note that the API key is linked to the encryption key used to sign the APK.
-             You need enqueueUpdateCurrentWeatherWorkRequestImmediately different API key for each encryption key, including the release key that is used to
+             You need enqueuePeriodic different API key for each encryption key, including the release key that is used to
              sign the APK for publishing.
              You can define the keys for the debug and release targets in src/debug/ and src/release/. 
         -->

app/src/main/java/com/hoc/weatherapp/App.kt

@@ -11,6 +11,7 @@ import com.hoc.weatherapp.koin.presenterModule
 import com.hoc.weatherapp.koin.retrofitModule
 import com.hoc.weatherapp.koin.sharePrefUtilModule
 import com.hoc.weatherapp.utils.debug
+import com.hoc.weatherapp.utils.toast
 import com.hoc.weatherapp.worker.UpdateCurrentWeatherWorker
 import com.hoc.weatherapp.worker.UpdateDailyWeatherWorker
 import com.jakewharton.threetenabp.AndroidThreeTen
@@ -39,16 +40,21 @@ class App : Application() {
     createNotificationChannel()
 
     WorkManager.getInstance().run {
-      getWorkInfosByTagLiveData(UpdateDailyWeatherWorker.TAG)
+      getWorkInfosForUniqueWorkLiveData(UpdateDailyWeatherWorker.UNIQUE_WORK_NAME)
         .observeForever {
-          debug("UpdateDailyWeatherWorker", "UpdateDailyWeatherWorker")
-          it.forEach { debug("info=$it", "UpdateDailyWeatherWorker") }
+          it.forEach {
+            debug("info=$it", "UpdateDailyWeatherWorker")
+            it.takeIf { it.state.isFinished }?.outputData?.getString("RESULT")?.let { toast(it) }
+          }
         }
 
-      getWorkInfosByTagLiveData(UpdateCurrentWeatherWorker.TAG)
+
+      getWorkInfosForUniqueWorkLiveData(UpdateCurrentWeatherWorker.UNIQUE_WORK_NAME)
         .observeForever {
-          debug("UpdateCurrentWeatherWorker", "UpdateCurrentWeatherWorker")
-          it.forEach { debug("info=$it", "UpdateCurrentWeatherWorker") }
+          it.forEach {
+            debug("info=$it", "UpdateCurrentWeatherWorker")
+            it.takeIf { it.state.isFinished }?.outputData?.getString("RESULT")?.let { toast(it) }
+          }
         }
     }
   }

app/src/main/java/com/hoc/weatherapp/ui/cities/CitiesPresenter.kt

@@ -81,7 +81,7 @@ class CitiesPresenter(
         .doOnSuccess { (cityAndCurrentWeather) ->
           if (settingPreferences.autoUpdatePreference.value) {
             WorkerUtil.enqueueUpdateCurrentWeatherWorkRequest()
-            WorkerUtil.enqueueUpdateDailyWeatherWorkWorkRequest()
+            WorkerUtil.enqueueUpdateDailyWeatherWorkRequest()
           }
           androidApplication.showNotificationIfEnabled(cityAndCurrentWeather, settingPreferences)
         }
@@ -135,7 +135,7 @@ class CitiesPresenter(
 
               if (settingPreferences.autoUpdatePreference.value) {
                 WorkerUtil.enqueueUpdateCurrentWeatherWorkRequest()
-                WorkerUtil.enqueueUpdateDailyWeatherWorkWorkRequest()
+                WorkerUtil.enqueueUpdateDailyWeatherWorkRequest()
               }
 
               androidApplication.showNotificationIfEnabled(

app/src/main/java/com/hoc/weatherapp/ui/main/fivedayforecast/DailyWeatherPresenter.kt

@@ -50,7 +50,7 @@ class DailyWeatherPresenter(
             .refreshFiveDayForecastOfSelectedCity()
             .doOnSuccess {
               if (settingPreferences.autoUpdatePreference.value) {
-                WorkerUtil.enqueueUpdateDailyWeatherWorkWorkRequest()
+                WorkerUtil.enqueueUpdateDailyWeatherWorkRequest()
               }
             }
             .doOnError {

app/src/main/java/com/hoc/weatherapp/ui/setting/SettingsActivity.kt

@@ -16,7 +16,7 @@ import com.hoc.weatherapp.utils.*
 import com.hoc.weatherapp.worker.WorkerUtil.cancelUpdateCurrentWeatherWorkRequest
 import com.hoc.weatherapp.worker.WorkerUtil.cancelUpdateDailyWeatherWorkWorkRequest
 import com.hoc.weatherapp.worker.WorkerUtil.enqueueUpdateCurrentWeatherWorkRequest
-import com.hoc.weatherapp.worker.WorkerUtil.enqueueUpdateDailyWeatherWorkWorkRequest
+import com.hoc.weatherapp.worker.WorkerUtil.enqueueUpdateDailyWeatherWorkRequest
 import io.reactivex.Observable
 import io.reactivex.android.schedulers.AndroidSchedulers
 import io.reactivex.disposables.CompositeDisposable
@@ -161,7 +161,7 @@ class SettingsActivity : AppCompatActivity() {
         key == getString(R.string.key_auto_update) && newValue is Boolean -> {
           settingPreferences.autoUpdatePreference.save(newValue)
           if (newValue) {
-            enqueueUpdateDailyWeatherWorkWorkRequest()
+            enqueueUpdateDailyWeatherWorkRequest()
             enqueueUpdateCurrentWeatherWorkRequest()
           } else {
             cancelUpdateCurrentWeatherWorkRequest()

app/src/main/java/com/hoc/weatherapp/worker/UpdateCurrentWeatherWorker.kt

@@ -1,36 +1,44 @@
 package com.hoc.weatherapp.worker
 
 import android.content.Context
-import androidx.work.Worker
+import androidx.work.RxWorker
 import androidx.work.WorkerParameters
+import androidx.work.workDataOf
 import com.hoc.weatherapp.data.CurrentWeatherRepository
 import com.hoc.weatherapp.data.NoSelectedCityException
 import com.hoc.weatherapp.data.local.SettingPreferences
 import com.hoc.weatherapp.utils.WEATHER_NOTIFICATION_ID
 import com.hoc.weatherapp.utils.cancelNotificationById
+import com.hoc.weatherapp.utils.debug
 import com.hoc.weatherapp.utils.showNotificationIfEnabled
+import io.reactivex.Single
 import org.koin.standalone.KoinComponent
 import org.koin.standalone.inject
 
 class UpdateCurrentWeatherWorker(context: Context, workerParams: WorkerParameters) :
-  Worker(context, workerParams), KoinComponent {
+  RxWorker(context, workerParams), KoinComponent {
+  private val tag = "__current_worker__"
   private val currentWeatherRepository by inject<CurrentWeatherRepository>()
   private val settingPreferences by inject<SettingPreferences>()
 
-  override fun doWork(): Result {
-    return runCatching {
-      currentWeatherRepository
-        .refreshCurrentWeatherOfSelectedCity()
-        .blockingGet()
+  override fun createWork(): Single<Result> {
+    return currentWeatherRepository
+      .refreshCurrentWeatherOfSelectedCity()
+      .doOnSuccess {
+        debug("[SUCCESS] doWork $it", tag)
 
-    }.onSuccess {
-      applicationContext.showNotificationIfEnabled(it, settingPreferences)
-    }.onFailure {
-      if (it is NoSelectedCityException) {
-        applicationContext.cancelNotificationById(WEATHER_NOTIFICATION_ID)
-        WorkerUtil.cancelUpdateCurrentWeatherWorkRequest()
+        applicationContext.showNotificationIfEnabled(it, settingPreferences)
       }
-    }.fold({ Result.success() }, { Result.failure() })
+      .doOnError {
+        debug("[FAILURE] doWork $it", tag)
+
+        if (it is NoSelectedCityException) {
+          applicationContext.cancelNotificationById(WEATHER_NOTIFICATION_ID)
+          WorkerUtil.cancelUpdateCurrentWeatherWorkRequest()
+        }
+      }
+      .map { Result.success(workDataOf("RESULT" to "Update current success")) }
+      .onErrorReturn { Result.failure(workDataOf("RESULT" to "Update current failure: ${it.message}")) }
   }
 
   companion object {

app/src/main/java/com/hoc/weatherapp/worker/UpdateDailyWeatherWorker.kt

@@ -1,30 +1,38 @@
 package com.hoc.weatherapp.worker
 
 import android.content.Context
-import androidx.work.Worker
+import androidx.work.RxWorker
 import androidx.work.WorkerParameters
+import androidx.work.workDataOf
 import com.hoc.weatherapp.data.FiveDayForecastRepository
 import com.hoc.weatherapp.data.NoSelectedCityException
 import com.hoc.weatherapp.utils.WEATHER_NOTIFICATION_ID
 import com.hoc.weatherapp.utils.cancelNotificationById
+import com.hoc.weatherapp.utils.debug
+import io.reactivex.Single
 import org.koin.standalone.KoinComponent
 import org.koin.standalone.inject
 
 class UpdateDailyWeatherWorker(context: Context, workerParams: WorkerParameters) :
-  Worker(context, workerParams), KoinComponent {
+  RxWorker(context, workerParams), KoinComponent {
+  private val tag = "__daily_worker__"
   private val fiveDayForecastRepository by inject<FiveDayForecastRepository>()
 
-  override fun doWork(): Result {
-    return runCatching {
-      fiveDayForecastRepository
-        .refreshFiveDayForecastOfSelectedCity()
-        .blockingGet()
-    }.onFailure {
-      if (it is NoSelectedCityException) {
-        applicationContext.cancelNotificationById(WEATHER_NOTIFICATION_ID)
-        WorkerUtil.cancelUpdateDailyWeatherWorkWorkRequest()
+  override fun createWork(): Single<Result> {
+    return fiveDayForecastRepository
+      .refreshFiveDayForecastOfSelectedCity()
+      .doOnSuccess {
+        debug("[SUCCESS] doWork $it", tag)
       }
-    }.fold({ Result.success() }, { Result.failure() })
+      .doOnError {
+        if (it is NoSelectedCityException) {
+          applicationContext.cancelNotificationById(WEATHER_NOTIFICATION_ID)
+          WorkerUtil.cancelUpdateDailyWeatherWorkWorkRequest()
+        }
+        debug("[FAILURE] doWork $it", tag)
+      }
+      .map { Result.success(workDataOf("RESULT" to "Update daily success")) }
+      .onErrorReturn { Result.failure(workDataOf("RESULT" to "Update daily failure: ${it.message}")) }
   }
 
   companion object {

app/src/main/java/com/hoc/weatherapp/worker/WorkerUtil.kt

@@ -1,16 +1,52 @@
 package com.hoc.weatherapp.worker
 
-import androidx.work.*
+import android.content.Context
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ListenableWorker
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.Operation
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import androidx.work.workDataOf
+import com.hoc.weatherapp.utils.debug
 import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 
 object WorkerUtil {
-  private val backgroundExecutor by lazy { Executors.newSingleThreadExecutor() }
+  private const val tag = "__worker__"
+  private val backgroundExecutor = Executors.newSingleThreadExecutor()
 
-  private fun enqueuePeriodicWorkRequestWithInitialDelay(tag: String): Operation {
+  /**
+   * Actual
+   */
+  private inline fun <reified T : ListenableWorker> enqueuePeriodic(
+    tag: String,
+    uniqueName: String
+  ): Operation {
+    val request = PeriodicWorkRequestBuilder<T>(
+      repeatInterval = 15,
+      repeatIntervalTimeUnit = TimeUnit.MINUTES
+    ).addTag(tag).keepResultsForAtLeast(30, TimeUnit.MINUTES).build()
+
+    return WorkManager
+      .getInstance()
+      .enqueueUniquePeriodicWork(
+        uniqueName,
+        ExistingPeriodicWorkPolicy.REPLACE,
+        request
+      )
+  }
+
+  /**
+   * Enqueue initial delay one time work request, will trigger periodic work request
+   */
+  private fun enqueue(tag: String): Operation {
     val workRequest = OneTimeWorkRequestBuilder<InitialDelayEnqueueWorker>()
       .setInitialDelay(15, TimeUnit.MINUTES)
       .setInputData(workDataOf("TAG" to tag))
+      .keepResultsForAtLeast(30, TimeUnit.MINUTES)
       .addTag(tag)
       .build()
 
@@ -19,55 +55,70 @@ object WorkerUtil {
       .enqueue(workRequest)
   }
 
-  private fun cancelAllWorkByTag(tag: String): Operation = WorkManager
-    .getInstance()
-    .cancelAllWorkByTag(tag)
-
-  internal fun enqueueUpdateCurrentWeatherWorkRequestImmediately(): Operation {
-    val updateCurrentWeather = PeriodicWorkRequestBuilder<UpdateCurrentWeatherWorker>(
-      repeatInterval = 15,
-      repeatIntervalTimeUnit = TimeUnit.MINUTES
-    ).addTag(UpdateCurrentWeatherWorker.TAG).build()
-
+  private fun cancelAllWorkByTag(tag: String): Operation {
     return WorkManager
       .getInstance()
-      .enqueueUniquePeriodicWork(
-        UpdateCurrentWeatherWorker.UNIQUE_WORK_NAME,
-        ExistingPeriodicWorkPolicy.REPLACE,
-        updateCurrentWeather
-      )
+      .cancelAllWorkByTag(tag)
   }
 
-  internal fun enqueueUpdateDailyWeatherWorkRequestImmediately(): Operation {
-    val updateDailyWeathers = PeriodicWorkRequestBuilder<UpdateDailyWeatherWorker>(
-      repeatInterval = 15,
-      repeatIntervalTimeUnit = TimeUnit.MINUTES
-    ).addTag(UpdateDailyWeatherWorker.TAG).build()
-
-    return WorkManager
-      .getInstance()
-      .enqueueUniquePeriodicWork(
-        UpdateDailyWeatherWorker.UNIQUE_WORK_NAME,
-        ExistingPeriodicWorkPolicy.REPLACE,
-        updateDailyWeathers
-      )
+  private class InitialDelayEnqueueWorker(context: Context, workerParams: WorkerParameters) :
+    Worker(context, workerParams) {
+    override fun doWork(): Result {
+      return when (inputData.getString("TAG")) {
+        UpdateDailyWeatherWorker.TAG -> {
+          Result
+            .success()
+            .also {
+              WorkerUtil.enqueuePeriodic<UpdateCurrentWeatherWorker>(
+                UpdateCurrentWeatherWorker.TAG,
+                UpdateCurrentWeatherWorker.UNIQUE_WORK_NAME
+              ).result.get()
+              debug("[SUCCESS] enqueuePeriodic current", tag)
+            }
+        }
+        UpdateCurrentWeatherWorker.TAG -> {
+          Result
+            .success()
+            .also {
+              WorkerUtil.enqueuePeriodic<UpdateDailyWeatherWorker>(
+                UpdateDailyWeatherWorker.TAG,
+                UpdateDailyWeatherWorker.UNIQUE_WORK_NAME
+              ).result.get()
+              debug("[SUCCESS] enqueuePeriodic daily", tag)
+            }
+        }
+        else -> Result.failure()
+      }
+    }
   }
 
+  /**
+   *
+   */
+
   @JvmStatic
   fun enqueueUpdateCurrentWeatherWorkRequest() {
     cancelUpdateCurrentWeatherWorkRequest()
       .result
       .addListener(Runnable {
-        enqueuePeriodicWorkRequestWithInitialDelay(UpdateCurrentWeatherWorker.TAG)
+        enqueue(UpdateCurrentWeatherWorker.TAG)
+          .result
+          .addListener(Runnable {
+            debug("[SUCCESS] enqueue current", tag)
+          }, backgroundExecutor)
       }, backgroundExecutor)
   }
 
   @JvmStatic
-  fun enqueueUpdateDailyWeatherWorkWorkRequest() {
+  fun enqueueUpdateDailyWeatherWorkRequest() {
     cancelUpdateDailyWeatherWorkWorkRequest()
       .result
       .addListener(Runnable {
-        enqueuePeriodicWorkRequestWithInitialDelay(UpdateDailyWeatherWorker.TAG)
+        enqueue(UpdateDailyWeatherWorker.TAG)
+          .result
+          .addListener(Runnable {
+            debug("[SUCCESS] enqueue daily", tag)
+          }, backgroundExecutor)
       }, backgroundExecutor)
   }
 

app/src/release/res/values/google_maps_api.xml

@@ -1,13 +1,13 @@
 <resources>
     <!--
-    TODO: Before you release your application, you need enqueueUpdateCurrentWeatherWorkRequestImmediately Google Maps API key.
+    TODO: Before you release your application, you need enqueuePeriodic Google Maps API key.
 
     To do this, you can either add your release key credentials to your existing
-    key, or create enqueueUpdateCurrentWeatherWorkRequestImmediately new key.
+    key, or create enqueuePeriodic new key.
 
     Note that this file specifies the API key for the release build target.
-    If you have previously set up enqueueUpdateCurrentWeatherWorkRequestImmediately key for the debug target with the debug signing certificate,
-    you will also need to set up enqueueUpdateCurrentWeatherWorkRequestImmediately key for your release certificate.
+    If you have previously set up enqueuePeriodic key for the debug target with the debug signing certificate,
+    you will also need to set up enqueuePeriodic key for your release certificate.
 
     Follow the directions here: