Update MDList tracker with the new tracker changes, also library update may be a bit faster

app/src/main/java/eu/kanade/tachiyomi/data/library/LibraryUpdateService.kt

@@ -6,7 +6,6 @@ import android.content.Intent
 import android.os.IBinder
 import android.os.PowerManager
 import androidx.core.content.ContextCompat
-import com.elvishew.xlog.XLog
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.database.DatabaseHelper
@@ -33,7 +32,7 @@ import eu.kanade.tachiyomi.ui.library.LibraryGroup
 import eu.kanade.tachiyomi.ui.manga.track.TrackItem
 import eu.kanade.tachiyomi.util.chapter.NoChaptersException
 import eu.kanade.tachiyomi.util.chapter.syncChaptersWithSource
-import eu.kanade.tachiyomi.util.lang.awaitSingle
+import eu.kanade.tachiyomi.util.lang.await
 import eu.kanade.tachiyomi.util.lang.runAsObservable
 import eu.kanade.tachiyomi.util.prepUpdateCover
 import eu.kanade.tachiyomi.util.shouldDownloadNewChapters
@@ -48,7 +47,6 @@ import exh.md.utils.MdUtil
 import exh.metadata.metadata.base.insertFlatMetadata
 import exh.source.getMainSource
 import exh.util.nullIfBlank
-import kotlinx.coroutines.runBlocking
 import rx.Observable
 import rx.Subscription
 import rx.schedulers.Schedulers
@@ -455,29 +453,33 @@ class LibraryUpdateService(
                 .subscribe()
         }
 
-        return (
-            /* SY --> */ if (source is MergedSource) runAsObservable({ source.fetchChaptersAndSync(manga, false) })
-            else /* SY <-- */ runAsObservable({
-                source.getChapterList(manga.toMangaInfo())
-                    .map { it.toSChapter() }
-            })
-                .map { syncChaptersWithSource(db, it, manga, source) }
         // SY -->
-            )
-            .doOnNext {
         if (source is MangaDex && trackManager.mdList.isLogged) {
-                    try {
+            runAsObservable({
-                        val tracks = db.getTracks(manga).executeAsBlocking()
+                val tracks = db.getTracks(manga).await()
-                        if (tracks.isEmpty() || tracks.all { it.sync_id != TrackManager.MDLIST }) {
+                if (tracks.isEmpty() || tracks.none { it.sync_id == TrackManager.MDLIST }) {
                     var track = trackManager.mdList.createInitialTracker(manga)
-                            track = runBlocking { trackManager.mdList.refresh(track).awaitSingle() }
+                    track = trackManager.mdList.refresh(track)
-                            db.insertTrack(track).executeAsBlocking()
+                    db.insertTrack(track).await()
-                        }
-                    } catch (e: Exception) {
-                        XLog.tag("LibraryUpdateService").e(e)
                 }
+            })
+                .onErrorResumeNext { Observable.just(Unit) }
+                .subscribeOn(Schedulers.io())
+                .subscribe()
         }
+        // SY <--
+
+
+        return runAsObservable({
+            // SY -->
+            if (source is MergedSource) {
+                source.fetchChaptersAndSync(manga, false)
+            } else {
+                val sourceChapters = source.getChapterList(manga.toMangaInfo())
+                    .map { it.toSChapter() }
+                syncChaptersWithSource(db, sourceChapters, manga, source)
             }
+        })
         // SY <--
     }
 

app/src/main/java/eu/kanade/tachiyomi/data/track/mdlist/MdList.kt

@@ -11,15 +11,12 @@ import eu.kanade.tachiyomi.data.track.TrackService
 import eu.kanade.tachiyomi.data.track.model.TrackSearch
 import eu.kanade.tachiyomi.source.model.SManga
 import eu.kanade.tachiyomi.util.lang.await
-import eu.kanade.tachiyomi.util.lang.runAsObservable
 import exh.md.utils.FollowStatus
 import exh.md.utils.MdUtil
 import exh.metadata.metadata.MangaDexSearchMetadata
 import exh.metadata.metadata.base.getFlatMetadataForManga
 import exh.metadata.metadata.base.insertFlatMetadata
 import exh.util.floor
-import kotlinx.coroutines.runBlocking
-import rx.Observable
 import uy.kohesive.injekt.injectLazy
 
 class MdList(private val context: Context, id: Int) : TrackService(id) {
@@ -48,16 +45,14 @@ class MdList(private val context: Context, id: Int) : TrackService(id) {
 
     override fun displayScore(track: Track) = track.score.toInt().toString()
 
-    override suspend fun add(track: Track): Track {
+    override suspend fun add(track: Track): Track = update(track)
-        return update(track)
-    }
 
     override suspend fun update(track: Track): Track {
         val mdex = mdex ?: throw Exception("Mangadex not enabled")
-        val manga = db.getManga(track.tracking_url.substringAfter(".org"), mdex.id).await() ?: throw Exception("Manga doesnt exist")
+        val mangaMetadata = db.getFlatMetadataForManga(track.manga_id).await()
-
+            ?.raise<MangaDexSearchMetadata>()
-        val mangaMetadata = db.getFlatMetadataForManga(manga.id!!).executeAsBlocking()?.raise(MangaDexSearchMetadata::class) ?: throw Exception("Invalid manga metadata")
+            ?: throw Exception("Invalid manga metadata")
-        val followStatus = FollowStatus.fromInt(track.status)!!
+        val followStatus = FollowStatus.fromInt(track.status) ?: throw Exception("Follow status was not a valid value")
 
         // allow follow status to update
         if (mangaMetadata.follow_status != followStatus.int) {
@@ -87,34 +82,16 @@ class MdList(private val context: Context, id: Int) : TrackService(id) {
 
     override fun getCompletionStatus(): Int = FollowStatus.COMPLETED.int
 
-    override fun bind(track: Track): Observable<Track> {
+    override suspend fun bind(track: Track): Track = update(refresh(track))
-        val mdex = mdex ?: throw Exception("Mangadex not enabled")
-        return runAsObservable({ mdex.fetchTrackingInfo(track.tracking_url) })
-            .doOnNext { remoteTrack ->
-                track.copyPersonalFrom(remoteTrack)
-                val manga = db.getManga(track.manga_id).executeAsBlocking()
-                track.total_chapters = if (manga != null && manga.status == SManga.COMPLETED && remoteTrack.total_chapters == 0) {
-                    db.getChapters(track.manga_id).executeAsBlocking().maxOfOrNull { it.chapter_number }?.floor() ?: remoteTrack.total_chapters
-                } else {
-                    remoteTrack.total_chapters
-                }
-                runBlocking { update(track) }
-            }
-    }
 
-    override fun refresh(track: Track): Observable<Track> {
+    override suspend fun refresh(track: Track): Track {
         val mdex = mdex ?: throw Exception("Mangadex not enabled")
-        return runAsObservable({ mdex.fetchTrackingInfo(track.tracking_url) })
+        val remoteTrack = mdex.fetchTrackingInfo(track.tracking_url)
-            .map { remoteTrack ->
         track.copyPersonalFrom(remoteTrack)
-                val manga = db.getManga(track.manga_id).executeAsBlocking()
+        if (track.total_chapters == 0 && db.getManga(track.manga_id).await()?.status == SManga.COMPLETED) {
-                track.total_chapters = if (manga != null && manga.status == SManga.COMPLETED && remoteTrack.total_chapters == 0) {
+            track.total_chapters = db.getChapters(track.manga_id).await().maxOfOrNull { it.chapter_number }?.floor() ?: 0
-                    db.getChapters(track.manga_id).executeAsBlocking().maxOfOrNull { it.chapter_number }?.floor() ?: remoteTrack.total_chapters
-                } else {
-                    remoteTrack.total_chapters
-                }
-                track
         }
+        return track
     }
 
     fun createInitialTracker(manga: Manga): Track {
@@ -126,7 +103,7 @@ class MdList(private val context: Context, id: Int) : TrackService(id) {
         return track
     }
 
-    override fun search(query: String): Observable<List<TrackSearch>> = throw Exception("not used")
+    override suspend fun search(query: String): List<TrackSearch> = throw Exception("not used")
 
     override suspend fun login(username: String, password: String): Unit = throw Exception("not used")
 }