Implement recurring tasks using AndroidX Work

app/src/main/java/org/wikipedia/activity/BaseActivity.kt

@@ -101,7 +101,7 @@ abstract class BaseActivity : AppCompatActivity(), ConnectionStateMonitor.Callba
         }
 
         // Conditionally execute all recurring tasks
-        RecurringTasksExecutor().run()
+        RecurringTasksExecutor.schedule()
         if (Prefs.isReadingListsFirstTimeSync && AccountUtil.isLoggedIn) {
             Prefs.isReadingListsFirstTimeSync = false
             Prefs.isReadingListSyncEnabled = true

app/src/main/java/org/wikipedia/alphaupdater/AlphaUpdateWorker.kt

@@ -0,0 +1,71 @@
+package org.wikipedia.alphaupdater
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.app.PendingIntentCompat
+import androidx.core.content.ContextCompat
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import okhttp3.Request
+import okio.IOException
+import org.wikipedia.dataclient.okhttp.OkHttpConnectionFactory.client
+import org.wikipedia.notifications.NotificationCategory
+import org.wikipedia.settings.PrefsIoUtil
+
+class AlphaUpdateWorker(
+    appContext: Context,
+    params: WorkerParameters
+) : CoroutineWorker(appContext, params) {
+    override suspend fun doWork(): Result {
+        val hashString = withContext(Dispatchers.IO) {
+            val request = Request.Builder().url(ALPHA_BUILD_DATA_URL).build()
+            try {
+                client.newCall(request).execute().body!!.use { it.string() }
+            } catch (e: IOException) {
+                // It's ok, we can do nothing.
+                null
+            }
+        }
+        if (hashString == null) {
+            return Result.failure()
+        }
+        if (PrefsIoUtil.getString(PREFERENCE_KEY_ALPHA_COMMIT, "") != hashString) {
+            showNotification()
+        }
+        PrefsIoUtil.setString(PREFERENCE_KEY_ALPHA_COMMIT, hashString)
+        return Result.success()
+    }
+
+    private fun showNotification() {
+        if (ContextCompat.checkSelfPermission(applicationContext, Manifest.permission.POST_NOTIFICATIONS)
+            != PackageManager.PERMISSION_GRANTED) {
+            return
+        }
+        val intent = Intent(Intent.ACTION_VIEW, Uri.parse(ALPHA_BUILD_APK_URL))
+        val pendingIntent = PendingIntentCompat.getActivity(applicationContext, 0, intent, 0, false)
+
+        val notificationManagerCompat = NotificationManagerCompat.from(applicationContext)
+        val notificationCategory = NotificationCategory.ALPHA_BUILD_CHECKER
+
+        val notificationBuilder = NotificationCompat.Builder(applicationContext, notificationCategory.id)
+            .setContentTitle(applicationContext.getString(notificationCategory.title))
+            .setContentText(applicationContext.getString(notificationCategory.description))
+            .setContentIntent(pendingIntent)
+            .setAutoCancel(true)
+        notificationBuilder.setSmallIcon(notificationCategory.iconResId)
+        notificationManagerCompat.notify(1, notificationBuilder.build())
+    }
+
+    companion object {
+        private const val PREFERENCE_KEY_ALPHA_COMMIT = "alpha_last_checked_commit"
+        private const val ALPHA_BUILD_APK_URL = "https://github.com/wikimedia/apps-android-wikipedia/releases/download/latest/app-alpha-universal-release.apk"
+        private const val ALPHA_BUILD_DATA_URL = "https://github.com/wikimedia/apps-android-wikipedia/releases/download/latest/rev-hash.txt"
+    }
+}

app/src/main/java/org/wikipedia/notifications/PollNotificationWorker.kt

@@ -61,11 +61,8 @@ class PollNotificationWorker(
 
     companion object {
         fun schedulePollNotificationJob(context: Context) {
-            val constraints = Constraints.Builder()
-                .setRequiredNetworkType(NetworkType.CONNECTED)
-                .build()
             val workRequest = OneTimeWorkRequestBuilder<PollNotificationWorker>()
-                .setConstraints(constraints)
+                .setConstraints(Constraints(NetworkType.CONNECTED))
                 .build()
             WorkManager.getInstance(context).enqueue(workRequest)
         }

app/src/main/java/org/wikipedia/recurring/DailyEventWorker.kt

@@ -0,0 +1,19 @@
+package org.wikipedia.recurring
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import org.wikipedia.WikipediaApp
+import org.wikipedia.analytics.eventplatform.DailyStatsEvent
+import org.wikipedia.analytics.eventplatform.EventPlatformClient
+
+class DailyEventWorker(
+    appContext: Context,
+    params: WorkerParameters
+) : CoroutineWorker(appContext, params) {
+    override suspend fun doWork(): Result {
+        DailyStatsEvent.log(WikipediaApp.instance)
+        EventPlatformClient.refreshStreamConfigs()
+        return Result.success()
+    }
+}

app/src/main/java/org/wikipedia/recurring/RecurringTasksExecutor.kt

@@ -1,26 +1,58 @@
 package org.wikipedia.recurring
 
-import kotlinx.coroutines.CoroutineExceptionHandler
-import kotlinx.coroutines.MainScope
-import kotlinx.coroutines.launch
+import androidx.work.Constraints
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import org.wikipedia.R
 import org.wikipedia.WikipediaApp
-import org.wikipedia.alphaupdater.AlphaUpdateChecker
-import org.wikipedia.settings.RemoteConfigRefreshTask
+import org.wikipedia.alphaupdater.AlphaUpdateWorker
+import org.wikipedia.settings.PrefsIoUtil
+import org.wikipedia.settings.RemoteConfigRefreshWorker
 import org.wikipedia.util.ReleaseUtil
-import org.wikipedia.util.log.L
-
-class RecurringTasksExecutor() {
-    fun run() {
-        val app = WikipediaApp.instance
-        MainScope().launch(CoroutineExceptionHandler { _, throwable ->
-            L.e(throwable)
-        }) {
-            RemoteConfigRefreshTask().runIfNecessary()
-            DailyEventTask(app).runIfNecessary()
-            TalkOfflineCleanupTask(app).runIfNecessary()
-            if (ReleaseUtil.isAlphaRelease) {
-                AlphaUpdateChecker(app).runIfNecessary()
-            }
+import java.util.concurrent.TimeUnit
+
+object RecurringTasksExecutor {
+    fun schedule() {
+        // Clean up now-unused task time values, as WorkManager handles scheduling
+        PrefsIoUtil.remove("alpha-update-checker")
+        PrefsIoUtil.remove("remote-config-refresher")
+        PrefsIoUtil.remove(R.string.preference_key_talk_offline_cleanup_task_name)
+        PrefsIoUtil.remove(R.string.preference_key_daily_event_time_task_name)
+
+        val networkConstraints = Constraints(
+            requiredNetworkType = NetworkType.CONNECTED,
+            requiresBatteryNotLow = true
+        )
+
+        val remoteConfigRefreshRequest = PeriodicWorkRequestBuilder<RemoteConfigRefreshWorker>(1, TimeUnit.DAYS)
+            .setConstraints(networkConstraints)
+            .build()
+
+        val dailyEventRequest = PeriodicWorkRequestBuilder<DailyEventWorker>(1, TimeUnit.DAYS)
+            .setConstraints(networkConstraints)
+            .build()
+
+        val offlineCleanupRequest = PeriodicWorkRequestBuilder<TalkOfflineCleanupWorker>(7, TimeUnit.DAYS)
+            .setConstraints(Constraints(requiresBatteryNotLow = true))
+            .build()
+
+        val tasks = mutableMapOf(
+            "REMOTE_CONFIG" to remoteConfigRefreshRequest,
+            "DAILY_EVENT" to dailyEventRequest,
+            "OFFLINE_CLEANUP" to offlineCleanupRequest
+        )
+
+        if (ReleaseUtil.isAlphaRelease) {
+            tasks["ALPHA_UPDATE"] = PeriodicWorkRequestBuilder<AlphaUpdateWorker>(1, TimeUnit.DAYS)
+                .setConstraints(networkConstraints)
+                .build()
+        }
+
+        tasks.forEach { (taskName, task) ->
+            WorkManager.getInstance(WikipediaApp.instance)
+                .enqueueUniquePeriodicWork(taskName, ExistingPeriodicWorkPolicy.KEEP, task)
         }
     }
 }

app/src/main/java/org/wikipedia/recurring/TalkOfflineCleanupTask.kt → app/src/main/java/org/wikipedia/recurring/TalkOfflineCleanupWorker.kt

@@ -1,32 +1,32 @@
 package org.wikipedia.recurring
 
 import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import org.wikipedia.R
 import org.wikipedia.database.AppDatabase
 import java.io.File
-import java.util.Date
-import java.util.concurrent.TimeUnit
+import java.time.Instant
+import java.time.temporal.ChronoUnit
 
-class TalkOfflineCleanupTask(context: Context) : RecurringTask() {
-    override val name = context.getString(R.string.preference_key_talk_offline_cleanup_task_name)
-
-    override fun shouldRun(lastRun: Date): Boolean {
-        return millisSinceLastRun(lastRun) > TimeUnit.DAYS.toMillis(CLEANUP_MAX_AGE_DAYS)
-    }
-
-    override suspend fun run(lastRun: Date) {
+class TalkOfflineCleanupWorker(
+    appContext: Context,
+    params: WorkerParameters
+) : CoroutineWorker(appContext, params) {
+    override suspend fun doWork(): Result {
         withContext(Dispatchers.IO) {
             AppDatabase.instance.offlineObjectDao()
                 .searchForOfflineObjects(CLEANUP_URL_SEARCH_KEY)
                 .filter {
-                    (absoluteTime - File(it.path + ".0").lastModified()) > TimeUnit.DAYS.toMillis(CLEANUP_MAX_AGE_DAYS)
+                    val lastModified = Instant.ofEpochMilli(File("${it.path}.0").lastModified())
+                    ChronoUnit.DAYS.between(lastModified, Instant.now()) > CLEANUP_MAX_AGE_DAYS
                 }.forEach {
                     AppDatabase.instance.offlineObjectDao().deleteOfflineObject(it)
                     AppDatabase.instance.offlineObjectDao().deleteFilesForObject(it)
                 }
         }
+        return Result.success()
     }
 
     companion object {