Some more code cleanup

(cherry picked from commit cf6c48744a3217b39d7980c2c283a01d3f2a0473)

# Conflicts:
#	app/src/main/java/eu/kanade/tachiyomi/data/backup/AbstractBackupRestore.kt
#	app/src/main/java/eu/kanade/tachiyomi/data/backup/full/FullBackupManager.kt
#	app/src/main/java/eu/kanade/tachiyomi/data/backup/full/FullBackupRestore.kt
#	app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/LegacyBackupManager.kt
#	app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/LegacyBackupRestore.kt

app/src/main/java/eu/kanade/tachiyomi/data/backup/AbstractBackupManager.kt

@@ -7,10 +7,16 @@ import eu.kanade.tachiyomi.data.database.models.Chapter
 import eu.kanade.tachiyomi.data.database.models.Manga
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.data.track.TrackManager
+import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.SourceManager
+import eu.kanade.tachiyomi.source.online.all.EHentai
+import eu.kanade.tachiyomi.util.chapter.syncChaptersWithSource
+import exh.eh.EHentaiThrottleManager
+import rx.Observable
 import uy.kohesive.injekt.injectLazy
 
 abstract class AbstractBackupManager(protected val context: Context) {
+
     internal val databaseHelper: DatabaseHelper by injectLazy()
     internal val sourceManager: SourceManager by injectLazy()
     internal val trackManager: TrackManager by injectLazy()
@@ -26,6 +32,32 @@ abstract class AbstractBackupManager(protected val context: Context) {
     internal fun getMangaFromDatabase(manga: Manga): Manga? =
         databaseHelper.getManga(manga.url, manga.source).executeAsBlocking()
 
+    /**
+     * [Observable] that fetches chapter information
+     *
+     * @param source source of manga
+     * @param manga manga that needs updating
+     * @param chapters list of chapters in the backup
+     * @return [Observable] that contains manga
+     */
+    internal open fun restoreChapterFetchObservable(source: Source, manga: Manga, chapters: List<Chapter>, throttleManager: EHentaiThrottleManager): Observable<Pair<List<Chapter>, List<Chapter>>> {
+        return (
+            if (source is EHentai) {
+                source.fetchChapterList(manga, throttleManager::throttle)
+            } else {
+                source.fetchChapterList(manga)
+            }
+            ).map {
+            syncChaptersWithSource(databaseHelper, it, manga, source)
+        }
+            .doOnNext { pair ->
+                if (pair.first.isNotEmpty()) {
+                    chapters.forEach { it.manga_id = manga.id }
+                    updateChapters(chapters)
+                }
+            }
+    }
+
     /**
      * Returns list containing manga from library
      *

app/src/main/java/eu/kanade/tachiyomi/data/backup/AbstractBackupRestore.kt

@@ -2,21 +2,30 @@ package eu.kanade.tachiyomi.data.backup
 
 import android.content.Context
 import android.net.Uri
+import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.database.DatabaseHelper
+import eu.kanade.tachiyomi.data.database.models.Chapter
+import eu.kanade.tachiyomi.data.database.models.Manga
+import eu.kanade.tachiyomi.data.database.models.Track
 import eu.kanade.tachiyomi.data.track.TrackManager
+import eu.kanade.tachiyomi.source.Source
+import eu.kanade.tachiyomi.util.chapter.NoChaptersException
 import exh.eh.EHentaiThrottleManager
 import kotlinx.coroutines.Job
+import rx.Observable
 import uy.kohesive.injekt.injectLazy
 import java.io.File
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
 
-abstract class AbstractBackupRestore(protected val context: Context, protected val notifier: BackupNotifier) {
+abstract class AbstractBackupRestore<T : AbstractBackupManager>(protected val context: Context, protected val notifier: BackupNotifier) {
-    protected val db: DatabaseHelper by injectLazy()
 
+    protected val db: DatabaseHelper by injectLazy()
     protected val trackManager: TrackManager by injectLazy()
 
+    protected lateinit var backupManager: T
+
     var job: Job? = null
 
     // SY -->
@@ -48,7 +57,7 @@ abstract class AbstractBackupRestore(protected val context: Context, protected v
     /**
      * Write errors to error log
      */
-    fun writeErrorLog(): File {
+    internal fun writeErrorLog(): File {
         try {
             if (errors.isNotEmpty()) {
                 val destFile = File(context.externalCacheDir, "tachiyomi_restore.txt")
@@ -66,4 +75,64 @@ abstract class AbstractBackupRestore(protected val context: Context, protected v
         }
         return File("")
     }
+
+    /**
+     * [Observable] that fetches chapter information
+     *
+     * @param source source of manga
+     * @param manga manga that needs updating
+     * @return [Observable] that contains manga
+     */
+    internal fun chapterFetchObservable(source: Source, manga: Manga, chapters: List<Chapter>): Observable<Pair<List<Chapter>, List<Chapter>>> {
+        return backupManager.restoreChapterFetchObservable(source, manga, chapters /* SY --> */, throttleManager /* SY <-- */)
+            // If there's any error, return empty update and continue.
+            .onErrorReturn {
+                val errorMessage = if (it is NoChaptersException) {
+                    context.getString(R.string.no_chapters_error)
+                } else {
+                    it.message
+                }
+                errors.add(Date() to "${manga.title} - $errorMessage")
+                Pair(emptyList(), emptyList())
+            }
+    }
+
+    /**
+     * [Observable] that refreshes tracking information
+     * @param manga manga that needs updating.
+     * @param tracks list containing tracks from restore file.
+     * @return [Observable] that contains updated track item
+     */
+    internal fun trackingFetchObservable(manga: Manga, tracks: List<Track>): Observable<Track> {
+        return Observable.from(tracks)
+            .flatMap { track ->
+                val service = trackManager.getService(track.sync_id)
+                if (service != null && service.isLogged) {
+                    service.refresh(track)
+                        .doOnNext { db.insertTrack(it).executeAsBlocking() }
+                        .onErrorReturn {
+                            errors.add(Date() to "${manga.title} - ${it.message}")
+                            track
+                        }
+                } else {
+                    errors.add(Date() to "${manga.title} - ${context.getString(R.string.tracker_not_logged_in, service?.name)}")
+                    Observable.empty()
+                }
+            }
+    }
+
+    /**
+     * Called to update dialog in [BackupConst]
+     *
+     * @param progress restore progress
+     * @param amount total restoreAmount of manga
+     * @param title title of restored manga
+     */
+    internal fun showRestoreProgress(
+        progress: Int,
+        amount: Int,
+        title: String
+    ) {
+        notifier.showRestoreProgress(title, progress, amount)
+    }
 }

app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupRestoreService.kt

@@ -68,7 +68,7 @@ class BackupRestoreService : Service() {
      */
     private lateinit var wakeLock: PowerManager.WakeLock
 
-    private var backupRestore: AbstractBackupRestore? = null
+    private var backupRestore: AbstractBackupRestore<*>? = null
     private lateinit var notifier: BackupNotifier
 
     override fun onCreate() {

app/src/main/java/eu/kanade/tachiyomi/data/backup/full/FullBackupManager.kt

@@ -31,11 +31,8 @@ import eu.kanade.tachiyomi.data.database.models.MangaCategory
 import eu.kanade.tachiyomi.data.database.models.Track
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.online.MetadataSource
-import eu.kanade.tachiyomi.source.online.all.EHentai
 import eu.kanade.tachiyomi.source.online.all.MergedSource
-import eu.kanade.tachiyomi.util.chapter.syncChaptersWithSource
 import exh.MERGED_SOURCE_ID
-import exh.eh.EHentaiThrottleManager
 import exh.metadata.metadata.base.getFlatMetadataForManga
 import exh.metadata.metadata.base.insertFlatMetadata
 import exh.savedsearches.JsonSavedSearch
@@ -264,35 +261,6 @@ class FullBackupManager(context: Context) : AbstractBackupManager(context) {
         }
     }
 
-    /**
-     * [Observable] that fetches chapter information
-     *
-     * @param source source of manga
-     * @param manga manga that needs updating
-     * @param chapters list of chapters in the backup
-     * @param throttleManager e-hentai throttle so it doesnt get banned
-     * @return [Observable] that contains manga
-     */
-    fun restoreChapterFetchObservable(source: Source, manga: Manga, chapters: List<Chapter> /* SY --> */, throttleManager: EHentaiThrottleManager /* SY <-- */): Observable<Pair<List<Chapter>, List<Chapter>>> {
-        // SY -->
-        return (
-            if (source is EHentai) {
-                source.fetchChapterList(manga, throttleManager::throttle)
-            } else {
-                source.fetchChapterList(manga)
-            }
-            ).map {
-            syncChaptersWithSource(databaseHelper, it, manga, source)
-        }
-            // SY <--
-            .doOnNext { pair ->
-                if (pair.first.isNotEmpty()) {
-                    chapters.forEach { it.manga_id = manga.id }
-                    updateChapters(chapters)
-                }
-            }
-    }
-
     /**
      * Restore the categories from Json
      *

app/src/main/java/eu/kanade/tachiyomi/data/backup/full/FullBackupRestore.kt

@@ -17,7 +17,6 @@ import eu.kanade.tachiyomi.data.database.models.Manga
 import eu.kanade.tachiyomi.data.database.models.Track
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.online.all.MergedSource
-import eu.kanade.tachiyomi.util.chapter.NoChaptersException
 import exh.EXHMigrations
 import exh.MERGED_SOURCE_ID
 import kotlinx.serialization.ExperimentalSerializationApi
@@ -28,8 +27,7 @@ import rx.Observable
 import java.util.Date
 
 @OptIn(ExperimentalSerializationApi::class)
-class FullBackupRestore(context: Context, notifier: BackupNotifier, private val online: Boolean) : AbstractBackupRestore(context, notifier) {
+class FullBackupRestore(context: Context, notifier: BackupNotifier, private val online: Boolean) : AbstractBackupRestore<FullBackupManager>(context, notifier) {
-    private lateinit var fullBackupManager: FullBackupManager
 
     /**
      * Restores data from backup file.
@@ -43,10 +41,10 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
         val startTime = System.currentTimeMillis()
 
         // Initialize manager
-        fullBackupManager = FullBackupManager(context)
+        backupManager = FullBackupManager(context)
 
         val backupString = context.contentResolver.openInputStream(uri)!!.source().gzip().buffer().use { it.readByteArray() }
-        val backup = fullBackupManager.parser.decodeFromByteArray(BackupSerializer, backupString)
+        val backup = backupManager.parser.decodeFromByteArray(BackupSerializer, backupString)
 
         restoreAmount = backup.backupManga.size + 1 /* SY --> */ + 1 /* SY <-- */ // +1 for categories, +1 for saved searches
         restoreProgress = 0
@@ -86,7 +84,7 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
 
     private fun restoreCategories(backupCategories: List<BackupCategory>) {
         db.inTransaction {
-            fullBackupManager.restoreCategories(backupCategories)
+            backupManager.restoreCategories(backupCategories)
         }
 
         restoreProgress += 1
@@ -95,7 +93,7 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
 
     // SY -->
     private fun restoreSavedSearches(backupSavedSearches: List<BackupSavedSearch>) {
-        fullBackupManager.restoreSavedSearches(backupSavedSearches)
+        backupManager.restoreSavedSearches(backupSavedSearches)
 
         restoreProgress += 1
         showRestoreProgress(restoreProgress, restoreAmount, context.getString(R.string.saved_searches))
@@ -118,7 +116,7 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
         // SY <--
 
         try {
-            val source = fullBackupManager.sourceManager.get(manga.source)
+            val source = backupManager.sourceManager.get(manga.source)
             if (source != null || !online) {
                 restoreMangaData(manga, source, chapters, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata, online)
             } else {
@@ -155,7 +153,7 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
         flatMetadata: BackupFlatMetadata?,
         online: Boolean
     ) {
-        val dbManga = fullBackupManager.getMangaFromDatabase(manga)
+        val dbManga = backupManager.getMangaFromDatabase(manga)
 
         db.inTransaction {
             if (dbManga == null) {
@@ -163,7 +161,7 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
                 restoreMangaFetch(source, manga, chapters, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata, online)
             } else { // Manga in database
                 // Copy information from manga already in database
-                fullBackupManager.restoreMangaNoFetch(manga, dbManga)
+                backupManager.restoreMangaNoFetch(manga, dbManga)
                 // Fetch rest of manga information
                 restoreMangaNoFetch(source, manga, chapters, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata, online)
             }
@@ -189,7 +187,7 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
         flatMetadata: BackupFlatMetadata?,
         online: Boolean
     ) {
-        fullBackupManager.restoreMangaFetchObservable(source, manga, online)
+        backupManager.restoreMangaFetchObservable(source, manga, online)
             .doOnError {
                 errors.add(Date() to "${manga.title} - ${it.message}")
             }
@@ -206,7 +204,7 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
                     }
                     // SY <--
                 } else {
-                    fullBackupManager.restoreChaptersForMangaOffline(it, chapters)
+                    backupManager.restoreChaptersForMangaOffline(it, chapters)
                     Observable.just(manga)
                 }
             }
@@ -234,14 +232,14 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
         Observable.just(backupManga)
             .flatMap { manga ->
                 if (online && source != null) {
-                    if (/* SY --> */ source !is MergedSource && /* SY <-- */ !fullBackupManager.restoreChaptersForManga(manga, chapters)) {
+                    if (/* SY --> */ source !is MergedSource && /* SY <-- */ !backupManager.restoreChaptersForManga(manga, chapters)) {
                         chapterFetchObservable(source, manga, chapters)
                             .map { manga }
                     } else {
                         Observable.just(manga)
                     }
                 } else {
-                    fullBackupManager.restoreChaptersForMangaOffline(manga, chapters)
+                    backupManager.restoreChaptersForMangaOffline(manga, chapters)
                     Observable.just(manga)
                 }
             }
@@ -256,80 +254,20 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
 
     private fun restoreExtraForManga(manga: Manga, categories: List<Int>, history: List<BackupHistory>, tracks: List<Track>, backupCategories: List<BackupCategory>, mergedMangaReferences: List<BackupMergedMangaReference>, flatMetadata: BackupFlatMetadata?) {
         // Restore categories
-        fullBackupManager.restoreCategoriesForManga(manga, categories, backupCategories)
+        backupManager.restoreCategoriesForManga(manga, categories, backupCategories)
 
         // Restore history
-        fullBackupManager.restoreHistoryForManga(history)
+        backupManager.restoreHistoryForManga(history)
 
         // Restore tracking
-        fullBackupManager.restoreTrackForManga(manga, tracks)
+        backupManager.restoreTrackForManga(manga, tracks)
 
         // SY -->
         // Restore merged manga references if its a merged manga
-        fullBackupManager.restoreMergedMangaReferencesForManga(manga, mergedMangaReferences)
+        backupManager.restoreMergedMangaReferencesForManga(manga, mergedMangaReferences)
 
         // Restore flat metadata for metadata sources
-        flatMetadata?.let { fullBackupManager.restoreFlatMetadata(manga, it) }
+        flatMetadata?.let { backupManager.restoreFlatMetadata(manga, it) }
         // SY <--
     }
-
-    /**
-     * [Observable] that fetches chapter information
-     *
-     * @param source source of manga
-     * @param manga manga that needs updating
-     * @return [Observable] that contains manga
-     */
-    private fun chapterFetchObservable(source: Source, manga: Manga, chapters: List<Chapter>): Observable<Pair<List<Chapter>, List<Chapter>>> {
-        return fullBackupManager.restoreChapterFetchObservable(source, manga, chapters /* SY --> */, throttleManager /* SY <-- */)
-            // If there's any error, return empty update and continue.
-            .onErrorReturn {
-                val errorMessage = if (it is NoChaptersException) {
-                    context.getString(R.string.no_chapters_error)
-                } else {
-                    it.message
-                }
-                errors.add(Date() to "${manga.title} - $errorMessage")
-                Pair(emptyList(), emptyList())
-            }
-    }
-
-    /**
-     * [Observable] that refreshes tracking information
-     * @param manga manga that needs updating.
-     * @param tracks list containing tracks from restore file.
-     * @return [Observable] that contains updated track item
-     */
-    private fun trackingFetchObservable(manga: Manga, tracks: List<Track>): Observable<Track> {
-        return Observable.from(tracks)
-            .flatMap { track ->
-                val service = trackManager.getService(track.sync_id)
-                if (service != null && service.isLogged) {
-                    service.refresh(track)
-                        .doOnNext { db.insertTrack(it).executeAsBlocking() }
-                        .onErrorReturn {
-                            errors.add(Date() to "${manga.title} - ${it.message}")
-                            track
-                        }
-                } else {
-                    errors.add(Date() to "${manga.title} - ${context.getString(R.string.tracker_not_logged_in, service?.name)}")
-                    Observable.empty()
-                }
-            }
-    }
-
-    /**
-     * Called to update dialog in [BackupConst]
-     *
-     * @param progress restore progress
-     * @param amount total restoreAmount of manga
-     * @param title title of restored manga
-     */
-    private fun showRestoreProgress(
-        progress: Int,
-        amount: Int,
-        title: String
-    ) {
-        notifier.showRestoreProgress(title, progress, amount)
-    }
 }

app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/LegacyBackupManager.kt

@@ -12,6 +12,7 @@ import com.google.gson.JsonArray
 import com.google.gson.JsonElement
 import com.google.gson.JsonObject
 import com.hippo.unifile.UniFile
+import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.backup.AbstractBackupManager
 import eu.kanade.tachiyomi.data.backup.BackupCreateService.Companion.BACKUP_CATEGORY
 import eu.kanade.tachiyomi.data.backup.BackupCreateService.Companion.BACKUP_CATEGORY_MASK
@@ -50,9 +51,7 @@ import eu.kanade.tachiyomi.data.database.models.TrackImpl
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.source.LocalSource
 import eu.kanade.tachiyomi.source.Source
-import eu.kanade.tachiyomi.source.online.all.EHentai
 import eu.kanade.tachiyomi.source.online.all.MergedSource
-import eu.kanade.tachiyomi.util.chapter.syncChaptersWithSource
 import eu.kanade.tachiyomi.util.lang.asObservable
 import exh.MERGED_SOURCE_ID
 import exh.eh.EHentaiThrottleManager
@@ -71,10 +70,8 @@ import java.lang.RuntimeException
 import kotlin.math.max
 
 class LegacyBackupManager(context: Context, version: Int = CURRENT_VERSION) : AbstractBackupManager(context) {
-    /**
+
-     * Version of parser
+    var parserVersion: Int = version
-     */
-    var version: Int = version
         private set
 
     var parser: Gson = initParser()
@@ -85,11 +82,11 @@ class LegacyBackupManager(context: Context, version: Int = CURRENT_VERSION) : Ab
      * @param version version of parser
      */
     internal fun setVersion(version: Int) {
-        this.version = version
+        this.parserVersion = version
         parser = initParser()
     }
 
-    private fun initParser(): Gson = when (version) {
+    private fun initParser(): Gson = when (parserVersion) {
         2 ->
             GsonBuilder()
                 .registerTypeAdapter<MangaImpl>(MangaTypeAdapter.build())
@@ -317,31 +314,18 @@ class LegacyBackupManager(context: Context, version: Int = CURRENT_VERSION) : Ab
      * @param manga manga that needs updating
      * @return [Observable] that contains manga
      */
-    fun restoreChapterFetchObservable(source: Source, manga: Manga, chapters: List<Chapter>, throttleManager: EHentaiThrottleManager): Observable<Pair<List<Chapter>, List<Chapter>>> {
+    override fun restoreChapterFetchObservable(source: Source, manga: Manga, chapters: List<Chapter>, throttleManager: EHentaiThrottleManager): Observable<Pair<List<Chapter>, List<Chapter>>> {
         // SY -->
-        if (source is MergedSource) {
+        return if (source is MergedSource) {
             val syncedChapters = runBlocking { source.fetchChaptersAndSync(manga, false) }
-            return syncedChapters.onEach { pair ->
+            syncedChapters.onEach { pair ->
                 if (pair.first.isNotEmpty()) {
                     chapters.forEach { it.manga_id = manga.id }
                     updateChapters(chapters)
                 }
             }.asObservable()
         } else {
-            return (
+            super.restoreChapterFetchObservable(source, manga, chapters, throttleManager)
-                if (source is EHentai) {
-                    source.fetchChapterList(manga, throttleManager::throttle)
-                } else {
-                    source.fetchChapterList(manga)
-                }
-                ).map { syncChaptersWithSource(databaseHelper, it, manga, source) }
-                // SY <--
-                .doOnNext { pair ->
-                    if (pair.first.isNotEmpty()) {
-                        chapters.forEach { it.manga_id = manga.id }
-                        updateChapters(chapters)
-                    }
-                }
         }
     }
 

app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/LegacyBackupRestore.kt

@@ -10,7 +10,6 @@ import com.google.gson.JsonParser
 import com.google.gson.stream.JsonReader
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.backup.AbstractBackupRestore
-import eu.kanade.tachiyomi.data.backup.BackupConst
 import eu.kanade.tachiyomi.data.backup.BackupNotifier
 import eu.kanade.tachiyomi.data.backup.legacy.models.Backup
 import eu.kanade.tachiyomi.data.backup.legacy.models.Backup.MANGAS
@@ -22,14 +21,11 @@ import eu.kanade.tachiyomi.data.database.models.MangaImpl
 import eu.kanade.tachiyomi.data.database.models.Track
 import eu.kanade.tachiyomi.data.database.models.TrackImpl
 import eu.kanade.tachiyomi.source.Source
-import eu.kanade.tachiyomi.util.chapter.NoChaptersException
 import exh.EXHMigrations
 import rx.Observable
 import java.util.Date
 
-class LegacyBackupRestore(context: Context, notifier: BackupNotifier) : AbstractBackupRestore(context, notifier) {
+class LegacyBackupRestore(context: Context, notifier: BackupNotifier) : AbstractBackupRestore<LegacyBackupManager>(context, notifier) {
-
-    private lateinit var backupManager: LegacyBackupManager
 
     /**
      * Restores data from backup file.
@@ -261,64 +257,4 @@ class LegacyBackupRestore(context: Context, notifier: BackupNotifier) : Abstract
         // Restore tracking
         backupManager.restoreTrackForManga(manga, tracks)
     }
-
-    /**
-     * [Observable] that fetches chapter information
-     *
-     * @param source source of manga
-     * @param manga manga that needs updating
-     * @return [Observable] that contains manga
-     */
-    private fun chapterFetchObservable(source: Source, manga: Manga, chapters: List<Chapter>): Observable<Pair<List<Chapter>, List<Chapter>>> {
-        return backupManager.restoreChapterFetchObservable(source, manga, chapters /* SY --> */, throttleManager /* SY <-- */)
-            // If there's any error, return empty update and continue.
-            .onErrorReturn {
-                val errorMessage = if (it is NoChaptersException) {
-                    context.getString(R.string.no_chapters_error)
-                } else {
-                    it.message
-                }
-                errors.add(Date() to "${manga.title} - $errorMessage")
-                Pair(emptyList(), emptyList())
-            }
-    }
-
-    /**
-     * [Observable] that refreshes tracking information
-     * @param manga manga that needs updating.
-     * @param tracks list containing tracks from restore file.
-     * @return [Observable] that contains updated track item
-     */
-    private fun trackingFetchObservable(manga: Manga, tracks: List<Track>): Observable<Track> {
-        return Observable.from(tracks)
-            .flatMap { track ->
-                val service = trackManager.getService(track.sync_id)
-                if (service != null && service.isLogged) {
-                    service.refresh(track)
-                        .doOnNext { db.insertTrack(it).executeAsBlocking() }
-                        .onErrorReturn {
-                            errors.add(Date() to "${manga.title} - ${it.message}")
-                            track
-                        }
-                } else {
-                    errors.add(Date() to "${manga.title} - ${context.getString(R.string.tracker_not_logged_in, service?.name)}")
-                    Observable.empty()
-                }
-            }
-    }
-
-    /**
-     * Called to update dialog in [BackupConst]
-     *
-     * @param progress restore progress
-     * @param amount total restoreAmount of manga
-     * @param title title of restored manga
-     */
-    private fun showRestoreProgress(
-        progress: Int,
-        amount: Int,
-        title: String
-    ) {
-        notifier.showRestoreProgress(title, progress, amount)
-    }
 }