diff --git a/src/es/animefenix/build.gradle b/src/es/animefenix/build.gradle
index f08ec865..61e7fe45 100644
--- a/src/es/animefenix/build.gradle
+++ b/src/es/animefenix/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Animefenix'
     extClass = '.Animefenix'
-    extVersionCode = 42
+    extVersionCode = 41
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/AnimeFenixFilters.kt b/src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/AnimeFenixFilters.kt
index 65c9aa4e..eaab6fbf 100644
--- a/src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/AnimeFenixFilters.kt
+++ b/src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/AnimeFenixFilters.kt
@@ -78,7 +78,7 @@ object AnimeFenixFilters {
 
     class SortFilter : QueryPartFilter("Orden", AnimeFenixFiltersData.SORT)
 
-    object AnimeFenixFiltersData {
+    private object AnimeFenixFiltersData {
         val YEARS = (1990..Calendar.getInstance().get(Calendar.YEAR)).map { Pair("$it", "$it") }.reversed().toTypedArray()
 
         val TYPES = arrayOf(
diff --git a/src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/Animefenix.kt b/src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/Animefenix.kt
index 8bf7dfeb..4e597c5f 100644
--- a/src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/Animefenix.kt
+++ b/src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/Animefenix.kt
@@ -46,24 +46,8 @@ class Animefenix : ConfigurableAnimeSource, AnimeHttpSource() {
 
     private val preferences: SharedPreferences by lazy { Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000) }
 
-    private object CSSQuery {
-        object AnimeList {
-            const val GRID = "main div.container div.grid"
-            const val ELEMENT = "a"
-            const val ELEMENT_URL = "a"
-            const val ELEMENT_TITLE = "div div h3"
-            const val ELEMENT_THUMBNAIL_URL = "img"
-            const val ELEMENT_STATUS = "div div span.bg-zinc-700"
-            const val NEXT = "a:has(span.sr-only:contains(Next))"
-        }
-
-        object EpisodeList {
-            const val EPISODE = "div.container div.bg-zinc-800 ul li"
-            const val NUMBER = "a span span"
-            const val URL = "a"
-        }
-    }
     companion object {
+        private val SERVER_REGEX = """tabsArray\['?\d+'?]\s*=\s*['\"](https[^'\"]+)['\"]""".toRegex()
         private const val PREF_QUALITY_KEY = "preferred_quality"
         private const val PREF_QUALITY_DEFAULT = "1080"
         private val QUALITY_LIST = arrayOf("1080", "720", "480", "360")
@@ -82,17 +66,13 @@ class Animefenix : ConfigurableAnimeSource, AnimeHttpSource() {
 
     override fun popularAnimeParse(response: Response): AnimesPage {
         val document = response.asJsoup()
-
-        val grid = document.select(CSSQuery.AnimeList.GRID)[1]
-
-        val elements = grid.select(CSSQuery.AnimeList.ELEMENT)
-        val nextPage = document.select(CSSQuery.AnimeList.NEXT).any()
+        val elements = document.select("main > div.container > div.grid > div.group")
+        val nextPage = document.select("nav[aria-label=Pagination] span:containsOwn(Next)").any()
         val animeList = elements.map { element ->
             SAnime.create().apply {
-                setUrlWithoutDomain(element.select(CSSQuery.AnimeList.ELEMENT_URL).attr("abs:href"))
-                title = element.select(CSSQuery.AnimeList.ELEMENT_TITLE).text()
-                thumbnail_url = element.select(CSSQuery.AnimeList.ELEMENT_THUMBNAIL_URL).attr("abs:src")
-                status = parseStatus(element.select(CSSQuery.AnimeList.ELEMENT_STATUS).text())
+                setUrlWithoutDomain(element.selectFirst("a")!!.attr("abs:href"))
+                title = element.selectFirst("div h3.text-primary")!!.ownText()
+                thumbnail_url = element.selectFirst("img.object-cover")?.attr("abs:src")
             }
         }
         return AnimesPage(animeList, nextPage)
@@ -116,12 +96,10 @@ class Animefenix : ConfigurableAnimeSource, AnimeHttpSource() {
 
     override fun episodeListParse(response: Response): List<SEpisode> {
         val document = response.asJsoup()
-        return document.select(CSSQuery.EpisodeList.EPISODE).map { it ->
-            val epNum = it.select(CSSQuery.EpisodeList.NUMBER).text().replace("Episodio", "")
+        return document.select("div.container > div > ul > li").map { element ->
             SEpisode.create().apply {
-                episode_number = epNum.toFloat()
-                name = "Episodio $epNum"
-                setUrlWithoutDomain(it.select(CSSQuery.EpisodeList.URL).attr("abs:href"))
+                name = element.selectFirst("span > span")!!.ownText()
+                setUrlWithoutDomain(element.selectFirst("a")!!.attr("abs:href"))
             }
         }
     }
@@ -129,11 +107,8 @@ class Animefenix : ConfigurableAnimeSource, AnimeHttpSource() {
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
         val videoList = mutableListOf<Video>()
-        val servers = document.selectFirst("script:containsData(var tabsArray)")!!.data()
-            .split("\n")
-            .filter { it.contains("tabsArray[") }
-            .map { it.split(" = ").last().trim().trim(';').trim('"') }
-            .filter { it.contains("https") }
+        val serversData = document.selectFirst("script:containsData(var tabsArray)")?.data() ?: throw Exception("No se encontraron servidores")
+        val servers = SERVER_REGEX.findAll(serversData).map { it.groupValues[1] }.toList()
 
         servers.forEach { server ->
             val decodedUrl = URLDecoder.decode(server, "UTF-8")
diff --git a/src/zh/xfani/build.gradle b/src/zh/xfani/build.gradle
index a7ccc34c..71047c71 100644
--- a/src/zh/xfani/build.gradle
+++ b/src/zh/xfani/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Xfani'
     extClass = '.Xfani'
-    extVersionCode = 2
+    extVersionCode = 3
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Filters.kt b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Filters.kt
index 17c9656b..4072b453 100644
--- a/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Filters.kt
+++ b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Filters.kt
@@ -52,7 +52,10 @@ class VersionFilter(
 
 class LetterFilter(
     tags: Array<String> = "ABCDEFGHIJKLMNOPQRSTUYWXYZ".map { it.toString() }.toMutableList()
-        .also { it.add("0-9") }.toTypedArray(),
+        .also {
+            it.add(0, "全部")
+            it.add("0-9")
+        }.toTypedArray(),
 ) : TagFilter("字母", tags)
 
 class SortFilter(
@@ -62,3 +65,5 @@ class SortFilter(
         "按评分" to "score",
     ),
 ) : SelectFilter("排序", kv)
+
+class YearFilter(tags: Array<String>) : TagFilter("年份", tags)
diff --git a/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Xfani.kt b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Xfani.kt
index 77a1e455..c0f5041c 100644
--- a/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Xfani.kt
+++ b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Xfani.kt
@@ -17,7 +17,12 @@ import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 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 kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
@@ -27,6 +32,7 @@ import okhttp3.MultipartBody
 import okhttp3.OkHttpClient
 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
@@ -37,6 +43,13 @@ import javax.net.ssl.SSLHandshakeException
 import javax.net.ssl.TrustManager
 import javax.net.ssl.X509TrustManager
 
+enum class FilterUpdateState {
+    NONE,
+    UPDATING,
+    UPDATED,
+    FAILED,
+}
+
 class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
     override val baseUrl: String
         get() = "https://dick.xfani.com"
@@ -52,6 +65,8 @@ class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
         Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
     }
     private val numberRegex = Regex("\\d+")
+    private var filterState = FilterUpdateState.NONE
+
     private fun OkHttpClient.Builder.ignoreAllSSLErrors(): OkHttpClient.Builder {
         val naiveTrustManager =
             @SuppressLint("CustomX509TrustManager")
@@ -74,12 +89,13 @@ class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
         return this
     }
 
-    override val client: OkHttpClient
-        get() = if (preferences.getBoolean(PREF_KEY_IGNORE_SSL_ERROR, false)) {
-            network.client.newBuilder().ignoreAllSSLErrors().build()
+    override val client: OkHttpClient by lazy {
+        if (preferences.getBoolean(PREF_KEY_IGNORE_SSL_ERROR, false)) {
+            network.client.newBuilder().ignoreAllSSLErrors()
         } else {
-            network.client.newBuilder().addInterceptor(::checkSSLErrorInterceptor).build()
-        }
+            network.client.newBuilder().addInterceptor(::checkSSLErrorInterceptor)
+        }.addInterceptor(::updateFiltersInterceptor).build()
+    }
 
     private val selectedVideoSource
         get() = preferences.getString(PREF_KEY_VIDEO_SOURCE, DEFAULT_VIDEO_SOURCE)!!.toInt()
@@ -92,6 +108,13 @@ class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
         }
     }
 
+    private fun updateFiltersInterceptor(chain: Interceptor.Chain): Response {
+        if (filterState == FilterUpdateState.NONE) {
+            updateFilter()
+        }
+        return chain.proceed(chain.request())
+    }
+
     override fun animeDetailsParse(response: Response): SAnime {
         val jsoup = response.asJsoup()
         return SAnime.create().apply {
@@ -118,10 +141,37 @@ class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
     }
 
     override fun videoListParse(response: Response): List<Video> {
-        val script = response.asJsoup().select("script:containsData(player_aaaa)").first()!!.data()
+        val requestUrl = response.request.url
+        val currentPath = requestUrl.encodedPath
+        val currentAnthology = response.request.url.pathSegments.last()
+        val document = response.asJsoup()
+        val videoUrl = findVideoUrl(document)
+        val sourceList =
+            document.select(".player-anthology .anthology-list .anthology-list-box")
+                .map { element ->
+                    element.select(".anthology-list-play li a").eachAttr("href")
+                        .first { it.endsWith(currentAnthology) }
+                }
+        val sourceNameList = document.select(".anthology-tab .swiper-wrapper a").map {
+            it.ownText().trim()
+        }
+        return sourceList.zip(sourceNameList) { url, name ->
+            if (url.endsWith(currentPath)) {
+                Video("$baseUrl$url", name, videoUrl = videoUrl)
+            } else {
+                Video("$baseUrl$url", name, videoUrl = null)
+            }
+        }.sortedByDescending { it.videoUrl != null }
+    }
+
+    override fun videoUrlParse(response: Response): String {
+        return findVideoUrl(response.asJsoup())
+    }
+
+    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) }
-        val url = info.jsonObject["url"]!!.jsonPrimitive.content
-        return listOf(Video(url, "SingleFile", videoUrl = url))
+        return info.jsonObject["url"]!!.jsonPrimitive.content
     }
 
     override fun latestUpdatesParse(response: Response): AnimesPage {
@@ -157,6 +207,9 @@ class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
     }
 
     override fun searchAnimeParse(response: Response): AnimesPage {
+        if (response.request.url.toString().contains("api/vod")) {
+            return vodListToAnimePageList(response)
+        }
         val jsoup = response.asJsoup()
         val items = jsoup.select("div.public-list-box.search-box.flex.rel")
         val animeList = items.map { item ->
@@ -183,25 +236,71 @@ class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
         return numbers.size == 2 && numbers[0] != numbers[1]
     }
 
+    private fun updateFilter() {
+        filterState = FilterUpdateState.UPDATING
+        val handler = CoroutineExceptionHandler { _, _ ->
+            filterState = FilterUpdateState.FAILED
+        }
+        CoroutineScope(Dispatchers.IO + handler).launch {
+            val jsoup = client.newCall(GET("$baseUrl/show/1/html")).awaitSuccess().asJsoup()
+            // update class and year filter type
+            val classList = jsoup.select("li[data-type=class]").eachAttr("data-val")
+            val yearList = jsoup.select("li[data-type=year]").eachAttr("data-val")
+            preferences.edit()
+                .putString(PREF_KEY_FILTER_CLASS, classList.joinToString())
+                .putString(PREF_KEY_FILTER_YEAR, yearList.joinToString())
+                .apply()
+            filterState = FilterUpdateState.UPDATED
+        }
+    }
+
+    private fun SharedPreferences.createTagFilter(
+        key: String,
+        block: (tags: Array<String>) -> TagFilter?,
+    ): TagFilter? {
+        val savedTags = getString(key, "")!!
+        if (savedTags.isBlank()) {
+            return block(emptyArray())
+        }
+        val tags = savedTags.split(", ").toMutableList()
+        if (tags[0].isBlank()) {
+            tags[0] = "全部"
+        }
+        return block(tags.toTypedArray())
+    }
+
     override fun getFilterList(): AnimeFilterList {
         return AnimeFilterList(
-            AnimeFilter.Header("设置筛选后关键字搜索会失效"),
-            TypeFilter(),
-            ClassFilter(),
-            VersionFilter(),
-            LetterFilter(),
-            SortFilter(),
+            listOfNotNull(
+                AnimeFilter.Header("以下筛选对搜索结果无效"),
+                TypeFilter(),
+                preferences.createTagFilter(PREF_KEY_FILTER_CLASS) {
+                    if (it.isEmpty()) {
+                        ClassFilter()
+                    } else {
+                        ClassFilter(it)
+                    }
+                },
+                preferences.createTagFilter(PREF_KEY_FILTER_YEAR) {
+                    if (it.isEmpty()) {
+                        null
+                    } else {
+                        YearFilter(it)
+                    }
+                },
+                VersionFilter(),
+                LetterFilter(),
+                SortFilter(),
+            ),
         )
     }
 
     private fun doSearch(page: Int, query: String): Request {
         val url = baseUrl.toHttpUrl().newBuilder()
         if (page <= 1) {
-            url.addPathSegment("search.html")
-                .addQueryParameter("wd", query)
+            url.addPathSegment("search.html").addQueryParameter("wd", query)
         } else {
-            url.addPathSegments("search/wd/")
-                .addPathSegment(query)
+            url.addPathSegments("search/wd/").addPathSegment(query)
                 .addPathSegments("page/$page.html")
         }
         return GET(url.build())
@@ -211,19 +310,16 @@ class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
         if (query.isNotBlank()) {
             return doSearch(page, query)
         }
-        val url = baseUrl.toHttpUrl().newBuilder()
-            .addPathSegments("index.php/api/vod")
-            .build()
+        val url = baseUrl.toHttpUrl().newBuilder().addPathSegments("index.php/api/vod").build()
         val time = System.currentTimeMillis() / 1000
-        val formBody = MultipartBody.Builder()
-            .setType(MultipartBody.FORM)
-            .addFormDataPart("page", "$page")
-            .addFormDataPart("time", "$time")
-            .addFormDataPart("key", generateKey(time))
+        val formBody =
+            MultipartBody.Builder().setType(MultipartBody.FORM).addFormDataPart("page", "$page")
+                .addFormDataPart("time", "$time").addFormDataPart("key", generateKey(time))
         filters.forEach { filter ->
             when (filter) {
                 is TypeFilter -> formBody.addFormDataPart("type", filter.selected)
                 is ClassFilter -> formBody.addFormDataPart("class", filter.selected)
+                is YearFilter -> formBody.addFormDataPart("year", filter.selected)
                 is VersionFilter -> formBody.addFormDataPart("version", filter.selected)
                 is LetterFilter -> formBody.addFormDataPart("letter", filter.selected)
                 is SortFilter -> formBody.addFormDataPart("by", filter.selected)
@@ -247,7 +343,7 @@ class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
                     setDefaultValue(DEFAULT_VIDEO_SOURCE)
                     summary = "当前选择：${entries[selectedVideoSource]}"
                     setOnPreferenceChangeListener { _, newValue ->
-                        summary = "当前选择 ${entries[(newValue as String).toInt()]}"
+                        summary = "当前选择：${entries[(newValue as String).toInt()]}"
                         true
                     }
                 },
@@ -270,6 +366,9 @@ class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
         const val PREF_KEY_VIDEO_SOURCE = "PREF_KEY_VIDEO_SOURCE"
         const val PREF_KEY_IGNORE_SSL_ERROR = "PREF_KEY_IGNORE_SSL_ERROR"
 
+        const val PREF_KEY_FILTER_CLASS = "PREF_KEY_FILTER_CLASS"
+        const val PREF_KEY_FILTER_YEAR = "PREF_KEY_FILTER_YEAR"
+
         const val DEFAULT_VIDEO_SOURCE = "0"
 
         val STATUS_STR_MAPPING = mapOf(