Implement seasons feature (#2095)

Author: Secozzi

CHANGELOG.md

@@ -21,6 +21,7 @@ The format is a modified version of [Keep a Changelog](https://keepachangelog.co
 ### Added
 
 - Add player settings to the main settings screen ([@jmir1](https://github.com/jmir1)) ([#2081](https://github.com/aniyomiorg/aniyomi/pull/2081))
+- Add seasons support ([@Secozzi](https://github.com/Secozzi)) ([#2095](https://github.com/aniyomiorg/aniyomi/pull/2095))
 
 ## [v0.18.0.1] - 2025-07-06
 ### Fixed

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

@@ -3,6 +3,7 @@ package eu.kanade.domain
 import eu.kanade.domain.download.anime.interactor.DeleteEpisodeDownload
 import eu.kanade.domain.download.manga.interactor.DeleteChapterDownload
 import eu.kanade.domain.entries.anime.interactor.SetAnimeViewerFlags
+import eu.kanade.domain.entries.anime.interactor.SyncSeasonsWithSource
 import eu.kanade.domain.entries.anime.interactor.UpdateAnime
 import eu.kanade.domain.entries.manga.interactor.GetExcludedScanlators
 import eu.kanade.domain.entries.manga.interactor.SetExcludedScanlators
@@ -122,12 +123,13 @@ import tachiyomi.domain.entries.anime.interactor.AnimeFetchInterval
 import tachiyomi.domain.entries.anime.interactor.GetAnime
 import tachiyomi.domain.entries.anime.interactor.GetAnimeByUrlAndSourceId
 import tachiyomi.domain.entries.anime.interactor.GetAnimeFavorites
-import tachiyomi.domain.entries.anime.interactor.GetAnimeWithEpisodes
+import tachiyomi.domain.entries.anime.interactor.GetAnimeWithEpisodesAndSeasons
 import tachiyomi.domain.entries.anime.interactor.GetDuplicateLibraryAnime
 import tachiyomi.domain.entries.anime.interactor.GetLibraryAnime
 import tachiyomi.domain.entries.anime.interactor.NetworkToLocalAnime
 import tachiyomi.domain.entries.anime.interactor.ResetAnimeViewerFlags
 import tachiyomi.domain.entries.anime.interactor.SetAnimeEpisodeFlags
+import tachiyomi.domain.entries.anime.interactor.SetAnimeSeasonFlags
 import tachiyomi.domain.entries.anime.repository.AnimeRepository
 import tachiyomi.domain.entries.manga.interactor.GetDuplicateLibraryManga
 import tachiyomi.domain.entries.manga.interactor.GetLibraryManga
@@ -165,6 +167,9 @@ import tachiyomi.domain.items.episode.interactor.SetAnimeDefaultEpisodeFlags
 import tachiyomi.domain.items.episode.interactor.ShouldUpdateDbEpisode
 import tachiyomi.domain.items.episode.interactor.UpdateEpisode
 import tachiyomi.domain.items.episode.repository.EpisodeRepository
+import tachiyomi.domain.items.season.interactor.GetAnimeSeasonsByParentId
+import tachiyomi.domain.items.season.interactor.SetAnimeDefaultSeasonFlags
+import tachiyomi.domain.items.season.interactor.ShouldUpdateDbSeason
 import tachiyomi.domain.release.interactor.GetApplicationRelease
 import tachiyomi.domain.release.service.ReleaseService
 import tachiyomi.domain.source.anime.interactor.GetAnimeSourcesWithNonLibraryAnime
@@ -228,19 +233,24 @@ class DomainModule : InjektModule {
         addFactory { GetDuplicateLibraryAnime(get()) }
         addFactory { GetAnimeFavorites(get()) }
         addFactory { GetLibraryAnime(get()) }
-        addFactory { GetAnimeWithEpisodes(get(), get()) }
+        addFactory { GetAnimeWithEpisodesAndSeasons(get(), get()) }
         addFactory { GetAnimeByUrlAndSourceId(get()) }
         addFactory { GetAnime(get()) }
+        addFactory { GetAnimeSeasonsByParentId(get()) }
         addFactory { GetNextEpisodes(get(), get(), get()) }
         addFactory { GetUpcomingAnime(get()) }
         addFactory { ResetAnimeViewerFlags(get()) }
         addFactory { SetAnimeEpisodeFlags(get()) }
+        addFactory { SetAnimeSeasonFlags(get()) }
         addFactory { AnimeFetchInterval(get()) }
         addFactory { SetAnimeDefaultEpisodeFlags(get(), get(), get()) }
+        addFactory { SetAnimeDefaultSeasonFlags(get(), get(), get()) }
         addFactory { SetAnimeViewerFlags(get()) }
-        addFactory { NetworkToLocalAnime(get()) }
+        addFactory { NetworkToLocalAnime(get(), get()) }
         addFactory { UpdateAnime(get(), get()) }
         addFactory { SetAnimeCategories(get()) }
+        addFactory { ShouldUpdateDbSeason() }
+        addFactory { SyncSeasonsWithSource(get(), get(), get(), get(), get()) }
 
         addSingletonFactory<MangaRepository> { MangaRepositoryImpl(get()) }
         addFactory { GetDuplicateLibraryManga(get()) }

app/src/main/java/eu/kanade/domain/entries/anime/interactor/SyncSeasonsWithSource.kt

@@ -0,0 +1,108 @@
+package eu.kanade.domain.entries.anime.interactor
+
+import eu.kanade.domain.entries.anime.model.toDomainAnime
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import tachiyomi.domain.entries.anime.interactor.NetworkToLocalAnime
+import tachiyomi.domain.entries.anime.model.Anime
+import tachiyomi.domain.entries.anime.model.NoSeasonsException
+import tachiyomi.domain.entries.anime.model.toAnimeUpdate
+import tachiyomi.domain.entries.anime.repository.AnimeRepository
+import tachiyomi.domain.items.season.interactor.GetAnimeSeasonsByParentId
+import tachiyomi.domain.items.season.interactor.ShouldUpdateDbSeason
+import tachiyomi.domain.items.season.service.SeasonRecognition
+import tachiyomi.source.local.entries.anime.isLocal
+import java.time.ZonedDateTime
+
+class SyncSeasonsWithSource(
+    private val updateAnime: UpdateAnime,
+    private val animeRepository: AnimeRepository,
+    private val networkToLocalAnime: NetworkToLocalAnime,
+    private val shouldUpdateDbSeason: ShouldUpdateDbSeason,
+    private val getAnimeSeasonsByParentId: GetAnimeSeasonsByParentId,
+) {
+    suspend fun await(
+        rawSourceSeasons: List<SAnime>,
+        anime: Anime,
+        source: AnimeSource,
+        manualFetch: Boolean = false,
+        fetchWindow: Pair<Long, Long> = Pair(0, 0),
+    ): List<Anime> {
+        if (rawSourceSeasons.isEmpty() && !source.isLocal()) {
+            throw NoSeasonsException()
+        }
+
+        val now = ZonedDateTime.now()
+
+        val sourceSeasons = rawSourceSeasons
+            .distinctBy { it.url }
+            .mapIndexed { i, sAnime ->
+                networkToLocalAnime.await(sAnime.toDomainAnime(source.id))
+                    .copy(parentId = anime.id, seasonSourceOrder = i.toLong())
+            }
+
+        val dbSeasons = getAnimeSeasonsByParentId.await(anime.id)
+
+        val newSeasons = mutableListOf<Anime>()
+        val updatedSeasons = mutableListOf<Anime>()
+        val removedSeasons = dbSeasons.filterNot { dbSeasons ->
+            sourceSeasons.any { sourceSeason ->
+                dbSeasons.anime.url == sourceSeason.url
+            }
+        }
+
+        for (sourceSeason in sourceSeasons) {
+            var season = sourceSeason
+
+            // Recognize season number for the season
+            val seasonNumber = SeasonRecognition.parseSeasonNumber(
+                anime.title,
+                season.title,
+                season.seasonNumber,
+            )
+            season = season.copy(seasonNumber = seasonNumber)
+
+            val dbSeason = dbSeasons.find { it.anime.url == season.url }?.anime
+            if (dbSeason == null) {
+                newSeasons.add(season)
+            } else {
+                if (shouldUpdateDbSeason.await(dbSeason, season)) {
+                    val toChangeSeason = dbSeason.copy(
+                        title = season.title,
+                        seasonNumber = season.seasonNumber,
+                        seasonSourceOrder = season.seasonSourceOrder,
+                    )
+                    updatedSeasons.add(toChangeSeason)
+                }
+            }
+        }
+
+        // Return if there's nothing to add, delete, or update to avoid unnecessary db transactions.
+        if (newSeasons.isEmpty() && removedSeasons.isEmpty() && updatedSeasons.isEmpty()) {
+            if (manualFetch || anime.fetchInterval == 0 || anime.nextUpdate < fetchWindow.first) {
+                updateAnime.awaitUpdateFetchInterval(
+                    anime,
+                    now,
+                    fetchWindow,
+                )
+            }
+            return sourceSeasons
+        }
+
+        if (removedSeasons.isNotEmpty()) {
+            val toDeleteIds = removedSeasons.map { it.id }
+            animeRepository.removeParentIdByIds(toDeleteIds)
+        }
+
+        val toUpdate = newSeasons.map { it.toAnimeUpdate() } +
+            updatedSeasons.map { it.toAnimeUpdate() }
+
+        if (toUpdate.isNotEmpty()) {
+            updateAnime.awaitAll(toUpdate)
+        }
+
+        updateAnime.awaitUpdateLastUpdate(anime.id)
+
+        return sourceSeasons
+    }
+}

app/src/main/java/eu/kanade/domain/entries/anime/model/Anime.kt

@@ -18,12 +18,31 @@ val Anime.downloadedFilter: TriState
             else -> TriState.DISABLED
         }
     }
+
+val Anime.seasonDownloadedFilter: TriState
+    get() {
+        if (Injekt.get<BasePreferences>().downloadedOnly().get()) return TriState.ENABLED_IS
+        return when (seasonDownloadedFilterRaw) {
+            Anime.SEASON_SHOW_DOWNLOADED -> TriState.ENABLED_IS
+            Anime.SEASON_SHOW_NOT_DOWNLOADED -> TriState.ENABLED_NOT
+            else -> TriState.DISABLED
+        }
+    }
+
 fun Anime.episodesFiltered(): Boolean {
     return unseenFilter != TriState.DISABLED ||
         downloadedFilter != TriState.DISABLED ||
         bookmarkedFilter != TriState.DISABLED
 }
 
+fun Anime.seasonsFiltered(): Boolean {
+    return seasonDownloadedFilter != TriState.DISABLED ||
+        seasonUnseenFilter != TriState.DISABLED ||
+        seasonStartedFilter != TriState.DISABLED ||
+        seasonBookmarkedFilter != TriState.DISABLED ||
+        seasonCompletedFilter != TriState.DISABLED
+}
+
 fun Anime.toSAnime(): SAnime = SAnime.create().also {
     it.url = url
     it.title = title
@@ -33,6 +52,8 @@ fun Anime.toSAnime(): SAnime = SAnime.create().also {
     it.genre = genre.orEmpty().joinToString()
     it.status = status.toInt()
     it.thumbnail_url = thumbnailUrl
+    it.fetch_type = fetchType
+    it.season_number = seasonNumber
     it.initialized = initialized
 }
 
@@ -54,6 +75,8 @@ fun Anime.copyFrom(other: SAnime): Anime {
         thumbnailUrl = thumbnailUrl,
         status = other.status.toLong(),
         updateStrategy = other.update_strategy,
+        fetchType = other.fetch_type,
+        seasonNumber = other.season_number,
         initialized = other.initialized && initialized,
     )
 }
@@ -69,6 +92,8 @@ fun SAnime.toDomainAnime(sourceId: Long): Anime {
         status = status.toLong(),
         thumbnailUrl = thumbnail_url,
         updateStrategy = update_strategy,
+        fetchType = fetch_type,
+        seasonNumber = season_number,
         initialized = initialized,
         source = sourceId,
     )