fix the worker not running periodically

johnnzhou · johnnzhou · commit 6dee7ff65e39 · 2023-04-09T22:52:47.000-07:00
diff --git a/app/build.gradle b/app/build.gradle
@@ -83,6 +83,7 @@ dependencies {
 
     def appCenterSdkVersion = '4.1.0'
     coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.2.2'
+
     implementation 'androidx.work:work-runtime-ktx:2.8.1'
     implementation "androidx.hilt:hilt-work:1.0.0"
     kapt "androidx.hilt:hilt-compiler:1.0.0"
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
@@ -63,6 +63,10 @@
                 android:name="androidx.work.WorkManagerInitializer"
                 android:value="androidx.startup"
                 tools:node="remove" />
+            <meta-data
+                android:name="com.lcl.lclmeasurementtool.sync.SyncInitializer"
+                android:value="androidx.startup"
+                tools:node="remove" />
         </provider>
 
         <activity
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/LCLApplication.kt b/app/src/main/java/com/lcl/lclmeasurementtool/LCLApplication.kt
@@ -12,13 +12,14 @@ import javax.inject.Inject
  * [Application] class for LCL Measurement tool
  */
 @HiltAndroidApp
-class LCLApplication : Application(), Configuration.Provider {
-    @Inject lateinit var workerFactory: HiltWorkerFactory
-
-    override fun getWorkManagerConfiguration() = Configuration.Builder()
-                                                    .setMinimumLoggingLevel(Log.DEBUG)
-                                                    .setWorkerFactory(workerFactory)
-                                                    .build()
+//class LCLApplication : Application(), Configuration.Provider {
+class LCLApplication : Application() {
+//    @Inject lateinit var workerFactory: HiltWorkerFactory
+//
+//    override fun getWorkManagerConfiguration() = Configuration.Builder()
+//                                                    .setMinimumLoggingLevel(Log.DEBUG)
+//                                                    .setWorkerFactory(workerFactory)
+//                                                    .build()
 
     override fun onCreate() {
         super.onCreate()
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/MainActivityViewModel.kt b/app/src/main/java/com/lcl/lclmeasurementtool/MainActivityViewModel.kt
@@ -7,6 +7,7 @@ import android.util.Log
 import androidx.compose.ui.graphics.Color
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import androidx.work.WorkManager
 import com.google.protobuf.ByteString
 import com.lcl.lclmeasurementtool.Utils.ECDSA
 import com.lcl.lclmeasurementtool.Utils.Hex
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/database/dao/ConnectivityDao.kt b/app/src/main/java/com/lcl/lclmeasurementtool/database/dao/ConnectivityDao.kt
@@ -17,7 +17,7 @@ interface ConnectivityDao {
 
     @Transaction
     @Query("SELECT * FROM connectivity_table where reported = false")
-    fun getAllNotReported(): Flow<List<ConnectivityReportModel>>
+    fun getAllNotReported(): List<ConnectivityReportModel>
 
     // WRITE
     @Transaction
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/database/dao/SignalStrengthDao.kt b/app/src/main/java/com/lcl/lclmeasurementtool/database/dao/SignalStrengthDao.kt
@@ -18,7 +18,7 @@ interface SignalStrengthDao {
 
     @Transaction
     @Query("SELECT * FROM signal_strength_table where reported = false")
-    fun getAllNotReported(): Flow<List<SignalStrengthReportModel>>
+    fun getAllNotReported(): List<SignalStrengthReportModel>
 
     // WRITE
     @Transaction
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/model/repository/ConnectivityRepository.kt b/app/src/main/java/com/lcl/lclmeasurementtool/model/repository/ConnectivityRepository.kt
@@ -1,11 +1,12 @@
 package com.lcl.lclmeasurementtool.model.repository
 
+import android.util.Log
 import com.lcl.lclmeasurementtool.database.dao.ConnectivityDao
 import com.lcl.lclmeasurementtool.model.datamodel.ConnectivityReportModel
-import com.lcl.lclmeasurementtool.sync.Synchronizer
+import com.lcl.lclmeasurementtool.util.Synchronizer
 import com.lcl.lclmeasurementtool.util.prepareReportData
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.*
 import javax.inject.Inject
 
 class ConnectivityRepository @Inject constructor(
@@ -19,16 +20,30 @@ class ConnectivityRepository @Inject constructor(
     override suspend fun insert(data: ConnectivityReportModel) = connectivityDao.insert(data)
 
     override suspend fun syncWith(synchronizer: Synchronizer) = synchronizer.syncData {
-        userDataRepository.userData.combine(connectivityDao.getAllNotReported()) { preference, connectivity ->
-            Pair(preference, connectivity)
-        }.collect {pair ->
+        val toReportList = connectivityDao.getAllNotReported()
+        if (toReportList.isEmpty()) {
+            Log.d(TAG, "no outstanding connectivity reports")
+            return@syncData
+        }
 
-            val userPreference = pair.first
-            val connectivityList = pair.second
-            connectivityList.forEach {connectivityReportModel ->
-                val reportString = prepareReportData(connectivityReportModel, userPreference)
+        toReportList.asFlow()
+            .flowOn(Dispatchers.IO)
+            .combine(userDataRepository.userData) { connectivity, preference ->
+                Log.d(TAG, "upload worker will upload $connectivity")
+                val reportString = prepareReportData(connectivity, preference)
                 networkApi.uploadConnectivity(reportString)
             }
-        }
+            .catch {
+                Log.d(TAG, "upload worker encounter $it when uploading connectivity")
+                throw it
+            }
+            .onCompletion {
+                Log.d(TAG, "finish uploading all unreported connectivity data")
+            }
+            .collect()
+    }
+
+    companion object {
+        const val TAG = "ConnectivityRepository"
     }
 }
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/model/repository/HistoryDataRepository.kt b/app/src/main/java/com/lcl/lclmeasurementtool/model/repository/HistoryDataRepository.kt
@@ -1,6 +1,6 @@
 package com.lcl.lclmeasurementtool.model.repository
 
-import com.lcl.lclmeasurementtool.sync.Syncable
+import com.lcl.lclmeasurementtool.util.Syncable
 import kotlinx.coroutines.flow.Flow
 
 interface HistoryDataRepository<T>: Syncable {
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/model/repository/SignalStrengthRepository.kt b/app/src/main/java/com/lcl/lclmeasurementtool/model/repository/SignalStrengthRepository.kt
@@ -1,11 +1,12 @@
 package com.lcl.lclmeasurementtool.model.repository
 
+import android.util.Log
 import com.lcl.lclmeasurementtool.database.dao.SignalStrengthDao
 import com.lcl.lclmeasurementtool.model.datamodel.SignalStrengthReportModel
-import com.lcl.lclmeasurementtool.sync.Synchronizer
+import com.lcl.lclmeasurementtool.util.Synchronizer
 import com.lcl.lclmeasurementtool.util.prepareReportData
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.*
 import javax.inject.Inject
 
 class SignalStrengthRepository @Inject constructor(
@@ -18,16 +19,30 @@ class SignalStrengthRepository @Inject constructor(
     override suspend fun insert(data: SignalStrengthReportModel) = signalStrengthDao.insert(data)
 
     override suspend fun syncWith(synchronizer: Synchronizer) = synchronizer.syncData {
-        userDataRepository.userData.combine(signalStrengthDao.getAllNotReported()) { preference, signalStrengths ->
-            Pair(preference, signalStrengths)
-        }.collect {pair ->
+        val toReportList = signalStrengthDao.getAllNotReported()
+        if (toReportList.isEmpty()) {
+            Log.d(TAG, "no outstanding signal strength reports")
+            return@syncData
+        }
 
-            val userPreference = pair.first
-            val signalStrengthList = pair.second
-            signalStrengthList.forEach {signalStrengthReportModel ->
-                val reportString = prepareReportData(signalStrengthReportModel, userPreference)
+        toReportList.asFlow()
+            .flowOn(Dispatchers.IO)
+            .combine(userDataRepository.userData) { signalStrength, preference ->
+                Log.d(TAG, "upload worker will upload $signalStrength")
+                val reportString = prepareReportData(signalStrength, preference)
                 networkApi.uploadSignalStrength(reportString)
             }
-        }
+            .catch {
+                Log.d(TAG, "upload worker encounter the following exception when uploading outstanding signal strength report")
+                throw it
+            }
+            .onCompletion {
+                Log.d(TAG, "finish uploading all unreported signal strength data")
+            }
+            .collect()
+    }
+
+    companion object {
+        const val TAG = "SignalStrengthRepository"
     }
 }
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/sync/DelegatingWorker.kt b/app/src/main/java/com/lcl/lclmeasurementtool/sync/DelegatingWorker.kt
@@ -0,0 +1,64 @@
+package com.lcl.lclmeasurementtool.sync
+
+import android.content.Context
+import androidx.hilt.work.HiltWorkerFactory
+import androidx.work.CoroutineWorker
+import androidx.work.Data
+import androidx.work.ForegroundInfo
+import androidx.work.WorkerParameters
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
+import kotlin.reflect.KClass
+
+/**
+ * An entry point to retrieve the [HiltWorkerFactory] at runtime
+ */
+@EntryPoint
+@InstallIn(SingletonComponent::class)
+interface HiltWorkerFactoryEntryPoint {
+    fun hiltWorkerFactory(): HiltWorkerFactory
+}
+
+private const val WORKER_CLASS_NAME = "RouterWorkerDelegateClassName"
+
+/**
+ * Adds metadata to a WorkRequest to identify what [CoroutineWorker] the [DelegatingWorker] should
+ * delegate to
+ */
+internal fun KClass<out CoroutineWorker>.delegatedData() =
+    Data.Builder()
+        .putString(WORKER_CLASS_NAME, qualifiedName)
+        .build()
+
+/**
+ * A worker that delegates sync to another [CoroutineWorker] constructed with a [HiltWorkerFactory].
+ *
+ * This allows for creating and using [CoroutineWorker] instances with extended arguments
+ * without having to provide a custom WorkManager configuration that the app module needs to utilize.
+ *
+ * In other words, it allows for custom workers in a library module without having to own
+ * configuration of the WorkManager singleton.
+ */
+class DelegatingWorker(
+    appContext: Context,
+    workerParams: WorkerParameters,
+) : CoroutineWorker(appContext, workerParams) {
+
+    private val workerClassName =
+        workerParams.inputData.getString(WORKER_CLASS_NAME) ?: ""
+
+    private val delegateWorker =
+        EntryPointAccessors.fromApplication<HiltWorkerFactoryEntryPoint>(appContext)
+            .hiltWorkerFactory()
+            .createWorker(appContext, workerClassName, workerParams)
+                as? CoroutineWorker
+            ?: throw IllegalArgumentException("Unable to find appropriate worker")
+
+    override suspend fun getForegroundInfo(): ForegroundInfo =
+        delegateWorker.getForegroundInfo()
+
+    override suspend fun doWork(): Result =
+        delegateWorker.doWork()
+}
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/sync/SyncInitializer.kt b/app/src/main/java/com/lcl/lclmeasurementtool/sync/SyncInitializer.kt
@@ -24,11 +24,13 @@ internal const val SyncWorkName = "LCLDataReportSync"
 
 class SyncInitializer: Initializer<Sync> {
     override fun create(context: Context): Sync {
-        WorkManager.getInstance(context).enqueueUniquePeriodicWork(
+        WorkManager.getInstance(context).apply {
+            enqueueUniquePeriodicWork(
                 SyncWorkName,
                 ExistingPeriodicWorkPolicy.CANCEL_AND_REENQUEUE,
                 UploadWorker.periodicSyncWork()
             )
+        }
         Log.d("SyncInitializer", "SyncInitializer initialize here!")
         return Sync
     }
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/sync/UploadWorker.kt b/app/src/main/java/com/lcl/lclmeasurementtool/sync/UploadWorker.kt
@@ -8,6 +8,7 @@ import com.lcl.lclmeasurementtool.datastore.Dispatcher
 import com.lcl.lclmeasurementtool.datastore.LCLDispatchers
 import com.lcl.lclmeasurementtool.model.repository.ConnectivityRepository
 import com.lcl.lclmeasurementtool.model.repository.SignalStrengthRepository
+import com.lcl.lclmeasurementtool.util.Synchronizer
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import kotlinx.coroutines.CoroutineDispatcher
@@ -30,8 +31,16 @@ class UploadWorker @AssistedInject constructor(
         withContext(ioDispatcher) {
             try {
                 val syncSuccessfully = awaitAll(
-                    async { signalStrengthRepository.sync() },
-                    async { connectivityRepository.sync() }
+                    async {
+                        val b = signalStrengthRepository.sync()
+                        Log.d(TAG, "signal strength repository finish sync")
+                        b
+                    },
+                    async {
+                        val b = connectivityRepository.sync()
+                        Log.d(TAG, "connectivity repository finish sync")
+                        b
+                    }
                 ).all { it }
                 if (syncSuccessfully) {
                     Log.d(TAG, "upload successfully")
@@ -48,10 +57,11 @@ class UploadWorker @AssistedInject constructor(
 
     companion object {
         fun periodicSyncWork() =
-            PeriodicWorkRequest.Builder(UploadWorker::class.java, 15, TimeUnit.MINUTES)
+            PeriodicWorkRequestBuilder<DelegatingWorker>(8, TimeUnit.HOURS)
             .setConstraints(Constraints(requiredNetworkType = NetworkType.CONNECTED))
-            .setInitialDelay(5, TimeUnit.MINUTES)
-            .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, Duration.ofMinutes(30))
+            .setInitialDelay(10, TimeUnit.MINUTES)
+            .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, Duration.ofMinutes(10))
+            .setInputData(UploadWorker::class.delegatedData())
             .build()
 
         const val TAG = "UploadWorker"
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/ui/SignalStrengthItem.kt b/app/src/main/java/com/lcl/lclmeasurementtool/ui/SignalStrengthItem.kt
@@ -38,7 +38,7 @@ fun SignalStrengthItem(
             SignalStrengthContent(data = data)
         }
         if (data.reported) {
-            TagLabel("Reported", modifier = Modifier.padding(end = 4.dp))
+            TagLabel("Reported", modifier = Modifier.padding(end = 10.dp))
         }
     }
 }
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/ui/TagIcon.kt b/app/src/main/java/com/lcl/lclmeasurementtool/ui/TagIcon.kt
@@ -45,7 +45,7 @@ fun TagLabel(label: String, modifier: Modifier = Modifier) {
 
     ) {
         
-        Text(text = label, fontSize = 8.sp, fontStyle = FontStyle.Italic)
+        Text(text = label, fontSize = 10.sp, fontStyle = FontStyle.Italic)
     }
 }
 
diff --git a/app/src/main/java/com/lcl/lclmeasurementtool/util/SyncUtil.kt b/app/src/main/java/com/lcl/lclmeasurementtool/util/SyncUtil.kt
@@ -1,11 +1,11 @@
-package com.lcl.lclmeasurementtool.sync
+package com.lcl.lclmeasurementtool.util
 
 import android.util.Log
 import retrofit2.HttpException
 import kotlin.coroutines.cancellation.CancellationException
 
 private suspend fun <T> suspendRunCatching(block: suspend () -> T): Result<T> = try {
-    Log.d("suspendRunCatching", "block ${block.javaClass.name} run successfully")
+    Log.d("suspendRunCatching", "block ${block.javaClass.name} is invoked")
     Result.success(block())
 } catch (cancellationException: CancellationException) {
     throw cancellationException
