BaseWorker extends CoroutineWorker

app/build.gradle.kts

@@ -193,6 +193,7 @@ dependencies {
     implementation("com.google.apis:google-api-services-drive:v3-rev20200609-1.30.9")
     implementation("com.google.auth:google-auth-library-oauth2-http:0.20.0")
     implementation("androidx.work:work-runtime:${Versions.work}")
+    implementation("androidx.work:work-runtime-ktx:${Versions.work}")
     implementation("com.mapbox.mapboxsdk:mapbox-android-core:3.0.0")
     implementation("com.mapbox.mapboxsdk:mapbox-sdk-services:5.3.0")
     implementation("com.etesync:journalmanager:1.1.0")

app/licenses.yml

@@ -756,3 +756,9 @@
   license: The Apache Software License, Version 2.0
   licenseUrl: http://www.apache.org/licenses/LICENSE-2.0.txt
   url: https://developer.android.com/jetpack/androidx
+- artifact: androidx.work:work-runtime-ktx:+
+  name: work-runtime-ktx
+  copyrightHolder: Android Open Source Project
+  license: The Apache Software License, Version 2.0
+  licenseUrl: http://www.apache.org/licenses/LICENSE-2.0.txt
+  url: https://developer.android.com/topic/libraries/architecture/index.html

app/src/main/assets/licenses.json

@@ -1800,6 +1800,20 @@
       "normalizedLicense": "apache2",
       "url": "https://developer.android.com/jetpack/androidx",
       "libraryName": "lifecycle-livedata-core-ktx"
+    },
+    {
+      "artifactId": {
+        "name": "work-runtime-ktx",
+        "group": "androidx.work",
+        "version": "+"
+      },
+      "copyrightHolder": "Android Open Source Project",
+      "copyrightStatement": "Copyright © Android Open Source Project. All rights reserved.",
+      "license": "The Apache Software License, Version 2.0",
+      "licenseUrl": "http://www.apache.org/licenses/LICENSE-2.0.txt",
+      "normalizedLicense": "apache2",
+      "url": "https://developer.android.com/topic/libraries/architecture/index.html",
+      "libraryName": "work-runtime-ktx"
     }
   ]
 }

app/src/main/java/org/tasks/injection/BaseWorker.kt

@@ -1,17 +1,17 @@
 package org.tasks.injection
 
 import android.content.Context
-import androidx.work.Worker
+import androidx.work.CoroutineWorker
 import androidx.work.WorkerParameters
 import org.tasks.analytics.Firebase
 import timber.log.Timber
 
-abstract class InjectingWorker(
+abstract class BaseWorker(
         internal val context: Context,
         workerParams: WorkerParameters,
-        internal val firebase: Firebase) : Worker(context, workerParams) {
+        internal val firebase: Firebase) : CoroutineWorker(context, workerParams) {
 
-    override fun doWork(): Result {
+    override suspend fun doWork(): Result {
         Timber.d("%s.doWork()", javaClass.simpleName)
         return try {
             run()
@@ -21,5 +21,5 @@ abstract class InjectingWorker(
         }
     }
 
-    protected abstract fun run(): Result
+    protected abstract suspend fun run(): Result
 }

app/src/main/java/org/tasks/jobs/AfterSaveWork.kt

@@ -9,7 +9,6 @@ import androidx.hilt.work.WorkerInject
 import androidx.work.Data
 import androidx.work.WorkerParameters
 import com.todoroo.astrid.dao.TaskDao
-import com.todoroo.astrid.dao.TaskDaoBlocking
 import com.todoroo.astrid.data.SyncFlags
 import com.todoroo.astrid.data.Task
 import com.todoroo.astrid.reminders.ReminderService
@@ -19,8 +18,8 @@ import org.tasks.LocalBroadcastManager
 import org.tasks.R
 import org.tasks.Strings.isNullOrEmpty
 import org.tasks.analytics.Firebase
-import org.tasks.data.CaldavDaoBlocking
+import org.tasks.data.CaldavDao
-import org.tasks.injection.InjectingWorker
+import org.tasks.injection.BaseWorker
 import org.tasks.location.GeofenceApi
 import org.tasks.notifications.NotificationManager
 import org.tasks.scheduling.RefreshScheduler
@@ -38,15 +37,15 @@ class AfterSaveWork @WorkerInject constructor(
         private val reminderService: ReminderService,
         private val refreshScheduler: RefreshScheduler,
         private val localBroadcastManager: LocalBroadcastManager,
-        private val taskDao: TaskDaoBlocking,
+        private val taskDao: TaskDao,
         private val syncAdapters: SyncAdapters,
         private val workManager: WorkManager,
-        private val caldavDao: CaldavDaoBlocking) : InjectingWorker(context, workerParams, firebase) {
+        private val caldavDao: CaldavDao) : BaseWorker(context, workerParams, firebase) {
 
-    override fun run(): Result {
+    override suspend fun run(): Result {
         val data = inputData
         val taskId = data.getLong(EXTRA_ID, -1)
-        val task = taskDao.fetchBlocking(taskId)
+        val task = taskDao.fetch(taskId)
         if (task == null) {
             Timber.e("Missing saved task")
             return Result.failure()

app/src/main/java/org/tasks/jobs/BackupWork.kt

@@ -24,7 +24,7 @@ class BackupWork @WorkerInject constructor(
         private val preferences: Preferences,
         private val workManager: WorkManager) : RepeatingWorker(context, workerParams, firebase) {
     
-    override fun run(): Result {
+    override suspend fun run(): Result {
         preferences.setLong(R.string.p_last_backup, DateUtilities.now())
         startBackup(context)
         return Result.success()

app/src/main/java/org/tasks/jobs/CleanupWork.kt

@@ -10,7 +10,7 @@ import com.todoroo.astrid.timers.TimerPlugin
 import org.tasks.analytics.Firebase
 import org.tasks.data.*
 import org.tasks.files.FileHelper
-import org.tasks.injection.InjectingWorker
+import org.tasks.injection.BaseWorker
 import org.tasks.location.GeofenceApi
 import org.tasks.notifications.NotificationManager
 import timber.log.Timber
@@ -24,12 +24,12 @@ class CleanupWork @WorkerInject constructor(
         private val timerPlugin: TimerPlugin,
         private val reminderService: ReminderService,
         private val alarmService: AlarmService,
-        private val taskAttachmentDao: TaskAttachmentDaoBlocking,
+        private val taskAttachmentDao: TaskAttachmentDao,
-        private val userActivityDao: UserActivityDaoBlocking,
+        private val userActivityDao: UserActivityDao,
-        private val locationDao: LocationDaoBlocking,
+        private val locationDao: LocationDao,
-        private val deletionDao: DeletionDaoBlocking) : InjectingWorker(context, workerParams, firebase) {
+        private val deletionDao: DeletionDao) : BaseWorker(context, workerParams, firebase) {
 
-    public override fun run(): Result {
+    override suspend fun run(): Result {
         val tasks = inputData.getLongArray(EXTRA_TASK_IDS)
         if (tasks == null) {
             Timber.e("No task ids provided")

app/src/main/java/org/tasks/jobs/DriveUploader.kt

@@ -12,7 +12,7 @@ import org.tasks.R
 import org.tasks.Strings.isNullOrEmpty
 import org.tasks.analytics.Firebase
 import org.tasks.drive.DriveInvoker
-import org.tasks.injection.InjectingWorker
+import org.tasks.injection.BaseWorker
 import org.tasks.preferences.Preferences
 import timber.log.Timber
 import java.io.IOException
@@ -27,9 +27,9 @@ class DriveUploader @WorkerInject constructor(
         @Assisted workerParams: WorkerParameters,
         firebase: Firebase,
         private val drive: DriveInvoker,
-        private val preferences: Preferences) : InjectingWorker(context, workerParams, firebase) {
+        private val preferences: Preferences) : BaseWorker(context, workerParams, firebase) {
 
-    override fun run(): Result {
+    override suspend fun run(): Result {
         val inputData = inputData
         val uri = Uri.parse(inputData.getString(EXTRA_URI))
         return try {

app/src/main/java/org/tasks/jobs/MidnightRefreshWork.kt

@@ -14,7 +14,7 @@ class MidnightRefreshWork @WorkerInject constructor(
         private val workManager: WorkManager,
         private val localBroadcastManager: LocalBroadcastManager) : RepeatingWorker(context, workerParams, firebase) {
 
-    override fun run(): Result {
+    override suspend fun run(): Result {
         localBroadcastManager.broadcastRefresh()
         return Result.success()
     }

app/src/main/java/org/tasks/jobs/RefreshWork.kt

@@ -15,7 +15,7 @@ class RefreshWork @WorkerInject constructor(
         private val refreshScheduler: RefreshScheduler,
         private val localBroadcastManager: LocalBroadcastManager) : RepeatingWorker(context, workerParams, firebase) {
 
-    public override fun run(): Result {
+    override suspend fun run(): Result {
         localBroadcastManager.broadcastRefresh()
         return Result.success()
     }

app/src/main/java/org/tasks/jobs/RemoteConfigWork.kt

@@ -5,14 +5,14 @@ import androidx.hilt.Assisted
 import androidx.hilt.work.WorkerInject
 import androidx.work.WorkerParameters
 import org.tasks.analytics.Firebase
-import org.tasks.injection.InjectingWorker
+import org.tasks.injection.BaseWorker
 
 class RemoteConfigWork @WorkerInject constructor(
         @Assisted context: Context,
         @Assisted workerParams: WorkerParameters,
-        firebase: Firebase) : InjectingWorker(context, workerParams, firebase) {
+        firebase: Firebase) : BaseWorker(context, workerParams, firebase) {
 
-    override fun run(): Result {
+    override suspend fun run(): Result {
         firebase.updateRemoteConfig()
         return Result.success()
     }

app/src/main/java/org/tasks/jobs/RepeatingWorker.kt

@@ -3,14 +3,14 @@ package org.tasks.jobs
 import android.content.Context
 import androidx.work.WorkerParameters
 import org.tasks.analytics.Firebase
-import org.tasks.injection.InjectingWorker
+import org.tasks.injection.BaseWorker
 
 abstract class RepeatingWorker internal constructor(
         context: Context,
         workerParams: WorkerParameters,
-        firebase: Firebase) : InjectingWorker(context, workerParams, firebase) {
+        firebase: Firebase) : BaseWorker(context, workerParams, firebase) {
 
-    override fun doWork(): Result {
+    override suspend fun doWork(): Result {
         val result = super.doWork()
         scheduleNext()
         return result

app/src/main/java/org/tasks/jobs/ReverseGeocodeWork.kt

@@ -6,8 +6,8 @@ import androidx.hilt.work.WorkerInject
 import androidx.work.WorkerParameters
 import org.tasks.LocalBroadcastManager
 import org.tasks.analytics.Firebase
-import org.tasks.data.LocationDaoBlocking
+import org.tasks.data.LocationDao
-import org.tasks.injection.InjectingWorker
+import org.tasks.injection.BaseWorker
 import org.tasks.location.Geocoder
 import timber.log.Timber
 import java.io.IOException
@@ -18,13 +18,13 @@ class ReverseGeocodeWork @WorkerInject constructor(
         firebase: Firebase,
         private val localBroadcastManager: LocalBroadcastManager,
         private val geocoder: Geocoder,
-        private val locationDao: LocationDaoBlocking) : InjectingWorker(context, workerParams, firebase) {
+        private val locationDao: LocationDao) : BaseWorker(context, workerParams, firebase) {
 
     companion object {
         const val PLACE_ID = "place_id"
     }
 
-    public override fun run(): Result {
+    override suspend fun run(): Result {
         val id = inputData.getLong(PLACE_ID, 0)
         if (id == 0L) {
             Timber.e("Missing id")

app/src/main/java/org/tasks/jobs/SyncWork.kt

@@ -7,11 +7,11 @@ import androidx.work.WorkerParameters
 import org.tasks.LocalBroadcastManager
 import org.tasks.analytics.Firebase
 import org.tasks.caldav.CaldavSynchronizer
-import org.tasks.data.CaldavDaoBlocking
+import org.tasks.data.CaldavDao
-import org.tasks.data.GoogleTaskListDaoBlocking
+import org.tasks.data.GoogleTaskListDao
 import org.tasks.etesync.EteSynchronizer
 import org.tasks.gtasks.GoogleTaskSynchronizer
-import org.tasks.injection.InjectingWorker
+import org.tasks.injection.BaseWorker
 import org.tasks.preferences.Preferences
 import org.tasks.sync.SyncAdapters
 import java.util.concurrent.Executors
@@ -26,11 +26,11 @@ class SyncWork @WorkerInject constructor(
         private val googleTaskSynchronizer: GoogleTaskSynchronizer,
         private val localBroadcastManager: LocalBroadcastManager,
         private val preferences: Preferences,
-        private val caldavDao: CaldavDaoBlocking,
+        private val caldavDao: CaldavDao,
-        private val googleTaskListDao: GoogleTaskListDaoBlocking,
+        private val googleTaskListDao: GoogleTaskListDao,
-        private val syncAdapters: SyncAdapters) : InjectingWorker(context, workerParams, firebase) {
+        private val syncAdapters: SyncAdapters) : BaseWorker(context, workerParams, firebase) {
     
-    public override fun run(): Result {
+    override suspend fun run(): Result {
         if (!syncAdapters.isSyncEnabled) {
             return Result.success()
         }
@@ -53,7 +53,7 @@ class SyncWork @WorkerInject constructor(
     }
 
     @Throws(InterruptedException::class)
-    private fun sync() {
+    private suspend fun sync() {
         val numThreads = Runtime.getRuntime().availableProcessors()
         val executor = Executors.newFixedThreadPool(numThreads)
         for (account in caldavDao.getAccounts()) {