Tracker-related cleanup

2025-11-12 03:58:56 +01:00 · 2023-09-25 23:22:16 -04:00
parent 86edce0d87
commit c8e226acb2
54 changed files with 417 additions and 395 deletions
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/search/MigrateDialog.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/search/MigrateDialog.kt
@@ -35,8 +35,8 @@ import eu.kanade.domain.manga.model.toSManga
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.download.DownloadManager
-import eu.kanade.tachiyomi.data.track.EnhancedTrackService
-import eu.kanade.tachiyomi.data.track.TrackManager
+import eu.kanade.tachiyomi.data.track.EnhancedTracker
+import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.ui.browse.migration.MigrationFlags
@@ -177,7 +177,7 @@ internal class MigrateDialogScreenModel(
    }

    private val enhancedServices by lazy {
-        Injekt.get<TrackManager>().services.filterIsInstance<EnhancedTrackService>()
+        Injekt.get<TrackerManager>().trackers.filterIsInstance<EnhancedTracker>()
    }

    suspend fun migrateManga(
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/source/browse/BrowseSourceScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/source/browse/BrowseSourceScreenModel.kt
@@ -15,16 +15,12 @@ import cafe.adriel.voyager.core.model.StateScreenModel
 import cafe.adriel.voyager.core.model.coroutineScope
 import eu.kanade.core.preference.asState
 import eu.kanade.domain.base.BasePreferences
-import eu.kanade.domain.chapter.interactor.SyncChapterProgressWithTrack
 import eu.kanade.domain.manga.interactor.UpdateManga
 import eu.kanade.domain.manga.model.toDomainManga
 import eu.kanade.domain.source.service.SourcePreferences
-import eu.kanade.domain.track.model.toDomainTrack
+import eu.kanade.domain.track.interactor.AddTracks
 import eu.kanade.presentation.util.ioCoroutineScope
 import eu.kanade.tachiyomi.data.cache.CoverCache
-import eu.kanade.tachiyomi.data.track.EnhancedTrackService
-import eu.kanade.tachiyomi.data.track.TrackManager
-import eu.kanade.tachiyomi.data.track.TrackService
 import eu.kanade.tachiyomi.source.CatalogueSource
 import eu.kanade.tachiyomi.source.model.FilterList
 import eu.kanade.tachiyomi.util.removeCovers
@@ -37,11 +33,9 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
-import logcat.LogPriority
 import tachiyomi.core.preference.CheckboxState
 import tachiyomi.core.preference.mapAsCheckboxState
 import tachiyomi.core.util.lang.launchIO
-import tachiyomi.core.util.system.logcat
 import tachiyomi.domain.category.interactor.GetCategories
 import tachiyomi.domain.category.interactor.SetMangaCategories
 import tachiyomi.domain.category.model.Category
@@ -54,7 +48,6 @@ import tachiyomi.domain.manga.model.Manga
 import tachiyomi.domain.manga.model.toMangaUpdate
 import tachiyomi.domain.source.interactor.GetRemoteManga
 import tachiyomi.domain.source.service.SourceManager
-import tachiyomi.domain.track.interactor.InsertTrack
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.util.Date
@@ -76,12 +69,9 @@ class BrowseSourceScreenModel(
    private val getManga: GetManga = Injekt.get(),
    private val networkToLocalManga: NetworkToLocalManga = Injekt.get(),
    private val updateManga: UpdateManga = Injekt.get(),
-    private val insertTrack: InsertTrack = Injekt.get(),
-    private val syncChapterProgressWithTrack: SyncChapterProgressWithTrack = Injekt.get(),
+    private val addTracks: AddTracks = Injekt.get(),
 ) : StateScreenModel<BrowseSourceScreenModel.State>(State(Listing.valueOf(listingQuery))) {

-    private val loggedServices by lazy { Injekt.get<TrackManager>().services.filter { it.isLoggedIn } }
-
    var displayMode by sourcePreferences.sourceDisplayMode().asState(coroutineScope)

    val source = sourceManager.getOrStub(sourceId)
@@ -243,8 +233,7 @@ class BrowseSourceScreenModel(
                new = new.removeCovers(coverCache)
            } else {
                setMangaDefaultChapterFlags.await(manga)
-
-                autoAddTrack(manga)
+                addTracks.bindEnhancedTracks(manga, source)
            }

            updateManga.await(new.toMangaUpdate())
@@ -281,25 +270,6 @@ class BrowseSourceScreenModel(
        }
    }

-    private suspend fun autoAddTrack(manga: Manga) {
-        loggedServices
-            .filterIsInstance<EnhancedTrackService>()
-            .filter { it.accept(source) }
-            .forEach { service ->
-                try {
-                    service.match(manga)?.let { track ->
-                        track.manga_id = manga.id
-                        (service as TrackService).bind(track)
-                        insertTrack.await(track.toDomainTrack()!!)
-
-                        syncChapterProgressWithTrack.await(manga.id, track.toDomainTrack()!!, service)
-                    }
-                } catch (e: Exception) {
-                    logcat(LogPriority.WARN, e) { "Could not match manga: ${manga.title} with service $service" }
-                }
-            }
-    }
-
    /**
     * Get user categories.
     *
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryScreenModel.kt
@@ -23,7 +23,7 @@ import eu.kanade.presentation.manga.DownloadAction
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.download.DownloadCache
 import eu.kanade.tachiyomi.data.download.DownloadManager
-import eu.kanade.tachiyomi.data.track.TrackManager
+import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.source.model.SManga
 import eu.kanade.tachiyomi.source.online.HttpSource
 import eu.kanade.tachiyomi.util.chapter.getNextUnread
@@ -88,7 +88,7 @@ class LibraryScreenModel(
    private val sourceManager: SourceManager = Injekt.get(),
    private val downloadManager: DownloadManager = Injekt.get(),
    private val downloadCache: DownloadCache = Injekt.get(),
-    private val trackManager: TrackManager = Injekt.get(),
+    private val trackerManager: TrackerManager = Injekt.get(),
 ) : StateScreenModel<LibraryScreenModel.State>(State()) {

    var activeCategoryIndex: Int by libraryPreferences.lastUsedCategory().asState(coroutineScope)
@@ -101,9 +101,9 @@ class LibraryScreenModel(
                getTracksPerManga.subscribe(),
                getTrackingFilterFlow(),
                downloadCache.changes,
-            ) { searchQuery, library, tracks, loggedInTrackServices, _ ->
+            ) { searchQuery, library, tracks, loggedInTrackers, _ ->
                library
-                    .applyFilters(tracks, loggedInTrackServices)
+                    .applyFilters(tracks, loggedInTrackers)
                    .applySort()
                    .mapValues { (_, value) ->
                        if (searchQuery != null) {
@@ -169,7 +169,7 @@ class LibraryScreenModel(
     */
    private suspend fun LibraryMap.applyFilters(
        trackMap: Map<Long, List<Long>>,
-        loggedInTrackServices: Map<Long, TriState>,
+        loggedInTrackers: Map<Long, TriState>,
    ): LibraryMap {
        val prefs = getLibraryItemPreferencesFlow().first()
        val downloadedOnly = prefs.globalFilterDownloaded
@@ -180,10 +180,10 @@ class LibraryScreenModel(
        val filterBookmarked = prefs.filterBookmarked
        val filterCompleted = prefs.filterCompleted

-        val isNotLoggedInAnyTrack = loggedInTrackServices.isEmpty()
+        val isNotLoggedInAnyTrack = loggedInTrackers.isEmpty()

-        val excludedTracks = loggedInTrackServices.mapNotNull { if (it.value == TriState.ENABLED_NOT) it.key else null }
-        val includedTracks = loggedInTrackServices.mapNotNull { if (it.value == TriState.ENABLED_IS) it.key else null }
+        val excludedTracks = loggedInTrackers.mapNotNull { if (it.value == TriState.ENABLED_NOT) it.key else null }
+        val includedTracks = loggedInTrackers.mapNotNull { if (it.value == TriState.ENABLED_IS) it.key else null }
        val trackFiltersIsIgnored = includedTracks.isEmpty() && excludedTracks.isEmpty()

        val filterFnDownloaded: (LibraryItem) -> Boolean = {
@@ -366,14 +366,14 @@ class LibraryScreenModel(
     * @return map of track id with the filter value
     */
    private fun getTrackingFilterFlow(): Flow<Map<Long, TriState>> {
-        val loggedServices = trackManager.services.filter { it.isLoggedIn }
-        return if (loggedServices.isNotEmpty()) {
-            val prefFlows = loggedServices
+        val loggedInTrackers = trackerManager.trackers.filter { it.isLoggedIn }
+        return if (loggedInTrackers.isNotEmpty()) {
+            val prefFlows = loggedInTrackers
                .map { libraryPreferences.filterTracking(it.id.toInt()).changes() }
                .toTypedArray()
            combine(*prefFlows) {
-                loggedServices
-                    .mapIndexed { index, trackService -> trackService.id to it[index] }
+                loggedInTrackers
+                    .mapIndexed { index, tracker -> tracker.id to it[index] }
                    .toMap()
            }
        } else {
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/library/LibrarySettingsScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/library/LibrarySettingsScreenModel.kt
@@ -3,7 +3,7 @@ package eu.kanade.tachiyomi.ui.library
 import cafe.adriel.voyager.core.model.ScreenModel
 import cafe.adriel.voyager.core.model.coroutineScope
 import eu.kanade.domain.base.BasePreferences
-import eu.kanade.tachiyomi.data.track.TrackManager
+import eu.kanade.tachiyomi.data.track.TrackerManager
 import tachiyomi.core.preference.Preference
 import tachiyomi.core.preference.TriState
 import tachiyomi.core.preference.getAndSet
@@ -22,11 +22,11 @@ class LibrarySettingsScreenModel(
    val libraryPreferences: LibraryPreferences = Injekt.get(),
    private val setDisplayMode: SetDisplayMode = Injekt.get(),
    private val setSortModeForCategory: SetSortModeForCategory = Injekt.get(),
-    private val trackManager: TrackManager = Injekt.get(),
+    private val trackerManager: TrackerManager = Injekt.get(),
 ) : ScreenModel {

-    val trackServices
-        get() = trackManager.services.filter { it.isLoggedIn }
+    val trackers
+        get() = trackerManager.trackers.filter { it.isLoggedIn }

    fun toggleFilter(preference: (LibraryPreferences) -> Preference<TriState>) {
        preference(libraryPreferences).getAndSet {
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/main/MainActivity.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/main/MainActivity.kt
@@ -138,7 +138,7 @@ class MainActivity : BaseActivity() {
                libraryPreferences = libraryPreferences,
                readerPreferences = Injekt.get(),
                backupPreferences = Injekt.get(),
-                trackManager = Injekt.get(),
+                trackerManager = Injekt.get(),
            )
        } else {
            false
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaScreenModel.kt
@@ -23,9 +23,9 @@ import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.download.DownloadCache
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.download.model.Download
-import eu.kanade.tachiyomi.data.track.EnhancedTrackService
-import eu.kanade.tachiyomi.data.track.TrackManager
-import eu.kanade.tachiyomi.data.track.TrackService
+import eu.kanade.tachiyomi.data.track.EnhancedTracker
+import eu.kanade.tachiyomi.data.track.Tracker
+import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.network.HttpException
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.ui.manga.track.TrackItem
@@ -84,7 +84,7 @@ class MangaScreenModel(
    private val libraryPreferences: LibraryPreferences = Injekt.get(),
    readerPreferences: ReaderPreferences = Injekt.get(),
    uiPreferences: UiPreferences = Injekt.get(),
-    private val trackManager: TrackManager = Injekt.get(),
+    private val trackerManager: TrackerManager = Injekt.get(),
    private val downloadManager: DownloadManager = Injekt.get(),
    private val downloadCache: DownloadCache = Injekt.get(),
    private val getMangaAndChapters: GetMangaWithChapters = Injekt.get(),
@@ -105,7 +105,7 @@ class MangaScreenModel(
    private val successState: State.Success?
        get() = state.value as? State.Success

-    private val loggedServices by lazy { trackManager.services.filter { it.isLoggedIn } }
+    private val loggedInTrackers by lazy { trackerManager.trackers.filter { it.isLoggedIn } }

    val manga: Manga?
        get() = successState?.manga
@@ -317,14 +317,14 @@ class MangaScreenModel(
                // Finally match with enhanced tracking when available
                val source = state.source
                state.trackItems
-                    .map { it.service }
-                    .filterIsInstance<EnhancedTrackService>()
+                    .map { it.tracker }
+                    .filterIsInstance<EnhancedTracker>()
                    .filter { it.accept(source) }
                    .forEach { service ->
                        launchIO {
                            try {
                                service.match(manga)?.let { track ->
-                                    (service as TrackService).register(track, mangaId)
+                                    (service as Tracker).register(track, mangaId)
                                }
                            } catch (e: Exception) {
                                logcat(LogPriority.WARN, e) {
@@ -949,11 +949,11 @@ class MangaScreenModel(
            getTracks.subscribe(manga.id)
                .catch { logcat(LogPriority.ERROR, it) }
                .map { tracks ->
-                    loggedServices
+                    loggedInTrackers
                        // Map to TrackItem
                        .map { service -> TrackItem(tracks.find { it.syncId == service.id }, service) }
                        // Show only if the service supports this manga's source
-                        .filter { (it.service as? EnhancedTrackService)?.accept(source!!) ?: true }
+                        .filter { (it.tracker as? EnhancedTracker)?.accept(source!!) ?: true }
                }
                .distinctUntilChanged()
                .collectLatest { trackItems ->
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/manga/track/TrackInfoDialog.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/manga/track/TrackInfoDialog.kt
@@ -46,14 +46,14 @@ import eu.kanade.presentation.track.TrackChapterSelector
 import eu.kanade.presentation.track.TrackDateSelector
 import eu.kanade.presentation.track.TrackInfoDialogHome
 import eu.kanade.presentation.track.TrackScoreSelector
-import eu.kanade.presentation.track.TrackServiceSearch
 import eu.kanade.presentation.track.TrackStatusSelector
+import eu.kanade.presentation.track.TrackerSearch
 import eu.kanade.presentation.util.Screen
 import eu.kanade.tachiyomi.R
-import eu.kanade.tachiyomi.data.track.DeletableTrackService
-import eu.kanade.tachiyomi.data.track.EnhancedTrackService
-import eu.kanade.tachiyomi.data.track.TrackManager
-import eu.kanade.tachiyomi.data.track.TrackService
+import eu.kanade.tachiyomi.data.track.DeletableTracker
+import eu.kanade.tachiyomi.data.track.EnhancedTracker
+import eu.kanade.tachiyomi.data.track.Tracker
+import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.data.track.model.TrackSearch
 import eu.kanade.tachiyomi.util.lang.convertEpochMillisZone
 import eu.kanade.tachiyomi.util.system.openInBrowser
@@ -105,7 +105,7 @@ data class TrackInfoDialogHomeScreen(
                navigator.push(
                    TrackStatusSelectorScreen(
                        track = it.track!!,
-                        serviceId = it.service.id,
+                        serviceId = it.tracker.id,
                    ),
                )
            },
@@ -113,7 +113,7 @@ data class TrackInfoDialogHomeScreen(
                navigator.push(
                    TrackChapterSelectorScreen(
                        track = it.track!!,
-                        serviceId = it.service.id,
+                        serviceId = it.tracker.id,
                    ),
                )
            },
@@ -121,7 +121,7 @@ data class TrackInfoDialogHomeScreen(
                navigator.push(
                    TrackScoreSelectorScreen(
                        track = it.track!!,
-                        serviceId = it.service.id,
+                        serviceId = it.tracker.id,
                    ),
                )
            },
@@ -129,7 +129,7 @@ data class TrackInfoDialogHomeScreen(
                navigator.push(
                    TrackDateSelectorScreen(
                        track = it.track!!,
-                        serviceId = it.service.id,
+                        serviceId = it.tracker.id,
                        start = true,
                    ),
                )
@@ -138,21 +138,21 @@ data class TrackInfoDialogHomeScreen(
                navigator.push(
                    TrackDateSelectorScreen(
                        track = it.track!!,
-                        serviceId = it.service.id,
+                        serviceId = it.tracker.id,
                        start = false,
                    ),
                )
            },
            onNewSearch = {
-                if (it.service is EnhancedTrackService) {
+                if (it.tracker is EnhancedTracker) {
                    sm.registerEnhancedTracking(it)
                } else {
                    navigator.push(
-                        TrackServiceSearchScreen(
+                        TrackerSearchScreen(
                            mangaId = mangaId,
                            initialQuery = it.track?.title ?: mangaTitle,
                            currentUrl = it.track?.remoteUrl,
-                            serviceId = it.service.id,
+                            serviceId = it.tracker.id,
                        ),
                    )
                }
@@ -160,10 +160,10 @@ data class TrackInfoDialogHomeScreen(
            onOpenInBrowser = { openTrackerInBrowser(context, it) },
            onRemoved = {
                navigator.push(
-                    TrackServiceRemoveScreen(
+                    TrackerRemoveScreen(
                        mangaId = mangaId,
                        track = it.track!!,
-                        serviceId = it.service.id,
+                        serviceId = it.tracker.id,
                    ),
                )
            },
@@ -201,12 +201,12 @@ data class TrackInfoDialogHomeScreen(
        }

        fun registerEnhancedTracking(item: TrackItem) {
-            item.service as EnhancedTrackService
+            item.tracker as EnhancedTracker
            coroutineScope.launchNonCancellable {
                val manga = Injekt.get<GetManga>().await(mangaId) ?: return@launchNonCancellable
                try {
-                    val matchResult = item.service.match(manga) ?: throw Exception()
-                    item.service.register(matchResult, mangaId)
+                    val matchResult = item.tracker.match(manga) ?: throw Exception()
+                    item.tracker.register(matchResult, mangaId)
                } catch (e: Exception) {
                    withUIContext { Injekt.get<Application>().toast(R.string.error_no_match) }
                }
@@ -236,13 +236,13 @@ data class TrackInfoDialogHomeScreen(
        }

        private fun List<Track>.mapToTrackItem(): List<TrackItem> {
-            val loggedServices = Injekt.get<TrackManager>().services.filter { it.isLoggedIn }
+            val loggedInTrackers = Injekt.get<TrackerManager>().trackers.filter { it.isLoggedIn }
            val source = Injekt.get<SourceManager>().getOrStub(sourceId)
-            return loggedServices
+            return loggedInTrackers
                // Map to TrackItem
                .map { service -> TrackItem(find { it.syncId == service.id }, service) }
                // Show only if the service supports this manga's source
-                .filter { (it.service as? EnhancedTrackService)?.accept(source) ?: true }
+                .filter { (it.tracker as? EnhancedTracker)?.accept(source) ?: true }
        }

        @Immutable
@@ -263,7 +263,7 @@ private data class TrackStatusSelectorScreen(
        val sm = rememberScreenModel {
            Model(
                track = track,
-                service = Injekt.get<TrackManager>().getService(serviceId)!!,
+                tracker = Injekt.get<TrackerManager>().get(serviceId)!!,
            )
        }
        val state by sm.state.collectAsState()
@@ -281,11 +281,11 @@ private data class TrackStatusSelectorScreen(

    private class Model(
        private val track: Track,
-        private val service: TrackService,
+        private val tracker: Tracker,
    ) : StateScreenModel<Model.State>(State(track.status.toInt())) {

        fun getSelections(): Map<Int, Int?> {
-            return service.getStatusList().associateWith { service.getStatus(it) }
+            return tracker.getStatusList().associateWith { tracker.getStatus(it) }
        }

        fun setSelection(selection: Int) {
@@ -294,7 +294,7 @@ private data class TrackStatusSelectorScreen(

        fun setStatus() {
            coroutineScope.launchNonCancellable {
-                service.setRemoteStatus(track.toDbTrack(), state.value.selection)
+                tracker.setRemoteStatus(track.toDbTrack(), state.value.selection)
            }
        }

@@ -316,7 +316,7 @@ private data class TrackChapterSelectorScreen(
        val sm = rememberScreenModel {
            Model(
                track = track,
-                service = Injekt.get<TrackManager>().getService(serviceId)!!,
+                tracker = Injekt.get<TrackerManager>().get(serviceId)!!,
            )
        }
        val state by sm.state.collectAsState()
@@ -335,7 +335,7 @@ private data class TrackChapterSelectorScreen(

    private class Model(
        private val track: Track,
-        private val service: TrackService,
+        private val tracker: Tracker,
    ) : StateScreenModel<Model.State>(State(track.lastChapterRead.toInt())) {

        fun getRange(): Iterable<Int> {
@@ -353,7 +353,7 @@ private data class TrackChapterSelectorScreen(

        fun setChapter() {
            coroutineScope.launchNonCancellable {
-                service.setRemoteLastChapterRead(track.toDbTrack(), state.value.selection)
+                tracker.setRemoteLastChapterRead(track.toDbTrack(), state.value.selection)
            }
        }

@@ -375,7 +375,7 @@ private data class TrackScoreSelectorScreen(
        val sm = rememberScreenModel {
            Model(
                track = track,
-                service = Injekt.get<TrackManager>().getService(serviceId)!!,
+                tracker = Injekt.get<TrackerManager>().get(serviceId)!!,
            )
        }
        val state by sm.state.collectAsState()
@@ -394,11 +394,11 @@ private data class TrackScoreSelectorScreen(

    private class Model(
        private val track: Track,
-        private val service: TrackService,
-    ) : StateScreenModel<Model.State>(State(service.displayScore(track.toDbTrack()))) {
+        private val tracker: Tracker,
+    ) : StateScreenModel<Model.State>(State(tracker.displayScore(track.toDbTrack()))) {

        fun getSelections(): List<String> {
-            return service.getScoreList()
+            return tracker.getScoreList()
        }

        fun setSelection(selection: String) {
@@ -407,7 +407,7 @@ private data class TrackScoreSelectorScreen(

        fun setScore() {
            coroutineScope.launchNonCancellable {
-                service.setRemoteScore(track.toDbTrack(), state.value.selection)
+                tracker.setRemoteScore(track.toDbTrack(), state.value.selection)
            }
        }

@@ -486,7 +486,7 @@ private data class TrackDateSelectorScreen(
        val sm = rememberScreenModel {
            Model(
                track = track,
-                service = Injekt.get<TrackManager>().getService(serviceId)!!,
+                tracker = Injekt.get<TrackerManager>().get(serviceId)!!,
                start = start,
            )
        }
@@ -515,7 +515,7 @@ private data class TrackDateSelectorScreen(

    private class Model(
        private val track: Track,
-        private val service: TrackService,
+        private val tracker: Tracker,
        private val start: Boolean,
    ) : ScreenModel {

@@ -534,15 +534,15 @@ private data class TrackDateSelectorScreen(
            val localMillis = millis.convertEpochMillisZone(ZoneOffset.UTC, ZoneOffset.systemDefault())
            coroutineScope.launchNonCancellable {
                if (start) {
-                    service.setRemoteStartDate(track.toDbTrack(), localMillis)
+                    tracker.setRemoteStartDate(track.toDbTrack(), localMillis)
                } else {
-                    service.setRemoteFinishDate(track.toDbTrack(), localMillis)
+                    tracker.setRemoteFinishDate(track.toDbTrack(), localMillis)
                }
            }
        }

        fun confirmRemoveDate(navigator: Navigator) {
-            navigator.push(TrackDateRemoverScreen(track, service.id, start))
+            navigator.push(TrackDateRemoverScreen(track, tracker.id, start))
        }
    }
 }
@@ -559,7 +559,7 @@ private data class TrackDateRemoverScreen(
        val sm = rememberScreenModel {
            Model(
                track = track,
-                service = Injekt.get<TrackManager>().getService(serviceId)!!,
+                tracker = Injekt.get<TrackerManager>().get(serviceId)!!,
                start = start,
            )
        }
@@ -614,25 +614,25 @@ private data class TrackDateRemoverScreen(

    private class Model(
        private val track: Track,
-        private val service: TrackService,
+        private val tracker: Tracker,
        private val start: Boolean,
    ) : ScreenModel {

-        fun getServiceName() = service.name
+        fun getServiceName() = tracker.name

        fun removeDate() {
            coroutineScope.launchNonCancellable {
                if (start) {
-                    service.setRemoteStartDate(track.toDbTrack(), 0)
+                    tracker.setRemoteStartDate(track.toDbTrack(), 0)
                } else {
-                    service.setRemoteFinishDate(track.toDbTrack(), 0)
+                    tracker.setRemoteFinishDate(track.toDbTrack(), 0)
                }
            }
        }
    }
 }

-data class TrackServiceSearchScreen(
+data class TrackerSearchScreen(
    private val mangaId: Long,
    private val initialQuery: String,
    private val currentUrl: String?,
@@ -647,14 +647,14 @@ data class TrackServiceSearchScreen(
                mangaId = mangaId,
                currentUrl = currentUrl,
                initialQuery = initialQuery,
-                service = Injekt.get<TrackManager>().getService(serviceId)!!,
+                tracker = Injekt.get<TrackerManager>().get(serviceId)!!,
            )
        }

        val state by sm.state.collectAsState()

        var textFieldValue by remember { mutableStateOf(TextFieldValue(initialQuery)) }
-        TrackServiceSearch(
+        TrackerSearch(
            query = textFieldValue,
            onQueryChange = { textFieldValue = it },
            onDispatchQuery = { sm.trackingSearch(textFieldValue.text) },
@@ -673,7 +673,7 @@ data class TrackServiceSearchScreen(
        private val mangaId: Long,
        private val currentUrl: String? = null,
        initialQuery: String,
-        private val service: TrackService,
+        private val tracker: Tracker,
    ) : StateScreenModel<Model.State>(State()) {

        init {
@@ -690,7 +690,7 @@ data class TrackServiceSearchScreen(

                val result = withIOContext {
                    try {
-                        val results = service.search(query)
+                        val results = tracker.search(query)
                        Result.success(results)
                    } catch (e: Throwable) {
                        Result.failure(e)
@@ -706,7 +706,7 @@ data class TrackServiceSearchScreen(
        }

        fun registerTracking(item: TrackSearch) {
-            coroutineScope.launchNonCancellable { service.register(item, mangaId) }
+            coroutineScope.launchNonCancellable { tracker.register(item, mangaId) }
        }

        fun updateSelection(selected: TrackSearch) {
@@ -721,7 +721,7 @@ data class TrackServiceSearchScreen(
    }
 }

-private data class TrackServiceRemoveScreen(
+private data class TrackerRemoveScreen(
    private val mangaId: Long,
    private val track: Track,
    private val serviceId: Long,
@@ -734,10 +734,10 @@ private data class TrackServiceRemoveScreen(
            Model(
                mangaId = mangaId,
                track = track,
-                service = Injekt.get<TrackManager>().getService(serviceId)!!,
+                tracker = Injekt.get<TrackerManager>().get(serviceId)!!,
            )
        }
-        val serviceName = sm.getServiceName()
+        val serviceName = sm.getName()
        var removeRemoteTrack by remember { mutableStateOf(false) }
        AlertDialogContent(
            modifier = Modifier.windowInsetsPadding(WindowInsets.systemBars),
@@ -758,7 +758,7 @@ private data class TrackServiceRemoveScreen(
                    Text(
                        text = stringResource(R.string.track_delete_text, serviceName),
                    )
-                    if (sm.isServiceDeletable()) {
+                    if (sm.isDeletable()) {
                        Row(verticalAlignment = Alignment.CenterVertically) {
                            Checkbox(checked = removeRemoteTrack, onCheckedChange = { removeRemoteTrack = it })
                            Text(text = stringResource(R.string.track_delete_remote_text, serviceName))
@@ -798,17 +798,17 @@ private data class TrackServiceRemoveScreen(
    private class Model(
        private val mangaId: Long,
        private val track: Track,
-        private val service: TrackService,
+        private val tracker: Tracker,
        private val deleteTrack: DeleteTrack = Injekt.get(),
    ) : ScreenModel {

-        fun getServiceName() = service.name
+        fun getName() = tracker.name

-        fun isServiceDeletable() = service is DeletableTrackService
+        fun isDeletable() = tracker is DeletableTracker

        fun deleteMangaFromService() {
            coroutineScope.launchNonCancellable {
-                (service as DeletableTrackService).delete(track.toDbTrack())
+                (tracker as DeletableTracker).delete(track.toDbTrack())
            }
        }

--- a/app/src/main/java/eu/kanade/tachiyomi/ui/manga/track/TrackItem.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/manga/track/TrackItem.kt
@@ -1,6 +1,6 @@
 package eu.kanade.tachiyomi.ui.manga.track

-import eu.kanade.tachiyomi.data.track.TrackService
+import eu.kanade.tachiyomi.data.track.Tracker
 import tachiyomi.domain.track.model.Track

-data class TrackItem(val track: Track?, val service: TrackService)
+data class TrackItem(val track: Track?, val tracker: Tracker)
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/setting/track/BaseOAuthLoginActivity.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/setting/track/BaseOAuthLoginActivity.kt
@@ -3,7 +3,7 @@ package eu.kanade.tachiyomi.ui.setting.track
 import android.content.Intent
 import android.net.Uri
 import android.os.Bundle
-import eu.kanade.tachiyomi.data.track.TrackManager
+import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.ui.base.activity.BaseActivity
 import eu.kanade.tachiyomi.ui.main.MainActivity
 import eu.kanade.tachiyomi.util.view.setComposeContent
@@ -12,7 +12,7 @@ import uy.kohesive.injekt.injectLazy

 abstract class BaseOAuthLoginActivity : BaseActivity() {

-    internal val trackManager: TrackManager by injectLazy()
+    internal val trackerManager: TrackerManager by injectLazy()

    abstract fun handleResult(data: Uri?)

--- a/app/src/main/java/eu/kanade/tachiyomi/ui/setting/track/TrackLoginActivity.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/setting/track/TrackLoginActivity.kt
@@ -20,11 +20,11 @@ class TrackLoginActivity : BaseOAuthLoginActivity() {
        val matchResult = regex.find(data.fragment.toString())
        if (matchResult?.groups?.get(1) != null) {
            lifecycleScope.launchIO {
-                trackManager.aniList.login(matchResult.groups[1]!!.value)
+                trackerManager.aniList.login(matchResult.groups[1]!!.value)
                returnToSettings()
            }
        } else {
-            trackManager.aniList.logout()
+            trackerManager.aniList.logout()
            returnToSettings()
        }
    }
@@ -33,11 +33,11 @@ class TrackLoginActivity : BaseOAuthLoginActivity() {
        val code = data.getQueryParameter("code")
        if (code != null) {
            lifecycleScope.launchIO {
-                trackManager.bangumi.login(code)
+                trackerManager.bangumi.login(code)
                returnToSettings()
            }
        } else {
-            trackManager.bangumi.logout()
+            trackerManager.bangumi.logout()
            returnToSettings()
        }
    }
@@ -46,11 +46,11 @@ class TrackLoginActivity : BaseOAuthLoginActivity() {
        val code = data.getQueryParameter("code")
        if (code != null) {
            lifecycleScope.launchIO {
-                trackManager.myAnimeList.login(code)
+                trackerManager.myAnimeList.login(code)
                returnToSettings()
            }
        } else {
-            trackManager.myAnimeList.logout()
+            trackerManager.myAnimeList.logout()
            returnToSettings()
        }
    }
@@ -59,11 +59,11 @@ class TrackLoginActivity : BaseOAuthLoginActivity() {
        val code = data.getQueryParameter("code")
        if (code != null) {
            lifecycleScope.launchIO {
-                trackManager.shikimori.login(code)
+                trackerManager.shikimori.login(code)
                returnToSettings()
            }
        } else {
-            trackManager.shikimori.logout()
+            trackerManager.shikimori.logout()
            returnToSettings()
        }
    }
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/stats/StatsScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/stats/StatsScreenModel.kt
@@ -10,7 +10,7 @@ import eu.kanade.core.util.fastMapNotNull
 import eu.kanade.presentation.more.stats.StatsScreenState
 import eu.kanade.presentation.more.stats.data.StatsData
 import eu.kanade.tachiyomi.data.download.DownloadManager
-import eu.kanade.tachiyomi.data.track.TrackManager
+import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.source.model.SManga
 import kotlinx.coroutines.flow.update
 import tachiyomi.core.util.lang.launchIO
@@ -33,10 +33,10 @@ class StatsScreenModel(
    private val getTotalReadDuration: GetTotalReadDuration = Injekt.get(),
    private val getTracks: GetTracks = Injekt.get(),
    private val preferences: LibraryPreferences = Injekt.get(),
-    private val trackManager: TrackManager = Injekt.get(),
+    private val trackerManager: TrackerManager = Injekt.get(),
 ) : StateScreenModel<StatsScreenState>(StatsScreenState.Loading) {

-    private val loggedServices by lazy { trackManager.services.fastFilter { it.isLoggedIn } }
+    private val loggedInTrackers by lazy { trackerManager.trackers.fastFilter { it.isLoggedIn } }

    init {
        coroutineScope.launchIO {
@@ -72,7 +72,7 @@ class StatsScreenModel(
            val trackersStatData = StatsData.Trackers(
                trackedTitleCount = mangaTrackMap.count { it.value.isNotEmpty() },
                meanScore = meanScore,
-                trackerCount = loggedServices.size,
+                trackerCount = loggedInTrackers.size,
            )

            mutableState.update {
@@ -115,10 +115,10 @@ class StatsScreenModel(
    }

    private suspend fun getMangaTrackMap(libraryManga: List<LibraryManga>): Map<Long, List<Track>> {
-        val loggedServicesIds = loggedServices.map { it.id }.toHashSet()
+        val loggedInTrackerIds = loggedInTrackers.map { it.id }.toHashSet()
        return libraryManga.associate { manga ->
            val tracks = getTracks.await(manga.id)
-                .fastFilter { it.syncId in loggedServicesIds }
+                .fastFilter { it.syncId in loggedInTrackerIds }

            manga.id to tracks
        }
@@ -144,7 +144,7 @@ class StatsScreenModel(
    }

    private fun get10PointScore(track: Track): Double {
-        val service = trackManager.getService(track.syncId)!!
+        val service = trackerManager.get(track.syncId)!!
        return service.get10PointScore(track)
    }
 }