Implement recurring tasks using AndroidX Work

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

@@ -97,7 +97,7 @@ abstract class BaseActivity : AppCompatActivity(), ConnectionStateMonitor.Callba
         supportActionBar?.setDisplayHomeAsUpEnabled(true)
 
         // 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/CategoriesTableCleanupWorker.kt

@@ -0,0 +1,24 @@
+package org.wikipedia.recurring
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import org.wikipedia.database.AppDatabase
+import org.wikipedia.util.log.L
+import java.time.LocalDate
+
+class CategoriesTableCleanupWorker(
+    appContext: Context,
+    workerParams: WorkerParameters
+) : CoroutineWorker(appContext, workerParams) {
+    override suspend fun doWork(): Result {
+        val twoYearsAgoTimeStamp = LocalDate.now().year - CLEANUP_TIME_IN_YEARS
+        AppDatabase.instance.categoryDao().deleteOlderThan(twoYearsAgoTimeStamp)
+        L.d("Successfully deleted Category data older than $CLEANUP_TIME_IN_YEARS years")
+        return Result.success()
+    }
+
+    companion object {
+        const val CLEANUP_TIME_IN_YEARS = 2
+    }
+}

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/RecommendedReadingListTask.kt → app/src/main/java/org/wikipedia/recurring/RecommendedReadingListWorker.kt

@@ -1,29 +1,29 @@
 package org.wikipedia.recurring
 
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
 import org.wikipedia.readinglist.recommended.RecommendedReadingListHelper
 import org.wikipedia.readinglist.recommended.RecommendedReadingListUpdateFrequency
 import org.wikipedia.settings.Prefs
+import java.time.DayOfWeek
 import java.time.LocalDate
-import java.util.Date
-import java.util.concurrent.TimeUnit
 
-class RecommendedReadingListTask() : RecurringTask() {
-    override val name = "generateRecommendedReadingListTask"
-
-    override fun shouldRun(lastRun: Date): Boolean {
-        if (millisSinceLastRun(lastRun) < TimeUnit.DAYS.toMillis(1)) {
-            return false
-        }
+class RecommendedReadingListWorker(
+    appContext: Context,
+    workerParams: WorkerParameters,
+) : CoroutineWorker(appContext, workerParams) {
+    override suspend fun doWork(): Result {
         // And run either every day, or on the first day of the week or month
         val now = LocalDate.now()
-        return when (Prefs.recommendedReadingListUpdateFrequency) {
+        val shouldRun = when (Prefs.recommendedReadingListUpdateFrequency) {
             RecommendedReadingListUpdateFrequency.DAILY -> true
-            RecommendedReadingListUpdateFrequency.WEEKLY -> now.dayOfWeek.value == 1
+            RecommendedReadingListUpdateFrequency.WEEKLY -> now.dayOfWeek == DayOfWeek.MONDAY
             RecommendedReadingListUpdateFrequency.MONTHLY -> now.dayOfMonth == 1
         }
-    }
-
-    override suspend fun run(lastRun: Date) {
-        RecommendedReadingListHelper.generateRecommendedReadingList(true)
+        if (shouldRun) {
+            RecommendedReadingListHelper.generateRecommendedReadingList(true)
+        }
+        return Result.success()
     }
 }