Fix autosend scheduling

analytics/src/main/java/org/odk/collect/analytics/Analytics.kt

@@ -41,5 +41,9 @@ interface Analytics {
         fun setParam(key: String, value: String) {
             params[key] = value
         }
+
+        fun setUserProperty(name: String, value: String) {
+            instance.setUserProperty(name, value)
+        }
     }
 }

async/build.gradle.kts

@@ -42,6 +42,9 @@ dependencies {
     implementation(Dependencies.androidx_core_ktx)
     implementation(Dependencies.kotlinx_coroutines_android)
     implementation(Dependencies.androidx_work_runtime)
+    implementation(project(":analytics")) {
+        exclude("com.google.firebase")
+    }
 
     testImplementation(Dependencies.hamcrest)
     testImplementation(Dependencies.robolectric)

async/src/main/AndroidManifest.xml

@@ -1,2 +1,3 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-</manifest>
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+</manifest>

async/src/main/java/org/odk/collect/async/CoroutineAndWorkManagerScheduler.kt

@@ -13,25 +13,44 @@ import kotlinx.coroutines.Dispatchers
 import java.util.concurrent.TimeUnit
 import kotlin.coroutines.CoroutineContext
 
-class CoroutineAndWorkManagerScheduler(foregroundContext: CoroutineContext, backgroundContext: CoroutineContext, private val workManager: WorkManager) : CoroutineScheduler(foregroundContext, backgroundContext) {
-
-    constructor(workManager: WorkManager) : this(Dispatchers.Main, Dispatchers.IO, workManager) // Needed for Java construction
-
-    override fun networkDeferred(tag: String, spec: TaskSpec, inputData: Map<String, String>, networkConstraint: Scheduler.NetworkType?) {
+class CoroutineAndWorkManagerScheduler(
+    foregroundContext: CoroutineContext,
+    backgroundContext: CoroutineContext,
+    private val workManager: WorkManager
+) : CoroutineScheduler(foregroundContext, backgroundContext) {
+
+    constructor(workManager: WorkManager) : this(
+        Dispatchers.Main,
+        Dispatchers.IO,
+        workManager
+    ) // Needed for Java construction
+
+    override fun networkDeferred(
+        tag: String,
+        spec: TaskSpec,
+        inputData: Map<String, String>,
+        networkConstraint: Scheduler.NetworkType?
+    ) {
         val constraintNetworkType = when (networkConstraint) {
             Scheduler.NetworkType.WIFI -> NetworkType.UNMETERED
             Scheduler.NetworkType.CELLULAR -> NetworkType.METERED
-            null -> NetworkType.CONNECTED
+            else -> NetworkType.CONNECTED
         }
 
         val constraints = Constraints.Builder()
             .setRequiredNetworkType(constraintNetworkType)
             .build()
 
-        val workManagerInputData = Data.Builder().putAll(inputData).build()
+        val workManagerInputData = Data.Builder()
+            .putString(TaskSpecWorker.DATA_TASK_SPEC_CLASS, spec.javaClass.name)
+            .putBoolean(
+                TaskSpecWorker.DATA_CELLULAR_ONLY,
+                networkConstraint == Scheduler.NetworkType.CELLULAR
+            )
+            .putAll(inputData)
+            .build()
 
-        val worker = spec.getWorkManagerAdapter()
-        val workRequest = OneTimeWorkRequest.Builder(worker)
+        val workRequest = OneTimeWorkRequest.Builder(TaskSpecWorker::class.java)
             .addTag(tag)
             .setConstraints(constraints)
             .setInputData(workManagerInputData)
@@ -40,15 +59,26 @@ class CoroutineAndWorkManagerScheduler(foregroundContext: CoroutineContext, back
         workManager.beginUniqueWork(tag, ExistingWorkPolicy.REPLACE, workRequest).enqueue()
     }
 
-    override fun networkDeferredRepeat(tag: String, spec: TaskSpec, repeatPeriod: Long, inputData: Map<String, String>) {
+    override fun networkDeferredRepeat(
+        tag: String,
+        spec: TaskSpec,
+        repeatPeriod: Long,
+        inputData: Map<String, String>
+    ) {
         val constraints = Constraints.Builder()
             .setRequiredNetworkType(NetworkType.CONNECTED)
             .build()
 
-        val workManagerInputData = Data.Builder().putAll(inputData).build()
+        val workManagerInputData = Data.Builder()
+            .putString(TaskSpecWorker.DATA_TASK_SPEC_CLASS, spec.javaClass.name)
+            .putAll(inputData)
+            .build()
 
-        val worker = spec.getWorkManagerAdapter()
-        val builder = PeriodicWorkRequest.Builder(worker, repeatPeriod, TimeUnit.MILLISECONDS)
+        val builder = PeriodicWorkRequest.Builder(
+            TaskSpecWorker::class.java,
+            repeatPeriod,
+            TimeUnit.MILLISECONDS
+        )
             .addTag(tag)
             .setInputData(workManagerInputData)
             .setConstraints(constraints)
@@ -59,7 +89,11 @@ class CoroutineAndWorkManagerScheduler(foregroundContext: CoroutineContext, back
             }
         }
 
-        workManager.enqueueUniquePeriodicWork(tag, ExistingPeriodicWorkPolicy.REPLACE, builder.build())
+        workManager.enqueueUniquePeriodicWork(
+            tag,
+            ExistingPeriodicWorkPolicy.REPLACE,
+            builder.build()
+        )
     }
 
     override fun cancelDeferred(tag: String) {

async/src/main/java/org/odk/collect/async/Scheduler.kt

@@ -81,7 +81,8 @@ interface Scheduler {
 
     enum class NetworkType {
         WIFI,
-        CELLULAR
+        CELLULAR,
+        OTHER
     }
 }
 

async/src/main/java/org/odk/collect/async/TaskSpec.kt

@@ -18,10 +18,4 @@ interface TaskSpec {
      * once instead of doing that after every single execution.
      */
     fun getTask(context: Context, inputData: Map<String, String>, isLastUniqueExecution: Boolean): Supplier<Boolean>
-
-    /**
-     * Returns class that can be used to schedule this task using Android's
-     * WorkManager framework
-     */
-    fun getWorkManagerAdapter(): Class<out WorkerAdapter>
 }

async/src/main/java/org/odk/collect/async/TaskSpecWorker.kt

@@ -0,0 +1,47 @@
+package org.odk.collect.async
+
+import android.content.Context
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import org.odk.collect.analytics.Analytics
+import org.odk.collect.async.network.ConnectivityProvider
+
+class TaskSpecWorker(
+    context: Context,
+    workerParams: WorkerParameters
+) : Worker(context, workerParams) {
+
+    private val connectivityProvider: ConnectivityProvider = ConnectivityProvider(context)
+
+    override fun doWork(): Result {
+        val cellularOnly = inputData.getBoolean(DATA_CELLULAR_ONLY, false)
+        if (cellularOnly && connectivityProvider.currentNetwork != Scheduler.NetworkType.CELLULAR) {
+            Analytics.setUserProperty("EncounteredMeteredNonCellularInTasks", "true")
+            return Result.retry()
+        }
+
+        val specClass = inputData.getString(DATA_TASK_SPEC_CLASS)!!
+        val spec = Class.forName(specClass).getConstructor().newInstance() as TaskSpec
+
+        val stringInputData = inputData.keyValueMap.mapValues { it.value.toString() }
+        val completed =
+            spec.getTask(applicationContext, stringInputData, isLastUniqueExecution(spec)).get()
+        val maxRetries = spec.maxRetries
+
+        return if (completed) {
+            Result.success()
+        } else if (maxRetries == null || runAttemptCount < maxRetries) {
+            Result.retry()
+        } else {
+            Result.failure()
+        }
+    }
+
+    private fun isLastUniqueExecution(spec: TaskSpec) =
+        spec.maxRetries?.let { runAttemptCount >= it } ?: true
+
+    companion object {
+        const val DATA_TASK_SPEC_CLASS = "taskSpecClass"
+        const val DATA_CELLULAR_ONLY = "cellularOnly"
+    }
+}

async/src/main/java/org/odk/collect/async/network/ConnectivityProvider.kt

@@ -0,0 +1,23 @@
+package org.odk.collect.async.network
+
+import android.content.Context
+import android.net.ConnectivityManager
+import org.odk.collect.async.Scheduler
+
+class ConnectivityProvider(private val context: Context) : NetworkStateProvider {
+    override val currentNetwork: Scheduler.NetworkType?
+        get() {
+            return if (connectivityManager.activeNetworkInfo?.isConnected == true) {
+                when (connectivityManager.activeNetworkInfo?.type) {
+                    ConnectivityManager.TYPE_WIFI -> Scheduler.NetworkType.WIFI
+                    ConnectivityManager.TYPE_MOBILE -> Scheduler.NetworkType.CELLULAR
+                    else -> Scheduler.NetworkType.OTHER
+                }
+            } else {
+                null
+            }
+        }
+
+    private val connectivityManager: ConnectivityManager
+        get() = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+}

async/src/main/java/org/odk/collect/async/network/NetworkStateProvider.kt

@@ -0,0 +1,12 @@
+package org.odk.collect.async.network
+
+import org.odk.collect.async.Scheduler
+
+interface NetworkStateProvider {
+    val currentNetwork: Scheduler.NetworkType?
+
+    val isDeviceOnline: Boolean
+        get() {
+            return currentNetwork != null
+        }
+}