Refactor some tracking-related logic

app/src/main/java/eu/kanade/domain/DomainModule.kt

@@ -16,6 +16,7 @@ import eu.kanade.domain.source.interactor.SetMigrateSorting
 import eu.kanade.domain.source.interactor.ToggleLanguage
 import eu.kanade.domain.source.interactor.ToggleSource
 import eu.kanade.domain.source.interactor.ToggleSourcePin
+import eu.kanade.domain.track.interactor.RefreshTracks
 import eu.kanade.domain.track.interactor.TrackChapter
 import tachiyomi.data.category.CategoryRepositoryImpl
 import tachiyomi.data.chapter.ChapterRepositoryImpl
@@ -113,6 +114,7 @@ class DomainModule : InjektModule {
 
         addSingletonFactory<TrackRepository> { TrackRepositoryImpl(get()) }
         addFactory { TrackChapter(get(), get(), get(), get()) }
+        addFactory { RefreshTracks(get(), get(), get(), get()) }
         addFactory { DeleteTrack(get()) }
         addFactory { GetTracksPerManga(get()) }
         addFactory { GetTracks(get()) }
@@ -125,7 +127,7 @@ class DomainModule : InjektModule {
         addFactory { SetReadStatus(get(), get(), get(), get()) }
         addFactory { ShouldUpdateDbChapter() }
         addFactory { SyncChaptersWithSource(get(), get(), get(), get(), get(), get(), get()) }
-        addFactory { SyncChaptersWithTrackServiceTwoWay(get(), get()) }
+        addFactory { SyncChaptersWithTrackServiceTwoWay(get(), get(), get()) }
 
         addSingletonFactory<HistoryRepository> { HistoryRepositoryImpl(get()) }
         addFactory { GetHistory(get()) }

app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithTrackServiceTwoWay.kt

@@ -1,11 +1,12 @@
 package eu.kanade.domain.chapter.interactor
 
 import eu.kanade.domain.track.model.toDbTrack
+import eu.kanade.tachiyomi.data.track.EnhancedTrackService
 import eu.kanade.tachiyomi.data.track.TrackService
 import logcat.LogPriority
 import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.chapter.interactor.GetChapterByMangaId
 import tachiyomi.domain.chapter.interactor.UpdateChapter
-import tachiyomi.domain.chapter.model.Chapter
 import tachiyomi.domain.chapter.model.toChapterUpdate
 import tachiyomi.domain.track.interactor.InsertTrack
 import tachiyomi.domain.track.model.Track
@@ -13,14 +14,22 @@ import tachiyomi.domain.track.model.Track
 class SyncChaptersWithTrackServiceTwoWay(
     private val updateChapter: UpdateChapter,
     private val insertTrack: InsertTrack,
+    private val getChapterByMangaId: GetChapterByMangaId,
 ) {
 
     suspend fun await(
-        chapters: List<Chapter>,
+        mangaId: Long,
         remoteTrack: Track,
         service: TrackService,
     ) {
-        val sortedChapters = chapters.sortedBy { it.chapterNumber }
+        if (service !is EnhancedTrackService) {
+            return
+        }
+
+        val sortedChapters = getChapterByMangaId.await(mangaId)
+            .sortedBy { it.chapterNumber }
+            .filter { it.isRecognizedNumber }
+
         val chapterUpdates = sortedChapters
             .filter { chapter -> chapter.chapterNumber <= remoteTrack.lastChapterRead && !chapter.read }
             .map { it.copy(read = true).toChapterUpdate() }

app/src/main/java/eu/kanade/domain/track/interactor/RefreshTracks.kt

@@ -0,0 +1,43 @@
+package eu.kanade.domain.track.interactor
+
+import eu.kanade.domain.chapter.interactor.SyncChaptersWithTrackServiceTwoWay
+import eu.kanade.domain.track.model.toDbTrack
+import eu.kanade.domain.track.model.toDomainTrack
+import eu.kanade.tachiyomi.data.track.TrackManager
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.supervisorScope
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.track.interactor.GetTracks
+import tachiyomi.domain.track.interactor.InsertTrack
+
+class RefreshTracks(
+    private val getTracks: GetTracks,
+    private val trackManager: TrackManager,
+    private val insertTrack: InsertTrack,
+    private val syncChaptersWithTrackServiceTwoWay: SyncChaptersWithTrackServiceTwoWay,
+) {
+
+    suspend fun await(mangaId: Long) {
+        supervisorScope {
+            getTracks.await(mangaId)
+                .map { track ->
+                    async {
+                        val service = trackManager.getService(track.syncId)
+                        if (service != null && service.isLoggedIn) {
+                            try {
+                                val updatedTrack = service.refresh(track.toDbTrack())
+                                insertTrack.await(updatedTrack.toDomainTrack()!!)
+                                syncChaptersWithTrackServiceTwoWay.await(mangaId, track, service)
+                            } catch (e: Throwable) {
+                                // Ignore errors and continue
+                                logcat(LogPriority.ERROR, e)
+                            }
+                        }
+                    }
+                }
+                .awaitAll()
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/track/interactor/TrackChapter.kt

@@ -24,33 +24,31 @@ class TrackChapter(
     suspend fun await(context: Context, mangaId: Long, chapterNumber: Double) = coroutineScope {
         launchNonCancellable {
             val tracks = getTracks.await(mangaId)
-
             if (tracks.isEmpty()) return@launchNonCancellable
 
             tracks.mapNotNull { track ->
                 val service = trackManager.getService(track.syncId)
-                if (service != null && service.isLogged && chapterNumber > track.lastChapterRead) {
-                    val updatedTrack = track.copy(lastChapterRead = chapterNumber)
+                if (service == null || !service.isLoggedIn || chapterNumber <= track.lastChapterRead) {
+                    return@mapNotNull null
+                }
 
-                    async {
-                        runCatching {
-                            try {
-                                service.update(updatedTrack.toDbTrack(), true)
-                                insertTrack.await(updatedTrack)
-                            } catch (e: Exception) {
-                                delayedTrackingStore.addItem(updatedTrack)
-                                DelayedTrackingUpdateJob.setupTask(context)
-                                throw e
-                            }
+                val updatedTrack = track.copy(lastChapterRead = chapterNumber)
+                async {
+                    runCatching {
+                        try {
+                            service.update(updatedTrack.toDbTrack(), true)
+                            insertTrack.await(updatedTrack)
+                        } catch (e: Exception) {
+                            delayedTrackingStore.addItem(updatedTrack)
+                            DelayedTrackingUpdateJob.setupTask(context)
+                            throw e
                         }
                     }
-                } else {
-                    null
                 }
             }
                 .awaitAll()
                 .mapNotNull { it.exceptionOrNull() }
-                .forEach { logcat(LogPriority.INFO, it) }
+                .forEach { logcat(LogPriority.WARN, it) }
         }
     }
 }

app/src/main/java/eu/kanade/domain/track/service/DelayedTrackingUpdateJob.kt

@@ -48,7 +48,7 @@ class DelayedTrackingUpdateJob(context: Context, workerParams: WorkerParameters)
                 .forEach { track ->
                     try {
                         val service = trackManager.getService(track.syncId)
-                        if (service != null && service.isLogged) {
+                        if (service != null && service.isLoggedIn) {
                             logcat(LogPriority.DEBUG) { "Updating delayed track item: ${track.id}, last chapter read: ${track.lastChapterRead}" }
                             service.update(track.toDbTrack(), true)
                             insertTrack.await(track)