Queue tracking updates when offline (closes #1497)

Co-authored-by: Jays2Kings <Jays2Kings@users.noreply.github.com>

app/src/main/java/eu/kanade/tachiyomi/data/track/job/DelayedTrackingStore.kt

@@ -0,0 +1,50 @@
+package eu.kanade.tachiyomi.data.track.job
+
+import android.content.Context
+import androidx.core.content.edit
+import eu.kanade.tachiyomi.data.database.models.Track
+import timber.log.Timber
+
+class DelayedTrackingStore(context: Context) {
+
+    /**
+     * Preference file where queued tracking updates are stored.
+     */
+    private val preferences = context.getSharedPreferences("tracking_queue", Context.MODE_PRIVATE)
+
+    fun addItem(track: Track) {
+        val trackId = track.id.toString()
+        val (_, lastChapterRead) = preferences.getString(trackId, "0:0.0")!!.split(":")
+        if (track.last_chapter_read > lastChapterRead.toFloat()) {
+            val value = "${track.manga_id}:${track.last_chapter_read}"
+            Timber.i("Queuing track item: $trackId, $value")
+            preferences.edit {
+                putString(trackId, value)
+            }
+        }
+    }
+
+    fun clear() {
+        preferences.edit {
+            clear()
+        }
+    }
+
+    fun getItems(): List<DelayedTrackingItem> {
+        return (preferences.all as Map<String, String>).entries
+            .map {
+                val (mangaId, lastChapterRead) = it.value.split(":")
+                DelayedTrackingItem(
+                    trackId = it.key.toLong(),
+                    mangaId = mangaId.toLong(),
+                    lastChapterRead = lastChapterRead.toFloat(),
+                )
+            }
+    }
+
+    data class DelayedTrackingItem(
+        val trackId: Long,
+        val mangaId: Long,
+        val lastChapterRead: Float,
+    )
+}

app/src/main/java/eu/kanade/tachiyomi/data/track/job/DelayedTrackingUpdateJob.kt

@@ -0,0 +1,75 @@
+package eu.kanade.tachiyomi.data.track.job
+
+import android.content.Context
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+import eu.kanade.tachiyomi.data.database.DatabaseHelper
+import eu.kanade.tachiyomi.data.track.TrackManager
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import timber.log.Timber
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.util.concurrent.TimeUnit
+
+class DelayedTrackingUpdateJob(context: Context, workerParams: WorkerParameters) :
+    CoroutineWorker(context, workerParams) {
+
+    override suspend fun doWork(): Result {
+        val db = Injekt.get<DatabaseHelper>()
+        val trackManager = Injekt.get<TrackManager>()
+        val delayedTrackingStore = Injekt.get<DelayedTrackingStore>()
+
+        withContext(Dispatchers.IO) {
+            val tracks = delayedTrackingStore.getItems().mapNotNull {
+                val manga = db.getManga(it.mangaId).executeAsBlocking() ?: return@withContext
+                db.getTracks(manga).executeAsBlocking()
+                    .find { track -> track.id == it.trackId }
+                    ?.also { track ->
+                        track.last_chapter_read = it.lastChapterRead
+                    }
+            }
+
+            tracks.forEach { track ->
+                try {
+                    val service = trackManager.getService(track.sync_id)
+                    if (service != null && service.isLogged) {
+                        service.update(track, true)
+                        db.insertTrack(track).executeAsBlocking()
+                    }
+                } catch (e: Exception) {
+                    Timber.e(e)
+                }
+            }
+
+            delayedTrackingStore.clear()
+        }
+
+        return Result.success()
+    }
+
+    companion object {
+        private const val TAG = "DelayedTrackingUpdate"
+
+        fun setupTask(context: Context) {
+            val constraints = Constraints.Builder()
+                .setRequiredNetworkType(NetworkType.CONNECTED)
+                .build()
+
+            val request = OneTimeWorkRequestBuilder<DelayedTrackingUpdateJob>()
+                .setConstraints(constraints)
+                .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 20, TimeUnit.SECONDS)
+                .addTag(TAG)
+                .build()
+
+            WorkManager.getInstance(context)
+                .enqueueUniqueWork(TAG, ExistingWorkPolicy.REPLACE, request)
+        }
+    }
+}