diff --git a/lib/bangumi-scraper/build.gradle.kts b/lib/bangumi-scraper/build.gradle.kts
new file mode 100644
index 0000000000..c49026e416
--- /dev/null
+++ b/lib/bangumi-scraper/build.gradle.kts
@@ -0,0 +1,7 @@
+plugins {
+    id("lib-android")
+}
+
+dependencies {
+    compileOnly(libs.aniyomi.lib)
+}
\ No newline at end of file
diff --git a/lib/bangumi-scraper/src/main/java/eu/kanade/tachiyomi/lib/bangumiscraper/BangumiDTO.kt b/lib/bangumi-scraper/src/main/java/eu/kanade/tachiyomi/lib/bangumiscraper/BangumiDTO.kt
new file mode 100644
index 0000000000..1f130ad25f
--- /dev/null
+++ b/lib/bangumi-scraper/src/main/java/eu/kanade/tachiyomi/lib/bangumiscraper/BangumiDTO.kt
@@ -0,0 +1,83 @@
+@file:UseSerializers(BoxItemSerializer::class)
+package eu.kanade.tachiyomi.lib.bangumiscraper
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.UseSerializers
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.json.JsonDecoder
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+
+@Serializable
+internal data class Images(
+    val large: String,
+    val common: String,
+    val medium: String,
+    val small: String,
+)
+
+@Serializable
+internal data class BoxItem(
+    val key: String,
+    val value: String,
+)
+
+@OptIn(ExperimentalSerializationApi::class)
+@Serializer(forClass = BoxItem::class)
+internal object BoxItemSerializer : KSerializer<BoxItem> {
+    override fun deserialize(decoder: Decoder): BoxItem {
+        val item = (decoder as JsonDecoder).decodeJsonElement().jsonObject
+        val key = item["key"]!!.jsonPrimitive.content
+        val value = (item["value"] as? JsonPrimitive)?.contentOrNull ?: ""
+        return BoxItem(key, value)
+    }
+}
+
+@Serializable
+internal data class Subject(
+    val name: String,
+    @SerialName("name_cn")
+    val nameCN: String,
+    val summary: String,
+    val images: Images,
+    @SerialName("meta_tags")
+    val metaTags: List<String>,
+    @SerialName("infobox")
+    val infoBox: List<BoxItem>,
+) {
+    fun findAuthor(): String? {
+        return findInfo("导演", "原作")
+    }
+
+    fun findArtist(): String? {
+        return findInfo("美术监督", "总作画监督", "动画制作")
+    }
+
+    fun findInfo(vararg keys: String): String? {
+        keys.forEach { key ->
+            return infoBox.find { item ->
+                item.key == key
+            }?.value ?: return@forEach
+        }
+        return null
+    }
+}
+
+@Serializable
+internal data class SearchItem(
+    val id: Int,
+    val name: String,
+    @SerialName("name_cn")
+    val nameCN: String,
+    val summary: String,
+    val images: Images,
+)
+
+@Serializable
+internal data class SearchResponse(val results: Int, val list: List<SearchItem>)
diff --git a/lib/bangumi-scraper/src/main/java/eu/kanade/tachiyomi/lib/bangumiscraper/BangumiScraper.kt b/lib/bangumi-scraper/src/main/java/eu/kanade/tachiyomi/lib/bangumiscraper/BangumiScraper.kt
new file mode 100644
index 0000000000..3653314e06
--- /dev/null
+++ b/lib/bangumi-scraper/src/main/java/eu/kanade/tachiyomi/lib/bangumiscraper/BangumiScraper.kt
@@ -0,0 +1,126 @@
+package eu.kanade.tachiyomi.lib.bangumiscraper
+
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.awaitSuccess
+import eu.kanade.tachiyomi.util.parseAs
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+
+enum class BangumiSubjectType(val value: Int) {
+    BOOK(1),
+    ANIME(2),
+    MUSIC(3),
+    GAME(4),
+    REAL(6),
+}
+
+enum class BangumiFetchType {
+    /**
+     * Give cover and summary info.
+     */
+    SHORT,
+
+    /**
+     * Give all require info include genre and author info.
+     */
+    ALL,
+}
+
+/**
+ * A helper class to fetch anime details from Bangumi
+ */
+object BangumiScraper {
+    private const val SEARCH_URL = "https://api.bgm.tv/search/subject"
+    private const val SUBJECTS_URL = "https://api.bgm.tv/v0/subjects"
+
+    /**
+     * Fetch anime details info from Bangumi
+     * @param fetchType check [BangumiFetchType] to get detail
+     * @param subjectType check [BangumiSubjectType] to get detail
+     * @param requestProducer used to custom request
+     */
+    suspend fun fetchDetail(
+        client: OkHttpClient,
+        keyword: String,
+        fetchType: BangumiFetchType = BangumiFetchType.SHORT,
+        subjectType: BangumiSubjectType = BangumiSubjectType.ANIME,
+        requestProducer: (url: HttpUrl) -> Request = { url -> GET(url) },
+    ): SAnime {
+        val httpUrl = SEARCH_URL.toHttpUrl().newBuilder()
+            .addPathSegment(keyword)
+            .addQueryParameter(
+                "responseGroup",
+                if (fetchType == BangumiFetchType.ALL) {
+                    "small"
+                } else {
+                    "medium"
+                },
+            )
+            .addQueryParameter("type", "${subjectType.value}")
+            .addQueryParameter("start", "0")
+            .addQueryParameter("max_results", "1")
+            .build()
+        val searchResponse = client.newCall(requestProducer(httpUrl)).awaitSuccess()
+            .checkErrorMessage().parseAs<SearchResponse>()
+        return if (searchResponse.list.isEmpty()) {
+            SAnime.create()
+        } else {
+            val item = searchResponse.list[0]
+            if (fetchType == BangumiFetchType.ALL) {
+                fetchSubject(client, "${item.id}", requestProducer)
+            } else {
+                SAnime.create().apply {
+                    thumbnail_url = item.images.large
+                    description = item.summary
+                }
+            }
+        }
+    }
+
+    private suspend fun fetchSubject(
+        client: OkHttpClient,
+        id: String,
+        requestProducer: (url: HttpUrl) -> Request,
+    ): SAnime {
+        val httpUrl = SUBJECTS_URL.toHttpUrl().newBuilder().addPathSegment(id).build()
+        val subject = client.newCall(requestProducer(httpUrl)).awaitSuccess()
+            .checkErrorMessage().parseAs<Subject>()
+        return SAnime.create().apply {
+            thumbnail_url = subject.images.large
+            description = subject.summary
+            genre = buildList {
+                addAll(subject.metaTags)
+                subject.findInfo("动画制作")?.let { add(it) }
+                subject.findInfo("放送开始")?.let { add(it) }
+            }.joinToString()
+            author = subject.findAuthor()
+            artist = subject.findArtist()
+            if (subject.findInfo("播放结束") != null) {
+                status = SAnime.COMPLETED
+            } else if (subject.findInfo("放送开始") != null) {
+                status = SAnime.ONGOING
+            }
+        }
+    }
+
+    private fun Response.checkErrorMessage(): String {
+        val responseStr = body.string()
+        val errorMessage =
+            responseStr.parseAs<JsonElement>().jsonObject["error"]?.jsonPrimitive?.contentOrNull
+        if (errorMessage != null) {
+            throw BangumiScraperException(errorMessage)
+        }
+        return responseStr
+    }
+}
+
+
+
diff --git a/lib/bangumi-scraper/src/main/java/eu/kanade/tachiyomi/lib/bangumiscraper/BangumiScraperException.kt b/lib/bangumi-scraper/src/main/java/eu/kanade/tachiyomi/lib/bangumiscraper/BangumiScraperException.kt
new file mode 100644
index 0000000000..08d1e30835
--- /dev/null
+++ b/lib/bangumi-scraper/src/main/java/eu/kanade/tachiyomi/lib/bangumiscraper/BangumiScraperException.kt
@@ -0,0 +1,3 @@
+package eu.kanade.tachiyomi.lib.bangumiscraper
+
+class BangumiScraperException(message: String) : Exception(message)
diff --git a/src/zh/anime1/build.gradle b/src/zh/anime1/build.gradle
new file mode 100644
index 0000000000..96c45c2dd5
--- /dev/null
+++ b/src/zh/anime1/build.gradle
@@ -0,0 +1,13 @@
+ext {
+    extName = 'Anime1.me'
+    extClass = '.Anime1'
+    extVersionCode = 3
+}
+
+apply from: "$rootDir/common.gradle"
+
+dependencies {
+    implementation(project(":lib:bangumi-scraper"))
+    //noinspection UseTomlInstead
+    implementation "com.github.houbb:opencc4j:1.8.1"
+}
diff --git a/src/zh/anime1/res/mipmap-hdpi/ic_launcher.png b/src/zh/anime1/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000000..985857355d
Binary files /dev/null and b/src/zh/anime1/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/zh/anime1/res/mipmap-mdpi/ic_launcher.png b/src/zh/anime1/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000000..186328d501
Binary files /dev/null and b/src/zh/anime1/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/zh/anime1/res/mipmap-xhdpi/ic_launcher.png b/src/zh/anime1/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000000..195d9a2792
Binary files /dev/null and b/src/zh/anime1/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/zh/anime1/res/mipmap-xxhdpi/ic_launcher.png b/src/zh/anime1/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000000..599affaf33
Binary files /dev/null and b/src/zh/anime1/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/zh/anime1/res/mipmap-xxxhdpi/ic_launcher.png b/src/zh/anime1/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 0000000000..20dda2b2a1
Binary files /dev/null and b/src/zh/anime1/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/zh/anime1/src/eu/kanade/tachiyomi/animeextension/zh/anime1/Anime1.kt b/src/zh/anime1/src/eu/kanade/tachiyomi/animeextension/zh/anime1/Anime1.kt
new file mode 100644
index 0000000000..5901449267
--- /dev/null
+++ b/src/zh/anime1/src/eu/kanade/tachiyomi/animeextension/zh/anime1/Anime1.kt
@@ -0,0 +1,272 @@
+package eu.kanade.tachiyomi.animeextension.zh.anime1
+
+import android.app.Application
+import android.content.SharedPreferences
+import android.webkit.CookieManager
+import androidx.preference.CheckBoxPreference
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
+import com.github.houbb.opencc4j.util.ZhTwConverterUtil
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.lib.bangumiscraper.BangumiFetchType
+import eu.kanade.tachiyomi.lib.bangumiscraper.BangumiScraper
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.network.awaitSuccess
+import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parseAs
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonPrimitive
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Document
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.text.SimpleDateFormat
+import java.util.Locale
+
+class Anime1 : AnimeHttpSource(), ConfigurableAnimeSource {
+    override val baseUrl: String
+        get() = "https://anime1.me"
+    override val lang: String
+        get() = "zh-hant"
+    override val name: String
+        get() = "Anime1.me"
+    override val supportsLatest: Boolean
+        get() = true
+
+    override fun headersBuilder() = super.headersBuilder().add("referer", "$baseUrl/")
+
+    private val videoApiUrl = "https://v.anime1.me/api"
+    private val dataUrl = "https://d1zquzjgwo9yb.cloudfront.net"
+    private val uploadDateFormat: SimpleDateFormat by lazy {
+        SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ", Locale.getDefault())
+    }
+    private lateinit var data: JsonArray
+    private val cookieManager
+        get() = CookieManager.getInstance()
+    private val preferences: SharedPreferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    override fun animeDetailsParse(response: Response) = throw UnsupportedOperationException()
+
+    override suspend fun getAnimeDetails(anime: SAnime): SAnime {
+        return if (bangumiEnable) {
+            BangumiScraper.fetchDetail(
+                client,
+                ZhTwConverterUtil.toSimple(anime.title.removeSuffixMark()),
+                fetchType = bangumiFetchType,
+            )
+        } else {
+            anime.thumbnail_url = FIX_COVER
+            anime
+        }
+    }
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        var document: Document? = response.asJsoup()
+        val episodes = mutableListOf<SEpisode>()
+        val requestUrl = response.request.url.toString()
+        while (document != null) {
+            val items = document.select("article.post").map {
+                SEpisode.create().apply {
+                    name = it.select(".entry-title").text()
+                    val url = it.selectFirst(".entry-title a")?.attr("href") ?: requestUrl
+                    setUrlWithoutDomain(url)
+                    date_upload = it.select("time.updated").attr("datetime").let { date ->
+                        runCatching { uploadDateFormat.parse(date)?.time }.getOrNull() ?: 0L
+                    }
+                }
+            }
+            episodes.addAll(items)
+            val previousUrl = document.select(".nav-previous a").attr("href")
+            document = if (previousUrl.isBlank()) {
+                null
+            } else {
+                client.newCall(GET(previousUrl)).execute().asJsoup()
+            }
+        }
+        return episodes
+    }
+
+    override fun videoListParse(response: Response): List<Video> {
+        val document = response.asJsoup()
+        val req = document.select("video").attr("data-apireq")
+        val videoResponse: VideoResponse = client.newCall(
+            POST(
+                videoApiUrl,
+                body = "d=$req".toRequestBody("application/x-www-form-urlencoded".toMediaTypeOrNull()),
+            ),
+        ).execute().parseAs()
+        return videoResponse.s.map {
+            val videoUrl = "https:${it.src}"
+            val newHeaders = cookieManager.getCookie(videoUrl)?.let { cookie ->
+                headers.newBuilder().add("cookie", cookie).build()
+            }
+            Video(videoUrl, it.type, videoUrl, headers = newHeaders)
+        }
+    }
+
+    override suspend fun getLatestUpdates(page: Int): AnimesPage {
+        if (!this::data.isInitialized) {
+            data = client.newCall(GET("$dataUrl/?_=${System.currentTimeMillis()}")).awaitSuccess()
+                .parseAs()
+        }
+        val items = data.subList((page - 1) * PAGE_SIZE, (page * PAGE_SIZE).coerceAtMost(data.size))
+        return AnimesPage(
+            items.map {
+                SAnime.create().apply {
+                    val array = it.jsonArray
+                    val id = array.getContent(0)!!
+                    url = "?cat=$id"
+                    title = array.getContent(1)!!
+                    if (id == "0" || title.contains("</a>")) {
+                        val doc = Jsoup.parse(title)
+                        doc.selectFirst("a")?.let { link ->
+                            url = link.attr("href")
+                        }
+                        title = doc.text()
+                    }
+                    status = if (array.getContent(2)?.contains("連載中") == true) {
+                        SAnime.ONGOING
+                    } else {
+                        SAnime.COMPLETED
+                    }
+                    genre = listOfNotNull(
+                        array.getContent(3),
+                        array.getContent(4),
+                        array.getContent(5),
+                    ).joinToString()
+                    thumbnail_url = FIX_COVER
+                }
+            },
+            items.size == PAGE_SIZE,
+        )
+    }
+
+    override suspend fun getPopularAnime(page: Int): AnimesPage {
+        return getLatestUpdates(page)
+    }
+
+    override fun latestUpdatesParse(response: Response) = throw UnsupportedOperationException()
+    override fun latestUpdatesRequest(page: Int) = throw UnsupportedOperationException()
+    override fun popularAnimeParse(response: Response) = throw UnsupportedOperationException()
+    override fun popularAnimeRequest(page: Int) = throw UnsupportedOperationException()
+
+    override fun searchAnimeParse(response: Response): AnimesPage {
+        // The search result is episode
+        val document = response.asJsoup()
+        val items = document.select("article.post .entry-title a").map {
+            SAnime.create().apply {
+                setUrlWithoutDomain(it.attr("href"))
+                title = it.ownText()
+                thumbnail_url = FIX_COVER
+            }
+        }
+        val previous = document.select(".nav-previous")
+        return AnimesPage(items, previous.isNotEmpty())
+    }
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val url = baseUrl.toHttpUrl().newBuilder()
+        if (page > 1) {
+            url.addPathSegments("page/$page")
+        }
+        url.addQueryParameter("s", query)
+        return GET(url.build())
+    }
+
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        val bangumiScraper = CheckBoxPreference(screen.context).apply {
+            key = PREF_KEY_BANGUMI
+            title = "啟用Bangumi刮削"
+        }
+        val bangumiFetchType = ListPreference(screen.context).apply {
+            key = PREF_KEY_BANGUMI_FETCH_TYPE
+            title = "詳情拉取設置"
+            setVisible(bangumiEnable)
+            entries = arrayOf("拉取部分數據", "拉取完整數據")
+            entryValues = arrayOf(BangumiFetchType.SHORT.name, BangumiFetchType.ALL.name)
+            setDefaultValue(entryValues[0])
+            summary = when (bangumiFetchType) {
+                BangumiFetchType.SHORT -> entries[0]
+                BangumiFetchType.ALL -> entries[1]
+                else -> entries[0]
+            }
+            setOnPreferenceChangeListener { _, value ->
+                summary = when (value) {
+                    BangumiFetchType.SHORT.name -> entries[0]
+                    BangumiFetchType.ALL.name -> entries[1]
+                    else -> entries[0]
+                }
+                true
+            }
+        }
+        bangumiScraper.setOnPreferenceChangeListener { _, value ->
+            bangumiFetchType.setVisible(value as Boolean)
+            true
+        }
+        screen.apply {
+            addPreference(bangumiScraper)
+            addPreference(bangumiFetchType)
+        }
+    }
+
+    private val bangumiEnable: Boolean
+        get() = preferences.getBoolean(PREF_KEY_BANGUMI, false)
+    private val bangumiFetchType: BangumiFetchType
+        get() {
+            val fetchTypeName =
+                preferences.getString(PREF_KEY_BANGUMI_FETCH_TYPE, BangumiFetchType.SHORT.name)
+            return when (fetchTypeName) {
+                BangumiFetchType.SHORT.name -> BangumiFetchType.SHORT
+                BangumiFetchType.ALL.name -> BangumiFetchType.ALL
+                else -> BangumiFetchType.SHORT
+            }
+        }
+
+    private fun JsonArray.getContent(index: Int): String? {
+        return getOrNull(index)?.jsonPrimitive?.contentOrNull
+    }
+
+    private fun String.removeSuffixMark(): String {
+        return removeBracket("(", ")").removeBracket("[", "]").trim()
+    }
+
+    private fun String.removeBracket(start: String, end: String): String {
+        val seasonStart = indexOf(start)
+        val seasonEnd = indexOf(end)
+        if (seasonEnd > seasonStart) {
+            return removeRange(seasonStart, seasonEnd + 1)
+        }
+        return this
+    }
+
+    companion object {
+        const val PAGE_SIZE = 20
+        const val FIX_COVER = "https://sta.anicdn.com/playerImg/8.jpg"
+
+        const val PREF_KEY_BANGUMI = "PREF_KEY_BANGUMI"
+        const val PREF_KEY_BANGUMI_FETCH_TYPE = "PREF_KEY_BANGUMI_FETCH_TYPE"
+    }
+}
+
+@Serializable
+data class VideoSource(val src: String, val type: String)
+
+@Serializable
+data class VideoResponse(val s: List<VideoSource>)
diff --git a/src/zh/xiaoxintv/build.gradle b/src/zh/xiaoxintv/build.gradle
new file mode 100644
index 0000000000..67d7a839f4
--- /dev/null
+++ b/src/zh/xiaoxintv/build.gradle
@@ -0,0 +1,7 @@
+ext {
+    extName = 'Xiaoxintv'
+    extClass = '.Xiaoxintv'
+    extVersionCode = 1
+}
+
+apply from: "$rootDir/common.gradle"
diff --git a/src/zh/xiaoxintv/res/mipmap-hdpi/ic_launcher.png b/src/zh/xiaoxintv/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000000..3f71948891
Binary files /dev/null and b/src/zh/xiaoxintv/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/zh/xiaoxintv/res/mipmap-mdpi/ic_launcher.png b/src/zh/xiaoxintv/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000000..a0c0809970
Binary files /dev/null and b/src/zh/xiaoxintv/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/zh/xiaoxintv/res/mipmap-xhdpi/ic_launcher.png b/src/zh/xiaoxintv/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000000..57026442c4
Binary files /dev/null and b/src/zh/xiaoxintv/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/zh/xiaoxintv/res/mipmap-xxhdpi/ic_launcher.png b/src/zh/xiaoxintv/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000000..f1e07f1381
Binary files /dev/null and b/src/zh/xiaoxintv/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/zh/xiaoxintv/res/mipmap-xxxhdpi/ic_launcher.png b/src/zh/xiaoxintv/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 0000000000..149a7beead
Binary files /dev/null and b/src/zh/xiaoxintv/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/zh/xiaoxintv/src/eu/kanade/tachiyomi/animeextension/zh/xiaoxintv/Filters.kt b/src/zh/xiaoxintv/src/eu/kanade/tachiyomi/animeextension/zh/xiaoxintv/Filters.kt
new file mode 100644
index 0000000000..68930c852d
--- /dev/null
+++ b/src/zh/xiaoxintv/src/eu/kanade/tachiyomi/animeextension/zh/xiaoxintv/Filters.kt
@@ -0,0 +1,221 @@
+@file:Suppress("LocalVariableName", "PropertyName")
+
+package eu.kanade.tachiyomi.animeextension.zh.xiaoxintv
+
+import android.content.SharedPreferences
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+private const val PREF_KEY_FILTER_CONFIG_PREFIX = "STORED_SEARCH_CONFIG"
+
+open class PathFilter(name: String, private val beans: Array<out SearchBean>) :
+    AnimeFilter.Select<String>(name, beans.map { it.name }.toTypedArray()) {
+    val selected
+        get() = beans[state]
+}
+
+class GroupFilter(name: String, filters: List<PathFilter>) :
+    AnimeFilter.Group<PathFilter>(name, filters)
+
+internal enum class FilterType(val title: String) {
+    TYPE("类型"),
+    CLASS("分类"),
+    YEAR("年份"),
+    LANG("语言"),
+    SORT("排序"),
+    REGION("地区"),
+}
+
+interface SearchBean {
+    val name: String
+    val ignore: Boolean
+    fun toPath(): String
+}
+
+@Serializable
+data class SearchType(
+    override val name: String,
+    val id: String,
+    override val ignore: Boolean = false,
+) : SearchBean {
+    constructor(name: String, id: Int) : this(name, "$id")
+
+    override fun toPath() = "/id/$id"
+}
+
+internal fun SearchType.toFilter(): PathFilter {
+    return PathFilter(name, arrayOf(this))
+}
+
+@Serializable
+data class SearchSort(
+    override val name: String,
+    val by: String,
+    override val ignore: Boolean = false,
+) : SearchBean {
+    override fun toPath() = "/by/$by"
+}
+
+@Serializable
+data class SearchYear(override val name: String, override val ignore: Boolean = false) :
+    SearchBean {
+    override fun toPath() = "/year/$name"
+}
+
+@Serializable
+data class SearchLang(override val name: String, override val ignore: Boolean = false) :
+    SearchBean {
+    override fun toPath() = "/lang/$name"
+}
+
+@Serializable
+data class SearchClass(override val name: String, override val ignore: Boolean = false) :
+    SearchBean {
+    override fun toPath() = "/class/$name"
+}
+
+@Serializable
+data class SearchRegion(override val name: String, override val ignore: Boolean = false) :
+    SearchBean {
+    override fun toPath() = "/area/$name"
+}
+
+@Serializable
+data class SearchFilterConfig(
+    val type: List<SearchType>,
+    val category: List<SearchClass> = emptyList(),
+    val year: List<SearchYear> = emptyList(),
+    val lang: List<SearchLang> = emptyList(),
+    val region: List<SearchRegion> = emptyList(),
+) {
+    fun isEmpty() =
+        type.isEmpty() && category.isEmpty() && year.isEmpty() && lang.isEmpty() && region.isEmpty()
+}
+
+private inline fun <reified T> c(): Class<T> {
+    return T::class.java
+}
+
+private val searchPriority = arrayOf(
+    c<SearchRegion>(),
+    c<SearchSort>(),
+    c<SearchClass>(),
+    c<SearchType>(),
+    c<SearchLang>(),
+    c<SearchYear>(),
+)
+
+internal fun Iterable<SearchBean>.toPath(): String {
+    return this.asSequence().filterNot { it.ignore }
+        .groupBy { it::class.java }.flatMap { it.value.subList(it.value.size - 1, it.value.size) }
+        .sortedBy {
+            searchPriority.indexOf(it::class.java)
+        }
+        .joinToString(separator = "") { it.toPath() }.removePrefix("/")
+}
+
+private val defaultLangList =
+    listOf(
+        SearchLang("全部", ignore = true),
+        SearchLang("国语"),
+        SearchLang("粤语"),
+        SearchLang("英语"),
+        SearchLang("其他"),
+    )
+
+private val typeAll = SearchType("全部", "-1", ignore = true)
+private val categoryAll = SearchClass("全部", ignore = true)
+private val yearAll = SearchYear("全部", ignore = true)
+private val regionAll = SearchRegion("全部", ignore = true)
+
+private val defaultSearchFilterConfig = mapOf(
+    // anime
+    "5" to SearchFilterConfig(
+        type = listOf(typeAll, SearchType("国产动漫", 51), SearchType("日本动漫", 52)),
+        category = listOf(
+            categoryAll,
+            SearchClass("热血"),
+            SearchClass("格斗"),
+            SearchClass("其他"),
+        ),
+        year = listOf(yearAll),
+        lang = defaultLangList,
+    ),
+    // movie
+    "7" to SearchFilterConfig(
+        type = listOf(typeAll),
+        region = listOf(regionAll),
+        year = listOf(yearAll),
+        lang = defaultLangList,
+    ),
+    // tv
+    "6" to SearchFilterConfig(
+        type = listOf(typeAll),
+        category = listOf(categoryAll),
+        year = listOf(yearAll),
+        lang = defaultLangList,
+    ),
+    // variety show
+    "3" to SearchFilterConfig(
+        type = listOf(typeAll),
+        category = listOf(categoryAll),
+        year = listOf(yearAll),
+        lang = defaultLangList,
+    ),
+    // documentary
+    "21" to SearchFilterConfig(
+        type = emptyList(),
+        region = listOf(regionAll),
+        year = listOf(yearAll),
+        lang = defaultLangList,
+    ),
+    // short show
+    "64" to SearchFilterConfig(
+        type = listOf(typeAll),
+    ),
+)
+
+private fun findDefaultSearchFilterConfig(majorTypeId: String): SearchFilterConfig {
+    return defaultSearchFilterConfig.getOrElse(majorTypeId) {
+        SearchFilterConfig(
+            listOf(typeAll),
+        )
+    }
+}
+
+private fun genFilterConfigKey(majorTypeId: String): String {
+    return PREF_KEY_FILTER_CONFIG_PREFIX + "_$majorTypeId"
+}
+
+internal val defaultMajorSearchTypeSet = arrayOf(
+    SearchType("动漫", 5),
+    SearchType("电影", 7),
+    SearchType("电视剧", 6),
+    SearchType("综艺", 3),
+    SearchType("纪录片", 21),
+    SearchType("短剧", 64),
+)
+
+internal val defaultSortTypeSet =
+    arrayOf(
+        SearchSort("时间", "time", ignore = true),
+        SearchSort("人气", "hits"),
+        SearchSort("评分", "score"),
+    )
+
+fun SharedPreferences.findSearchFilterConfig(majorTypeId: String, json: Json): SearchFilterConfig {
+    // check shared preferences
+    return getString(genFilterConfigKey(majorTypeId), null)?.let { json.decodeFromString(it) }
+        ?: findDefaultSearchFilterConfig(majorTypeId)
+}
+
+fun SharedPreferences.saveSearchFilterConfig(
+    majorTypeId: String,
+    searchFilterConfig: SearchFilterConfig,
+    json: Json,
+) {
+    edit().putString(genFilterConfigKey(majorTypeId), json.encodeToString(searchFilterConfig))
+        .apply()
+}
diff --git a/src/zh/xiaoxintv/src/eu/kanade/tachiyomi/animeextension/zh/xiaoxintv/Xiaoxintv.kt b/src/zh/xiaoxintv/src/eu/kanade/tachiyomi/animeextension/zh/xiaoxintv/Xiaoxintv.kt
new file mode 100644
index 0000000000..01d5e15138
--- /dev/null
+++ b/src/zh/xiaoxintv/src/eu/kanade/tachiyomi/animeextension/zh/xiaoxintv/Xiaoxintv.kt
@@ -0,0 +1,278 @@
+package eu.kanade.tachiyomi.animeextension.zh.xiaoxintv
+
+import android.app.Application
+import android.content.SharedPreferences
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.Request
+import okhttp3.Response
+import org.jsoup.nodes.Document
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import uy.kohesive.injekt.injectLazy
+
+private object HotSortFilter :
+    PathFilter(FilterType.SORT.title, arrayOf(SearchSort("人气", "hits")))
+
+class Xiaoxintv : AnimeHttpSource() {
+    override val baseUrl: String
+        get() = "https://xiaoxintv.cc"
+    override val lang: String
+        get() = "zh"
+    override val name: String
+        get() = "小宝影院"
+    override val supportsLatest: Boolean
+        get() = true
+
+    private val majorSearchTypeSet: Array<SearchType>
+        get() = defaultMajorSearchTypeSet
+    private val searchSortTypeSet: Array<SearchSort>
+        get() = defaultSortTypeSet
+    private val filterUpdateRecord by lazy {
+        majorSearchTypeSet.associateWith {
+            false
+        }.toMutableMap()
+    }
+    private val json by injectLazy<Json>()
+    private val preferences: SharedPreferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    override fun animeDetailsParse(response: Response): SAnime {
+        val document = response.asJsoup()
+        return SAnime.create().apply {
+            thumbnail_url =
+                document.select(".myui-vodlist__thumb.picture img").attr("data-original")
+            url = document.select(".myui-vodlist__thumb.picture").attr("href")
+            title = document.select(".myui-content__detail .title").text()
+            author = document.selectFirst("p.data:contains(主演：)")?.text()
+            artist = document.selectFirst("p.data:contains(导演：)")?.text()
+            description = document.selectFirst("p.data:contains(简介：)")?.ownText()
+        }
+    }
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val document = response.asJsoup()
+        return document.select("#playlist1 ul li").mapIndexed { index, element ->
+            SEpisode.create().apply {
+                url = element.select("a").attr("href")
+                name = element.attr("title")
+                episode_number = index.toFloat()
+            }
+        }.reversed()
+    }
+
+    private fun findVideoUrl(document: Document): String {
+        val script = document.select("script:containsData(player_aaaa)").first()!!.data()
+        val info = script.substringAfter("player_aaaa=").let { json.parseToJsonElement(it) }
+        return info.jsonObject["url"]!!.jsonPrimitive.content
+    }
+
+    override fun videoListParse(response: Response): List<Video> {
+        val document = response.asJsoup()
+        val videoUrl = findVideoUrl(document)
+        return listOf(Video(videoUrl, "小宝影院", videoUrl))
+    }
+
+    override fun latestUpdatesParse(response: Response): AnimesPage {
+        return searchFilterParse(response)
+    }
+
+    override fun latestUpdatesRequest(page: Int) = searchAnimeRequest(
+        page,
+        "",
+        AnimeFilterList(
+            majorSearchTypeSet[0].toFilter(),
+        ),
+    )
+
+    override fun popularAnimeParse(response: Response): AnimesPage {
+        return searchFilterParse(response)
+    }
+
+    override fun popularAnimeRequest(page: Int) = searchAnimeRequest(
+        page,
+        "",
+        AnimeFilterList(
+            majorSearchTypeSet[0].toFilter(),
+            HotSortFilter,
+        ),
+    )
+
+    override fun searchAnimeParse(response: Response): AnimesPage {
+        val requestUrl = response.request.url.toString()
+        if (requestUrl.contains("/vod/search")) {
+            return searchKeywordParse(response)
+        }
+        return searchFilterParse(response)
+    }
+
+    private fun searchFilterParse(response: Response): AnimesPage {
+        val document = response.asJsoup()
+        tryUpdateFilters(response.request, document)
+        val items = document.select(".myui-vodlist__box").map {
+            SAnime.create().apply {
+                val thumbNode = it.select(".myui-vodlist__thumb")
+                url = thumbNode.attr("href")
+                thumbnail_url = thumbNode.attr("data-original")
+                title = thumbNode.attr("title")
+            }
+        }
+        val nextPageUrl = document.select(".myui-page a:contains(下一页)").attr("href")
+        return AnimesPage(items, !response.request.url.toString().endsWith(nextPageUrl))
+    }
+
+    private fun tryUpdateFilters(request: Request, document: Document) {
+        val requestUrl = request.url.toString()
+        val match = filterUpdateRecord.firstNotNullOfOrNull {
+            if (requestUrl.endsWith(it.key.toPath())) {
+                it.key
+            } else {
+                null
+            }
+        }
+        if (match == null || filterUpdateRecord[match] == true) {
+            return
+        }
+        filterUpdateRecord[match] = true
+        var typeList: List<SearchType> = emptyList()
+        var langList: List<SearchLang> = emptyList()
+        var yearList: List<SearchYear> = emptyList()
+        var regionList: List<SearchRegion> = emptyList()
+        var classList: List<SearchClass> = emptyList()
+        document.select(".myui-panel_bd .myui-screen__list").forEach {
+            val li = it.select("li a")
+            val key = li[0].text()
+            val options = li.drop(1)
+            when (key) {
+                FilterType.TYPE.title -> {
+                    typeList = options.mapIndexed { index, element ->
+                        SearchType(
+                            element.text(),
+                            element.attr("href").substringAfter("id/")
+                                .substringBefore("/").removeSuffix(".html"),
+                            ignore = index == 0,
+                        )
+                    }
+                }
+
+                FilterType.LANG.title -> {
+                    langList = options.mapIndexed { index, element ->
+                        SearchLang(element.text(), ignore = index == 0)
+                    }
+                }
+
+                FilterType.YEAR.title -> {
+                    yearList = options.mapIndexed { index, element ->
+                        SearchYear(element.text(), ignore = index == 0)
+                    }
+                }
+
+                FilterType.REGION.title -> {
+                    regionList = options.mapIndexed { index, element ->
+                        SearchRegion(element.text(), ignore = index == 0)
+                    }
+                }
+
+                FilterType.CLASS.title -> {
+                    classList = options.mapIndexed { index, element ->
+                        SearchClass(element.text(), ignore = index == 0)
+                    }
+                }
+
+                else -> {}
+            }
+        }
+        val config = SearchFilterConfig(typeList, classList, yearList, langList, regionList)
+        if (config.isEmpty()) {
+            return
+        }
+        preferences.saveSearchFilterConfig(match.id, config, json)
+    }
+
+    private fun searchKeywordParse(response: Response): AnimesPage {
+        val document = response.asJsoup()
+        val items = document.select("#searchList li").map {
+            SAnime.create().apply {
+                val thumbNode = it.select("a.myui-vodlist__thumb")
+                url = thumbNode.attr("href")
+                thumbnail_url = thumbNode.attr("data-original")
+                title = thumbNode.attr("title")
+            }
+        }
+        val nextPageUrl = document.select(".myui-page a:contains(下一页)").attr("href")
+        return AnimesPage(items, !response.request.url.toString().endsWith(nextPageUrl))
+    }
+
+    private fun keywordQuery(page: Int, query: String): Request {
+        val searchUrl = baseUrl.toHttpUrl().newBuilder()
+            .addPathSegments("index.php/vod/search")
+        if (page > 1) {
+            searchUrl.addPathSegments("page/$page/wd/$query")
+        } else {
+            searchUrl.addQueryParameter("wd", query)
+        }
+        return GET(searchUrl.build())
+    }
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        if (query.isNotBlank()) {
+            return keywordQuery(page, query)
+        }
+        val searchUrl = baseUrl.toHttpUrl().newBuilder().addPathSegments("index.php/vod/show")
+        val filterPath = filters.flatMap {
+            if (it is GroupFilter) {
+                it.state
+            } else {
+                listOf(it)
+            }
+        }.filterIsInstance<PathFilter>().map { it.selected }.toPath()
+        if (filterPath.isEmpty()) {
+            searchUrl.addPathSegments(majorSearchTypeSet[0].toPath().removePrefix("/"))
+        } else {
+            searchUrl.addPathSegments(filterPath)
+        }
+        if (page > 1) {
+            searchUrl.addPathSegments("page/$page")
+        }
+        return GET(searchUrl.build())
+    }
+
+    private fun List<SearchBean>.toFilter(name: String): PathFilter? {
+        if (isEmpty()) {
+            return null
+        }
+        return PathFilter(name, toTypedArray())
+    }
+
+    override fun getFilterList(): AnimeFilterList {
+        val groupFilters = majorSearchTypeSet.map { majorType ->
+            val config = preferences.findSearchFilterConfig(majorType.id, json)
+            val filters = listOfNotNull(
+                config.type.toFilter(FilterType.TYPE.title),
+                config.region.toFilter(FilterType.REGION.title),
+                config.category.toFilter(FilterType.CLASS.title),
+                config.year.toFilter(FilterType.YEAR.title),
+                config.lang.toFilter(FilterType.LANG.title),
+            )
+            GroupFilter(majorType.name, filters)
+        }.toTypedArray()
+        return AnimeFilterList(
+            PathFilter("主分类", majorSearchTypeSet),
+            PathFilter(FilterType.SORT.title, searchSortTypeSet),
+            AnimeFilter.Header("展开下方与主分类对应分组可进行更多设置"),
+            *groupFilters,
+        )
+    }
+}